diff --git a/es/book/aliases.md b/es/book/aliases.md index 59e7a205639..77aea3251b9 100644 --- a/es/book/aliases.md +++ b/es/book/aliases.md @@ -9,16 +9,16 @@ Un alias te permite crear un nombre corto para un bloque de comandos. Cuando se Ejemplo: ``` -> alias ls-nombres [] { ls | select name } -> ls-nombres -────┬──────────────────── - # │ name -────┼──────────────────── - 0 │ 404.html - 1 │ CONTRIBUTING.md - 2 │ Gemfile - 3 │ Gemfile.lock - 4 │ LICENSE +alias ls-nombres [] { ls | select name } +ls-nombres +# => ────┬──────────────────── +# => # │ name +# => ────┼──────────────────── +# => 0 │ 404.html +# => 1 │ CONTRIBUTING.md +# => 2 │ Gemfile +# => 3 │ Gemfile.lock +# => 4 │ LICENSE ``` ## Parámetros @@ -26,9 +26,9 @@ Ejemplo: También pueden tomar parámetros opcionales que son pasadas al bloque. Cada parámetro se convierte en una variable en el bloque. ``` -> alias decir [mensaje] { echo $mensaje } -> decir "¡hola!" -¡hola! +alias decir [mensaje] { echo $mensaje } +decir "¡hola!" +# => ¡hola! ``` Puedes tener un número arbitrario de estos argumentos. Cuando el usuario no proporciona un valor, la variable en el bloque evaulara a `Nothing` y será eliminada. diff --git a/es/book/cargando_datos.md b/es/book/cargando_datos.md index b243b6f47e9..0ebafb84353 100644 --- a/es/book/cargando_datos.md +++ b/es/book/cargando_datos.md @@ -7,16 +7,16 @@ Hemos visto como puedes usar comandos como `ls`, `ps`, `date`, y `sys` para carg Una de las funciones más destacadas de Nu para trabajar con datos es el comando `open`. Es una multi-herramienta que puede trabajar con varios formatos de datos. Para ver qué significa esto intentemos abrir un archivo en formato json: ``` -> open editors/vscode/package.json -------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- - name | descript | author | license | version | reposito | publishe | categori | keywords | engines | activati | main | contribu | scripts | devDepen - | ion | | | | ry | r | es | | | onEvents | | tes | | dencies -------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- - lark | Lark | Lark | MIT | 1.0.0 | [object] | vscode | [0 | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object] - | support | develope | | | | | items] | | | | tension | | | - | for VS | rs | | | | | | | | | | | | - | Code | | | | | | | | | | | | | -------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- +open editors/vscode/package.json +# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- +# => name | descript | author | license | version | reposito | publishe | categori | keywords | engines | activati | main | contribu | scripts | devDepen +# => | ion | | | | ry | r | es | | | onEvents | | tes | | dencies +# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- +# => lark | Lark | Lark | MIT | 1.0.0 | [object] | vscode | [0 | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object] +# => | support | develope | | | | | items] | | | | tension | | | +# => | for VS | rs | | | | | | | | | | | | +# => | Code | | | | | | | | | | | | | +# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- ``` De manera similar a `ls`, abrir un tipo de archivo que Nu entienda nos devolverá algo más que solo texto (o una secuencia de bytes). Aquí abrimos el archivo "package.json" de un proyecto de JavaScript. Nu puede reconocer y abrir el texto en JSON y devolvernos una tabla de datos. @@ -24,8 +24,8 @@ De manera similar a `ls`, abrir un tipo de archivo que Nu entienda nos devolver Si deseamos revisar la versión del proyecto que estamos mirando podemos usar el comando `get`. ``` -> open editors/vscode/package.json | get version -1.0.0 +open editors/vscode/package.json | get version +# => 1.0.0 ``` Actualmente Nu soporta los siguiente formatos para cargar datos directamente a tablas: @@ -40,7 +40,7 @@ Actualmente Nu soporta los siguiente formatos para cargar datos directamente a t ¿Pero qué sucede si cargas un archivo de texto que no sea de estos? Probemos: ``` -> open README.md +open README.md ``` Se nos muestra el contenido del archivo. Si el archivo es muy grande obtendremos una vista práctica desplazable para mirar el archivo y luego regresar a la terminal. Para ayudar con legibilidad Nu resaltará la sintaxis de formatos comunes de archivos como de código, markdown, y más. @@ -54,10 +54,10 @@ Una parte importante de trabajar con datos llegando fuera de Nu es que no siempr Imaginemos que nos proporcionan estos datos de archivo: ``` -> open gente.txt -Octavia | Butler | Writer -Bob | Ross | Painter -Antonio | Vivaldi | Composer +open gente.txt +# => Octavia | Butler | Writer +# => Bob | Ross | Painter +# => Antonio | Vivaldi | Composer ``` Cada pedazo de dato que deseamos está separada por el símbolo de tubería (pipe '|'), y cada persona está en líneas separadas. Nu no contiene un formato de archivo delimitado con pleca ('|') predeterminado, por lo que tendremos que parsearlo nosotros mismos. @@ -65,79 +65,79 @@ Cada pedazo de dato que deseamos está separada por el símbolo de tubería (pip Lo primero que queremos hacer al cargar el archivo es trabajarlo línea por línea: ``` -> open gente.txt | lines ----+------------------------------ - # | value ----+------------------------------ - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+------------------------------ +open gente.txt | lines +# => ---+------------------------------ +# => # | value +# => ---+------------------------------ +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+------------------------------ ``` Podemos darnos cuenta que estamos trabajando con las líneas porque estamos de vuelta a una lista. Nuestro próximo paso es mirar si podemos dividir las filas a algo más útil. Para eso, usaremos el comando `split`. `split`, como implica el nombre, nos da una manera de dividir una cadena delimitada. Usaremos el subcomando `column` para dividir el contenido a varias columnas. Indicamos cuál es el delimitador y se hace el resto: ``` -> open gente.txt | lines | split column "|" ----+----------+-----------+----------- - # | Column1 | Column2 | Column3 ----+----------+-----------+----------- - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+----------+-----------+----------- +open gente.txt | lines | split column "|" +# => ---+----------+-----------+----------- +# => # | Column1 | Column2 | Column3 +# => ---+----------+-----------+----------- +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+----------+-----------+----------- ``` Casi se ve correcto. Parece que hay espacio extra ahí. Cambiemos nuestro delimitador: ``` -> open gente.txt | lines | split column " | " ----+---------+---------+---------- - # | Column1 | Column2 | Column3 ----+---------+---------+---------- - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+---------+---------+---------- +open gente.txt | lines | split column " | " +# => ---+---------+---------+---------- +# => # | Column1 | Column2 | Column3 +# => ---+---------+---------+---------- +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+---------+---------+---------- ``` Nada mal. El comando `split` nos da datos que podemos usar. Adicionalmente nos crea nombres de columnas predeterminadas: ``` -> open gente.txt | lines | split column " | " | get Column1 ----+--------- - # | value ----+--------- - 0 | Octavia - 1 | Bob - 2 | Antonio ----+--------- +open gente.txt | lines | split column " | " | get Column1 +# => ---+--------- +# => # | value +# => ---+--------- +# => 0 | Octavia +# => 1 | Bob +# => 2 | Antonio +# => ---+--------- ``` También podemos nombrar nuestras columnas en vez de usar nombres predeterminados: ``` -> open gente.txt | lines | split column " | " primer_nombre apellido trabajo ----+---------------+-----------+---------- - # | primer_nombre | apellido | trabajo ----+---------------+-----------+---------- - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+---------------+-----------+---------- +open gente.txt | lines | split column " | " primer_nombre apellido trabajo +# => ---+---------------+-----------+---------- +# => # | primer_nombre | apellido | trabajo +# => ---+---------------+-----------+---------- +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+---------------+-----------+---------- ``` Ahora que tenemos nuestros datos en una tabla podemos usar todos los comandos que hemos usado en tablas antes: ``` -> open gente.txt | lines | split column " | " primer_nombre apellido trabajo | sort-by primer_nombre ----+---------------+-----------+---------- - # | primer_nombre | apellido | trabajo ----+---------------+-----------+---------- - 0 | Antonio | Vivaldi | Composer - 1 | Bob | Ross | Painter - 2 | Octavia | Butler | Writer ----+---------------+-----------+---------- +open gente.txt | lines | split column " | " primer_nombre apellido trabajo | sort-by primer_nombre +# => ---+---------------+-----------+---------- +# => # | primer_nombre | apellido | trabajo +# => ---+---------------+-----------+---------- +# => 0 | Antonio | Vivaldi | Composer +# => 1 | Bob | Ross | Painter +# => 2 | Octavia | Butler | Writer +# => ---+---------------+-----------+---------- ``` Hay otros comandos que puedes usar para trabajar con cadenas: @@ -149,12 +149,12 @@ Hay otros comandos que puedes usar para trabajar con cadenas: También hay un conjunto de comandos auxiliares que podemos llamar si conocemos de antemano que los datos tienen una estructura que Nu debería de entender. Por ejemplo, abramos un Rust archivo lock: ``` -> open Cargo.lock -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -[[package]] -name = "adhoc_derive" -version = "0.1.2" +open Cargo.lock +# => # This file is automatically @generated by Cargo. +# => # It is not intended for manual editing. +# => [[package]] +# => name = "adhoc_derive" +# => version = "0.1.2" ``` The `from` command can be used for each of the structured data text formats that Nu can open and understand by passing it the supported format as a subcommand. @@ -162,12 +162,12 @@ The `from` command can be used for each of the structured data text formats that El archivo "Cargo.lock" es un archivo en formato .toml pero la extensión del archivo no es .toml. Está bien, podemos usar el comando `from` usando el subcomando `toml`: ``` -> open Cargo.lock | from toml -----------+------------- - metadata | package -----------+------------- - [object] | [405 items] -----------+------------- +open Cargo.lock | from toml +# => ----------+------------- +# => metadata | package +# => ----------+------------- +# => [object] | [405 items] +# => ----------+------------- ``` El comando `from` se puede usar para cada dato estructurado de formatos de texto que Nu pueda abrir y entender pasando el formato soportado como subcomando. @@ -177,13 +177,13 @@ El comando `from` se puede usar para cada dato estructurado de formatos de texto Mientras es útil poder abrir un archivo e inmediatamente trabajar con una tabla de sus datos, esto no siempre es lo que deseas hacer. Para llegar al texto subyacente, el comando `open` puede tomar una bandera opcional: ``` -> open Cargo.toml --raw -[package] -name = "nu" -version = "0.1.3" -authors = ["Yehuda Katz ", "Sophia Turner <547158+sophiajt@users.noreply.github.com>"] -description = "A shell for the GitHub era" -license = "MIT" +open Cargo.toml --raw +# => [package] +# => name = "nu" +# => version = "0.1.3" +# => authors = ["Yehuda Katz ", "Sophia Turner <547158+sophiajt@users.noreply.github.com>"] +# => description = "A shell for the GitHub era" +# => license = "MIT" ``` ## Abriendo URLs @@ -191,10 +191,10 @@ license = "MIT" Además de cargar archivos desde tu archivos de sistema, también puedes usar el comando `http get` proporcionando una URL. Se cargará el contenido de la URL por internet y devolverá: ``` -> http get http://www.andresrobalino.com/feed.xml ----------- - rss ----------- - [1 item] ----------- +http get http://www.andresrobalino.com/feed.xml +# => ---------- +# => rss +# => ---------- +# => [1 item] +# => ---------- ``` diff --git a/es/book/configuracion.md b/es/book/configuracion.md index 2ccc578185c..575d1da5818 100644 --- a/es/book/configuracion.md +++ b/es/book/configuracion.md @@ -23,7 +23,7 @@ Nu tiene un número pequeño, pero creciente, de variables internas que puedes e Para establecer una de estas variables, puedes usar `config set`. Por ejemplo: ``` -> config set edit_mode "vi" +config set edit_mode "vi" ``` ### Estableciendo una variable desde la tubería @@ -31,7 +31,7 @@ Para establecer una de estas variables, puedes usar `config set`. Por ejemplo: Hay una manera adicional de establecer una variable, y es usar el contenido de la tubería como el valor deseado para la variable. Para esto usa la bandera `set-into`: ``` -> echo "bar" | config set_into foo +echo "bar" | config set_into foo ``` Esto es de utilidad cuando se trabaja con las variables `env` y `path`. @@ -41,12 +41,12 @@ Esto es de utilidad cuando se trabaja con las variables `env` y `path`. Ejecutando el comando `config` sin argumentos mostrará una tabla de las preferencias de configuración actuales: ``` -> config -━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━ - edit_mode │ env │ path │ table_mode -───────────┼────────────────┼──────────────────┼──────────── - emacs │ [table: 1 row] │ [table: 10 rows] │ normal -━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━ +config +# => ━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━ +# => edit_mode │ env │ path │ table_mode +# => ───────────┼────────────────┼──────────────────┼──────────── +# => emacs │ [table: 1 row] │ [table: 10 rows] │ normal +# => ━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━ ``` Nota: si por el momento no has establecido variables de configuración, puede estar vacía. @@ -56,7 +56,7 @@ Nota: si por el momento no has establecido variables de configuración, puede es Usando la bandera `get`, puedes conseguir el valor de una variable: ``` -> config get edit_mode +config get edit_mode ``` ### Eliminando una variable @@ -64,7 +64,7 @@ Usando la bandera `get`, puedes conseguir el valor de una variable: Para eliminar una variable de la configuración, usa la bandera `remove`: ``` -> config remove edit_mode +config remove edit_mode ``` ### Borrar toda la configuración @@ -72,7 +72,7 @@ Para eliminar una variable de la configuración, usa la bandera `remove`: Si deseas borrar toda la configuración y empezar de cero, puedes usar la bandera `clear`. Por supuesto, tenga precaución con esto ya que una vez ejecutado el archivo de configuración también se eliminará. ``` -> config clear +config clear ``` ### Encontrar dónde se almacena el archivo de configuración @@ -93,7 +93,7 @@ config path Es posible que desees cargar la configuración desde una ubicación distinta a la predeterminada. Para hacerlo, usa la bandera `load`: ``` -> config load myconfiguration.toml +config load myconfiguration.toml ``` ## Configurando Nu como shell de inicio de sesión @@ -103,8 +103,8 @@ Para usar Nu como shell de inicio de sesión, necesitarás configurar las variab Antes de cambiarlo, ejecuta Nu dentro de otra shell, como Bash. Luego, obtén el entorno y PATH desde esa shell con los siguientes comandos: ``` -> config set path $nu.path -> config set env $nu.env +config set path $nu.path +config set env $nu.env ``` `$nu.path` y `$nu.env` son valores que están prestablecidas a las variables actuales de entorno y PATH, respectivamente. Una vez que las estableces a la configuración, estarán disponibles cuando uses Nu como shell de inicio de sesión. @@ -112,15 +112,15 @@ Antes de cambiarlo, ejecuta Nu dentro de otra shell, como Bash. Luego, obtén el A continuación, en algunas distribuciones también deberás asegurarte de que Nu esté en la lista en `/etc/shells`: ``` -❯ cat /etc/shells -# /etc/shells: valid login shells -/bin/sh -/bin/dash -/bin/bash -/bin/rbash -/usr/bin/screen -/usr/bin/fish -/home/sophia/.cargo/bin/nu +cat /etc/shells +# => # /etc/shells: valid login shells +# => /bin/sh +# => /bin/dash +# => /bin/bash +# => /bin/rbash +# => /usr/bin/screen +# => /usr/bin/fish +# => /home/sophia/.cargo/bin/nu ``` Con esto, deberías de poder hacer `chsh` y establecer Nu como la shell de inicio de sesión. Luego de cerrar sesión, en el próximo inicio de sesión deberías de recibir un brillante mensaje de Nu. diff --git a/es/book/entorno.md b/es/book/entorno.md index 3398005ff75..d05b0fef2ce 100644 --- a/es/book/entorno.md +++ b/es/book/entorno.md @@ -5,12 +5,12 @@ Una tarea común al usar una shell es controlar el ambiente de entorno que aplic Puedes ver las variables de entorno actuales que se enviarán a las aplicaciones explorando `#nu.env`: ``` -> echo $nu.env -──────────────────────────┬────────────────────────────── - COLORTERM │ truecolor - DBUS_SESSION_BUS_ADDRESS │ unix:path=/run/user/1000/bus - DESKTOP_SESSION │ gnome - DISPLAY │ :1 +echo $nu.env +# => ──────────────────────────┬────────────────────────────── +# => COLORTERM │ truecolor +# => DBUS_SESSION_BUS_ADDRESS │ unix:path=/run/user/1000/bus +# => DESKTOP_SESSION │ gnome +# => DISPLAY │ :1 ``` El ambiente es creador a través de los ajustes en la configuración de Nu y a partir del entorno en el que se ejecuta Nu. Puedes actualizar el ambiente permanentement usando técnicas enumeradas en el capítulo de [configuración](configuracion.md). @@ -18,8 +18,8 @@ El ambiente es creador a través de los ajustes en la configuración de Nu y a p También puedes temporalmente actualizar una variable de entorno cuando ejecutas un comando o tubería de comandos. ``` -> with-env [MI_VARIABLE VALOR] { echo $nu.env.MI_VARIABLE } -VALOR +with-env [MI_VARIABLE VALOR] { echo $nu.env.MI_VARIABLE } +# => VALOR ``` El comando `with-env` establecerá temporalmente la variable de entorno dada (aquí: la variable "MI_VARIABLE" es dada el valor "VALOR"). Una vez hecho esto, el bloque se ejecutará con esta nueva variable de entorno establecida. @@ -29,6 +29,6 @@ A common shorthand, inspired by Bash and others, is also available. You can writ Una atajo común, inspirada en Bash y otros, también está disponible. Puedes escribir el ejemplo anterior como: ``` -> MI_VARIABLE=VALOR echo $nu.env.MI_VARIABLE -VALOR +# => MI_VARIABLE=VALOR echo $nu.env.MI_VARIABLE +# => VALOR ``` diff --git a/es/book/escapando.md b/es/book/escapando.md index f3b247c9ea4..2b16d49dffc 100644 --- a/es/book/escapando.md +++ b/es/book/escapando.md @@ -5,11 +5,11 @@ Nu proporciona una serie de comandos que puedes utilitar en diferentes sistemas Comando de Nu: ``` -> ls +ls ``` Escapa al comando local: ``` -> ^ls +^ls ``` diff --git a/es/book/instalacion.md b/es/book/instalacion.md index f3fb30f6951..b93a2c2d03f 100644 --- a/es/book/instalacion.md +++ b/es/book/instalacion.md @@ -19,8 +19,7 @@ Descarga el archivo actual `.zip` [de la página de releases](https://github.com y posteriormente agrega Nu a la variable de entorno `PATH`. Una vez que hagamos eso, podemos ejecutar Nu usando el comando `nu`: ``` - > nu - C:\Users\user> + nu ``` Si te encuentras usando [Windows Terminal](https://github.com/microsoft/terminal) puedes establecer `nu` como la shell por defecto añadiendo: @@ -113,7 +112,7 @@ brew install openssl cmake Una vez instaladas las depependencias que Nu necesita, podemos instalarla usando el comando `cargo` que viene con el compilador Rust. ``` -> cargo install nu --locked +cargo install nu --locked ``` ¡Eso es todo! Cargo hará el trabajo de descarga Nu junto con sus dependencias, construirla e instalarla en el bin path de cargo para que podamos arrancarlo. @@ -121,15 +120,16 @@ Una vez instaladas las depependencias que Nu necesita, podemos instalarla usando Si deseas instalar con más funcionalidades, puedes hacer: ``` -> cargo install nu --locked --features=stable +cargo install nu --locked --features=stable ``` Para todas las funcionalidades disponibles, la manera más fácil es descargar la fuente de Nu y construírlo usted mismo usando las herramientas de Rust: ``` -> git clone https://github.com/nushell/nushell.git -> cd nushell -nushell> cargo install --path . --locked --force --features=stable +git clone https://github.com/nushell/nushell.git +cd nushell +# ./nushell +cargo install --path . --locked --force --features=stable Para que esto funcione, asegúrate de tener todas las dependencias instaladas (que se muestran arriba) en el sistema. @@ -148,7 +148,7 @@ También podemos contruir nuestro propio Nu directamente desde github. Esto nos ``` -> git clone https://github.com/nushell/nushell.git +git clone https://github.com/nushell/nushell.git ``` @@ -156,8 +156,9 @@ Git nos clonará el repositorio principal de Nu. Partiendo de ahí podemos contr ``` -> cd nushell -> nushell> cargo build --workspace --features=stable; cargo run --features=stable +cd nushell +# ./nushell +cargo build --workspace --features=stable; cargo run --features=stable ``` @@ -165,7 +166,7 @@ También puedes construir y arrancar Nu en modo release: ``` -nushell> cargo build --release --workspace --features=stable; cargo run --release --features=stable +cargo build --release --workspace --features=stable; cargo run --release --features=stable ``` Gente familiarizada con Rust se preguntará la razón por la que hacemos un paso "build" y otro paso "run" si "run" construye por defecto. Esto es para evitar una deficiencia de la nueva opción `default-run` en Cargo y asegurar que todos los plugins se construyan aunque puede que esto no sea necesario en el futuro. diff --git a/es/book/matematicas.md b/es/book/matematicas.md index fdbe6e40973..f3f5c50e9e2 100644 --- a/es/book/matematicas.md +++ b/es/book/matematicas.md @@ -5,8 +5,8 @@ Hay veces que simplemente necesitas sumar un par de números cuando te encuentra ## Sumar, Restar, Mupltiplicar, Dividir ``` -> 1 + 3 -4 +1 + 3 +# => 4 ``` En Nu puedes realizar lo usual: sumar, restar, mutiplicar y dividir con los operadores `+`, `-`, `*`, y `/` respectivamente. Precedencia de operadores es respetada, por lo que `1 + 2 * 3` será tratado como `1 + (2 * 3)`. Lo que nos lleva a paréntesis. @@ -20,13 +20,13 @@ Puedes usar paréntesis para agrupar expresiones matemáticas en modo `math`. Es Puedes revisar si un valor se encuentra dentro de un conjunto de valores o no, usando los operadores `in` y `not-in`. ``` -> 1 in [1 2 3] -true +1 in [1 2 3] +# => true ``` ``` -> 1 not-in [1 2 3] -false +1 not-in [1 2 3] +# => false ``` ## =~ y !~ @@ -34,13 +34,13 @@ false Puedes revisar si una cadena se encuentra dentro de otra cadena o no, usando `=~` y `!~`. ``` -> "gallinagallo" =~ "gallo" -true +"gallinagallo" =~ "gallo" +# => true ``` ``` -> "gallinagallo" !~ "pollito" -true +"gallinagallo" !~ "pollito" +# => true ``` ## Comparaciones @@ -67,8 +67,8 @@ Las operaciones matemáticas son evaluadas de la siguiente manera (de mayor prec - Suma (`+`) y Resta (`-`) ``` -> 3 * (1 + 2) -9 +3 * (1 + 2) +# => 9 ``` ## Modo matemático abreviado @@ -78,13 +78,13 @@ Hay una variación abreviada "short-hand" en modo matemático incluída en Nushe Es probable que ya la usaste antes. Por ejemplo, supongamos que deseamos ver filas de `ls` donde para cada uno por lo menos tenga 10 kilobytes, podemos escribir: ``` -> ls | where size > 10kb +ls | where size > 10kb ``` El comando `where memoria > 10kb` tiene dos partes: El nombre del comando `where` y su abreviación expresión matemática `size > 10kb`. Indicamos `abreviada` debido a que `size` es una versión acortada de escribir `$it.size`. Si observamos su forma completamente expandida, veríamos: ``` -> ls | where {|$it| $it.size > 10kb } +ls | where {|$it| $it.size > 10kb } ``` Usamos el modo abreviado para trabajar con datos de columnas para no tener que repetir la forma expandida siempre. diff --git a/es/book/metadatos.md b/es/book/metadatos.md index 481e7bb0f71..207059d760b 100644 --- a/es/book/metadatos.md +++ b/es/book/metadatos.md @@ -3,14 +3,14 @@ Al usar Nu es posible que hayan momentos que has encontrado como si algo extra sucediera detrás de escenas. Por ejemplo digamos que intentas abrir un archivo soportado por Nu para luego olvidarte e intentar convertir nuevamente: ``` -> open Cargo.toml | from toml -error: Expected a string from pipeline -- shell:1:18 -1 | open Cargo.toml | from toml - | ^^^^^^^^^ requires string input -- shell:1:5 -1 | open Cargo.toml | from toml - | ---------- object originates from here +open Cargo.toml | from toml +# => error: Expected a string from pipeline +# => - shell:1:18 +# => 1 | open Cargo.toml | from toml +# => | ^^^^^^^^^ requires string input +# => - shell:1:5 +# => 1 | open Cargo.toml | from toml +# => | ---------- object originates from here ``` El mensaje de error nos indica que hemos proporcionado a `from toml` algo distinto a una cadena pero también el origen del valor. ¿Cómo puede saberlo? @@ -20,12 +20,12 @@ Valores que fluyen a través de la tubería en Nu comúnmente disponen de inform Nuevamente ejecutemos el comando `open` pero esta vez observaremos las etiquetas que nos devuelve: ``` -> open Cargo.toml | tags -----------+---------------------------------------- - span | anchor -----------+---------------------------------------- - [object] | /home/sophia/Source/nushell/Cargo.toml -----------+---------------------------------------- +open Cargo.toml | tags +# => ----------+---------------------------------------- +# => span | anchor +# => ----------+---------------------------------------- +# => [object] | /home/sophia/Source/nushell/Cargo.toml +# => ----------+---------------------------------------- ``` Actualmente rastreamos dos pedazos de metadatos de los valores en la tubería. Puedes darte cuenta que disponemos del ancla que nos da la ubicación de dónde se cargaron los datos. Esto puede ayudar a Nu entender mejor como presentar datos. @@ -33,12 +33,12 @@ Actualmente rastreamos dos pedazos de metadatos de los valores en la tubería. P También hay lapso (span). Miremos más de cerca a eso: ``` -> open Cargo.toml | tags | get span --------+----- - start | end --------+----- - 5 | 15 --------+----- +open Cargo.toml | tags | get span +# => -------+----- +# => start | end +# => -------+----- +# => 5 | 15 +# => -------+----- ``` El lapso "start" y "end" aquí se refiere en dónde estará el subrayado en la línea. Si cuentas a partir de 5 y luego hasta 15 podrás observar que se alinea con el nombre de archivo "Cargo.toml". Así es como Nu sabía qué subrayar apropiadamente en el error que vimos previamente. diff --git a/es/book/pipeline.md b/es/book/pipeline.md index 5ef57677c9d..a1cab1e6f78 100644 --- a/es/book/pipeline.md +++ b/es/book/pipeline.md @@ -7,7 +7,7 @@ Uno de los diseños centrales de Nu es la tubería (pipeline), una idea de dise Una tubería (pipeline) es construída con tres partes: la entrada, el filtro, y la salida. ``` -> open "Cargo.toml" | inc package.version | save "Cargo_new.toml" +open "Cargo.toml" | inc package.version | save "Cargo_new.toml" ``` El primer comando, `open "Cargo.toml"`, es una entrada (a veces también llamada "fuente" o "productor"). Esto crea o carga datos y lo canaliza en la tubería. Es de entrada para la tubería tener valores y poder trabajarlas. Comandos como `ls` también son entradas ya que toman datos desde el sistema de archivos y lo canalizan a través de las tuberías para que puedan ser usadas. @@ -39,13 +39,13 @@ Es posible que te hayas preguntado como miramos una tabla si `ls` es una entrada En efecto, el comando: ``` -> ls +ls ``` y la tubería: ``` -> ls | autoview +ls | autoview ``` Son uno y lo mismo. diff --git a/es/book/trabajando_con_tablas.md b/es/book/trabajando_con_tablas.md index c699eb49863..0c454d42757 100644 --- a/es/book/trabajando_con_tablas.md +++ b/es/book/trabajando_con_tablas.md @@ -5,21 +5,21 @@ Una de las maneras comunes de mirar datos en Nu es a través de una tabla. Nu vi Para empezar, consigamos una tabla que podamos usar: ``` -> ls ----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------------+------+----------+---------+------------+------------ - 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 2 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago - 3 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago - 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 5 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago - 6 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago - 7 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 8 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 9 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago ----+---------------+------+----------+---------+------------+------------ +ls +# => ---+---------------+------+----------+---------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------------+------+----------+---------+------------+------------ +# => 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 2 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago +# => 3 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 5 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago +# => 6 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago +# => 7 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 8 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 9 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago +# => ---+---------------+------+----------+---------+------------+------------ ``` ## Ordenando los datos @@ -27,21 +27,21 @@ Para empezar, consigamos una tabla que podamos usar: Podemos ordenar la tabla llamando el comando `sort-by` e indicándole qué columnas queremos usar al ordenar. Digamos que deseamos ordenar nuestra tabla por tamaño de archivo: ``` -> ls | sort-by size ----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------------+------+----------+---------+------------+------------ - 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 5 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago - 6 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago - 7 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago - 8 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago - 9 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago ----+---------------+------+----------+---------+------------+------------ +ls | sort-by size +# => ---+---------------+------+----------+---------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------------+------+----------+---------+------------+------------ +# => 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 5 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago +# => 6 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago +# => 7 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago +# => 8 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago +# => 9 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => ---+---------------+------+----------+---------+------------+------------ ``` Podemos ordenar una tabla con cualquier columna que pueda ser comparada. Por ejemplo, también pudimos haber ordenador usando las columnas "name", "accessed", o "modified". @@ -51,36 +51,36 @@ Podemos ordenar una tabla con cualquier columna que pueda ser comparada. Por eje Podemos seleccionar datos de una tabla seleccionando columnas o filas específicas. Escojamos algunas columnas de nuestra tabla para usar: ``` -> ls | select name size ----+---------------+--------- - # | name | size ----+---------------+--------- - 0 | add.rs | 2.7 KB - 1 | sum.rs | 3.0 KB - 2 | inc.rs | 11.8 KB - 3 | str.rs | 21.4 KB - 4 | skip.rs | 1.7 KB - 5 | textview.rs | 9.4 KB - 6 | binaryview.rs | 13.0 KB - 7 | edit.rs | 2.7 KB - 8 | tree.rs | 3.0 KB - 9 | sys.rs | 9.2 KB ----+---------------+--------- +ls | select name size +# => ---+---------------+--------- +# => # | name | size +# => ---+---------------+--------- +# => 0 | add.rs | 2.7 KB +# => 1 | sum.rs | 3.0 KB +# => 2 | inc.rs | 11.8 KB +# => 3 | str.rs | 21.4 KB +# => 4 | skip.rs | 1.7 KB +# => 5 | textview.rs | 9.4 KB +# => 6 | binaryview.rs | 13.0 KB +# => 7 | edit.rs | 2.7 KB +# => 8 | tree.rs | 3.0 KB +# => 9 | sys.rs | 9.2 KB +# => ---+---------------+--------- ``` Esto ayuda a crear una table más enfocada para lo que necesitamos. Siguiente, digamos que queremos ver los 5 archivos más livianos de este directorio: ``` -> ls | sort-by size | first 5 ----+---------+------+----------+--------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------+------+----------+--------+------------+------------ - 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago ----+---------+------+----------+--------+------------+------------ +ls | sort-by size | first 5 +# => ---+---------+------+----------+--------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------+------+----------+--------+------------+------------ +# => 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => ---+---------+------+----------+--------+------------+------------ ``` Notarás que primero ordenamos la tabla por tamaño para llegar hasta el archivo más pequeño y luego usamos `first 5` que nos devuelve las primeras 5 filas de la tabla. @@ -88,14 +88,14 @@ Notarás que primero ordenamos la tabla por tamaño para llegar hasta el archivo También puedes saltarte filas con `skip` que no deseas. Saltemos las primeras dos de las 5 filas que obtuvimos arriba: ``` -> ls | sort-by size | first 5 | skip 2 ----+---------+------+----------+--------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------+------+----------+--------+------------+------------ - 0 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 2 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago ----+---------+------+----------+--------+------------+------------ +ls | sort-by size | first 5 | skip 2 +# => ---+---------+------+----------+--------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------+------+----------+--------+------------+------------ +# => 0 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 2 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => ---+---------+------+----------+--------+------------+------------ ``` Hemos reducido a tres filas que nos interesa. @@ -103,28 +103,28 @@ Hemos reducido a tres filas que nos interesa. Veamos algunos otros comandos para seleccionar datos. Es posible que te hayas preguntado por qué las filas de la tabla son números. Esto actúa como una forma práctica de llegar a una sola fila. Ordenemos nuestra tabla por el nombre del archivo y luego escojamos una de las filas con el comando `n-th` usando el número de fila: ``` -> ls | sort-by name ----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------------+------+----------+---------+------------+------------ - 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 1 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago - 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 3 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago - 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 5 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago - 6 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 7 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago - 8 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago - 9 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +ls | sort-by name +# => ---+---------------+------+----------+---------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------------+------+----------+---------+------------+------------ +# => 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 1 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago +# => 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 3 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago +# => 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 5 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => 6 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 7 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago +# => 8 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago +# => 9 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago ---+---------------+------+----------+---------+------------+------------ -> ls | sort-by name | nth 5 ---------+------+----------+---------+------------+------------ - name | type | readonly | size | accessed | modified ---------+------+----------+---------+------------+------------ - str.rs | File | | 21.4 KB | 2 days ago | 2 days ago ---------+------+----------+---------+------------+------------ +ls | sort-by name | nth 5 +# => --------+------+----------+---------+------------+------------ +# => name | type | readonly | size | accessed | modified +# => --------+------+----------+---------+------------+------------ +# => str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => --------+------+----------+---------+------------+------------ ``` ## Obteniendo datos de una tabla @@ -132,21 +132,21 @@ Veamos algunos otros comandos para seleccionar datos. Es posible que te hayas pr Hasta ahora hemos trabajado con tablas reduciendo la tabla a solo lo que necesitamos. A veces es posible que queramos ir un paso más allá y solo mirar los valores en las celdas en lugar the tomar una columna completa. Digamos, por ejemplo, que queramos obtener una lista de los nombres de los archivos. Para esto usamos el comando `get`: ``` -> ls | get name ----+--------------- - # | value ----+--------------- - 0 | add.rs - 1 | sum.rs - 2 | inc.rs - 3 | str.rs - 4 | skip.rs - 5 | textview.rs - 6 | binaryview.rs - 7 | edit.rs - 8 | tree.rs - 9 | sys.rs ----+--------------- +ls | get name +# => ---+--------------- +# => # | value +# => ---+--------------- +# => 0 | add.rs +# => 1 | sum.rs +# => 2 | inc.rs +# => 3 | str.rs +# => 4 | skip.rs +# => 5 | textview.rs +# => 6 | binaryview.rs +# => 7 | edit.rs +# => 8 | tree.rs +# => 9 | sys.rs +# => ---+--------------- ``` Ahora tenemos los valores de cada nombre de los archivos. @@ -154,21 +154,21 @@ Ahora tenemos los valores de cada nombre de los archivos. Puede parecerse al comando `select` que vimos previamente, probemos `select` para comparar los dos: ``` -> ls | select name ----+--------------- - # | name ----+--------------- - 0 | add.rs - 1 | sum.rs - 2 | inc.rs - 3 | str.rs - 4 | skip.rs - 5 | textview.rs - 6 | binaryview.rs - 7 | edit.rs - 8 | tree.rs - 9 | sys.rs ----+--------------- +ls | select name +# => ---+--------------- +# => # | name +# => ---+--------------- +# => 0 | add.rs +# => 1 | sum.rs +# => 2 | inc.rs +# => 3 | str.rs +# => 4 | skip.rs +# => 5 | textview.rs +# => 6 | binaryview.rs +# => 7 | edit.rs +# => 8 | tree.rs +# => 9 | sys.rs +# => ---+--------------- ``` ¡Se ven muy similares! Veamos si podemos explicar la diferencia entre estos dos comandos para aclarar: @@ -189,46 +189,46 @@ Además de seleccionar datos de una tabla, también podemos actualizar lo que co Podemos utilizar el comando `add` para agregar una nueva columna a la tabla. Veamos un ejemplo: ``` -> open rustfmt.toml ---------- - edition ---------- - 2018 ---------- +open rustfmt.toml +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- ``` Agreguemos una columna llamada "next_edition" con el valor 2021: ``` -> open rustfmt.toml | add next_edition 2021 ----------+-------------- - edition | next_edition ----------+-------------- - 2018 | 2021 ----------+-------------- +open rustfmt.toml | add next_edition 2021 +# => ---------+-------------- +# => edition | next_edition +# => ---------+-------------- +# => 2018 | 2021 +# => ---------+-------------- ``` Observa que si abrimos el archivo original el contenido permanece igual: ``` -> open rustfmt.toml ---------- - edition ---------- - 2018 ---------- +open rustfmt.toml +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- ``` Los cambios en Nu son cambios funcionales, lo que significa que funcionan en los valores mismos en vez de causar cambios permanentes. Esto nos permite realizar diferentes tipos de trabajo en nuestra tubería hasta que estemos listos para grabar los resultados con cualquier cambio que nos gustaría si así decidimos. Aquí podríamos grabar los resultados usando el comando `save`: ``` -> open rustfmt.toml | add next_edition 2021 | save rustfmt2.toml -/home/sophia/Source/nushell(master)> open rustfmt2.toml ----------+-------------- - edition | next_edition ----------+-------------- - 2018 | 2021 ----------+-------------- +open rustfmt.toml | add next_edition 2021 | save rustfmt2.toml +open rustfmt2.toml +# => ---------+-------------- +# => edition | next_edition +# => ---------+-------------- +# => 2018 | 2021 +# => ---------+-------------- ``` ### Editando una columna @@ -237,22 +237,22 @@ Similarmente al comando `add`, también podemos usar el comando `edit` para camb ``` open rustfmt.toml ---------- - edition ---------- - 2018 ---------- +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- ``` y ahora, actualizemos la edición y que apunte a la siguiente edición que esperamos soportar: ``` -> open rustfmt.toml | edit edition 2021 ---------- - edition ---------- - 2021 ---------- +open rustfmt.toml | edit edition 2021 +# => --------- +# => edition +# => --------- +# => 2021 +# => --------- ``` ### Incrementando valores @@ -260,27 +260,27 @@ y ahora, actualizemos la edición y que apunte a la siguiente edición que esper Hay un comando más en Nu que nos ayudará a trabajar con números y versiones: `inc`. ``` -> open rustfmt.toml ---------- - edition ---------- - 2018 ---------- -> open rustfmt.toml | inc edition ---------- - edition ---------- - 2019 ---------- +open rustfmt.toml +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- +open rustfmt.toml | inc edition +# => --------- +# => edition +# => --------- +# => 2019 +# => --------- ``` Como el valor en "edition" es un número, podemos usar `inc` para actualizarlo. `inc` realmente brilla cuando trabajamos con versiones: ``` -> open Cargo.toml | get package.version -0.1.3 -> open Cargo.toml | inc package.version --minor | get package.version -0.2.0 +open Cargo.toml | get package.version +# => 0.1.3 +open Cargo.toml | inc package.version --minor | get package.version +# => 0.2.0 ``` Cuando trabajamos con versiones podemos usar banderas e indicar cómo incrementar la versión: diff --git a/es/book/variables_y_subexpresiones.md b/es/book/variables_y_subexpresiones.md index 10ba0429e41..572fd88b3d7 100644 --- a/es/book/variables_y_subexpresiones.md +++ b/es/book/variables_y_subexpresiones.md @@ -9,9 +9,9 @@ La variable es el más simple de ambas expresiones de evaluación. Durante la ev Si creamos una variable, podemos imprimir su contenido al usar `$` para referir a la misma: ``` -> let mi_valor = 4 -> echo $mi_valor -4 +let mi_valor = 4 +echo $mi_valor +# => 4 ``` ## Variables rutas (paths) @@ -19,14 +19,14 @@ Si creamos una variable, podemos imprimir su contenido al usar `$` para referir Una variable ruta funciona al llegar dentro del contenido de una variable, navegando columnas dentro de la misma para alcanzar un valor final. Supongamos que en vez de `4`, hayamos asignado una tabla como valor: ``` -> let mi_valor = [[nombre]; [pruebausuario]] +let mi_valor = [[nombre]; [pruebausuario]] ``` Podemos usar variables ruta para evaluar la variable `$mi_valor` y obtener el valor de la columna `nombre` con un solo paso: ``` -> echo $mi_valor.nombre -pruebausuario +echo $mi_valor.nombre +# => pruebausuario ``` ## Subexpresiones @@ -38,14 +38,14 @@ Los paréntesis contienen una tubería que se ejecutará hasta completar, y su v Subexpresiones también pueden ser tuberías y no solamente comandos individuales. Si desearamos una lista de nombres de archivos superiores a diez kilobytes, podemos utilizar subexpresiones para ejecutar una tubería y asignar el resultado a una variable: ``` -> let nombres_de_archivos_grandes = (ls | where size > 10kb) -> echo $nombres_de_archivos_grandes -───┬────────────┬──────┬──────────┬────────────── - # │ name │ type │ size │ modified -───┼────────────┼──────┼──────────┼────────────── - 0 │ Cargo.lock │ File │ 155.3 KB │ 17 hours ago - 1 │ README.md │ File │ 15.9 KB │ 17 hours ago -───┴────────────┴──────┴──────────┴────────────── +let nombres_de_archivos_grandes = (ls | where size > 10kb) +echo $nombres_de_archivos_grandes +# => ───┬────────────┬──────┬──────────┬────────────── +# => # │ name │ type │ size │ modified +# => ───┼────────────┼──────┼──────────┼────────────── +# => 0 │ Cargo.lock │ File │ 155.3 KB │ 17 hours ago +# => 1 │ README.md │ File │ 15.9 KB │ 17 hours ago +# => ───┴────────────┴──────┴──────────┴────────────── ``` ## Subexpresiones y rutas @@ -53,13 +53,13 @@ Subexpresiones también pueden ser tuberías y no solamente comandos individuale Subexpresiones también soportan rutas. Por ejemplo, supongamos que queremos una lista de nombres de archivos en el directorio actual. Una manera de hacerlo es con una tubería: ``` -> ls | get name +ls | get name ``` Pero también podemos hacer una acción similar con un solo paso usando una subexpresión de ruta: ``` -> echo (ls).name +echo (ls).name ``` Todo depende de las necesidades del código o estilo particular que trabaje mejor para ti. diff --git a/fr/book/cheat_sheet.md b/fr/book/cheat_sheet.md index 30840c543ea..8573c153a31 100644 --- a/fr/book/cheat_sheet.md +++ b/fr/book/cheat_sheet.md @@ -46,72 +46,72 @@ sélectionner deux colonnes nommées du tableau et afficher leurs valeurs : interpoler du texte : ```nu -> let name = "Alice" -> $"greetings, ($name)!" -greetings, Alice! +let name = "Alice" +$"greetings, ($name)!" +# => greetings, Alice! ``` découper le texte à chaque virgule et stocker la liste dans la variable `string_list` : ```nu -> let string_list = "one,two,three" | split row "," -> $string_list -╭───┬───────╮ -│ 0 │ one │ -│ 1 │ two │ -│ 2 │ three │ -╰───┴───────╯ +let string_list = "one,two,three" | split row "," +$string_list +# => ╭───┬───────╮ +# => │ 0 │ one │ +# => │ 1 │ two │ +# => │ 2 │ three │ +# => ╰───┴───────╯ ``` vérifier si une string contient une sous-string : ```nu -> "Hello, world!" | str contains "o, w" -true +"Hello, world!" | str contains "o, w" +# => true ``` concaténer plusieurs strings avec un délimiteur : ```nu -> let str_list = [zero one two] -> $str_list | str join ',' -zero,one,two +let str_list = [zero one two] +$str_list | str join ',' +# => zero,one,two ``` découper le texte selon des indices : ```nu -> 'Hello World!' | str substring 4..8 -o Wor +'Hello World!' | str substring 4..8 +# => o Wor ``` parser une string en des colonnes nommées : ```nu -> 'Nushell 0.80' | parse '{shell} {version}' -╭───┬─────────┬─────────╮ -│ # │ shell │ version │ -├───┼─────────┼─────────┤ -│ 0 │ Nushell │ 0.80 │ -╰───┴─────────┴─────────╯ +'Nushell 0.80' | parse '{shell} {version}' +# => ╭───┬─────────┬─────────╮ +# => │ # │ shell │ version │ +# => ├───┼─────────┼─────────┤ +# => │ 0 │ Nushell │ 0.80 │ +# => ╰───┴─────────┴─────────╯ ``` parser des valeurs au format csv : ```nu -> "acronym,long\nAPL,A Programming Language" | from csv -╭───┬─────────┬────────────────────────╮ -│ # │ acronym │ long │ -├───┼─────────┼────────────────────────┤ -│ 0 │ APL │ A Programming Language │ -╰───┴─────────┴────────────────────────╯ +"acronym,long\nAPL,A Programming Language" | from csv +# => ╭───┬─────────┬────────────────────────╮ +# => │ # │ acronym │ long │ +# => ├───┼─────────┼────────────────────────┤ +# => │ 0 │ APL │ A Programming Language │ +# => ╰───┴─────────┴────────────────────────╯ ``` appliquer une couleur à un texte dans un terminal de commande : ```nu -> $'(ansi purple_bold)This text is a bold purple!(ansi reset)' -This text is a bold purple! +$'(ansi purple_bold)This text is a bold purple!(ansi reset)' +# => This text is a bold purple! ``` ## Listes @@ -119,136 +119,136 @@ This text is a bold purple! insérer une valeur à un index dans une list : ```nu -> [foo bar baz] | insert 1 'beeze' -╭───┬───────╮ -│ 0 │ foo │ -│ 1 │ beeze │ -│ 2 │ bar │ -│ 3 │ baz │ -╰───┴───────╯ +[foo bar baz] | insert 1 'beeze' +# => ╭───┬───────╮ +# => │ 0 │ foo │ +# => │ 1 │ beeze │ +# => │ 2 │ bar │ +# => │ 3 │ baz │ +# => ╰───┴───────╯ ``` mettre à jour une liste par index : ```nu -> [1, 2, 3, 4] | update 1 10 -╭───┬────╮ -│ 0 │ 1 │ -│ 1 │ 10 │ -│ 2 │ 3 │ -│ 3 │ 4 │ -╰───┴────╯ +[1, 2, 3, 4] | update 1 10 +# => ╭───┬────╮ +# => │ 0 │ 1 │ +# => │ 1 │ 10 │ +# => │ 2 │ 3 │ +# => │ 3 │ 4 │ +# => ╰───┴────╯ ``` ajouter une valeur au début d'une liste : ```nu -> let numbers = [1, 2, 3] -> $numbers | prepend 0 -╭───┬───╮ -│ 0 │ 0 │ -│ 1 │ 1 │ -│ 2 │ 2 │ -│ 3 │ 3 │ -╰───┴───╯ +let numbers = [1, 2, 3] +$numbers | prepend 0 +# => ╭───┬───╮ +# => │ 0 │ 0 │ +# => │ 1 │ 1 │ +# => │ 2 │ 2 │ +# => │ 3 │ 3 │ +# => ╰───┴───╯ ``` ajouter une valeur à la fin d'une liste : ```nu -> let numbers = [1, 2, 3] -> $numbers | append 4 -╭───┬───╮ -│ 0 │ 1 │ -│ 1 │ 2 │ -│ 2 │ 3 │ -│ 3 │ 4 │ -╰───┴───╯ +let numbers = [1, 2, 3] +$numbers | append 4 +# => ╭───┬───╮ +# => │ 0 │ 1 │ +# => │ 1 │ 2 │ +# => │ 2 │ 3 │ +# => │ 3 │ 4 │ +# => ╰───┴───╯ ``` découper les premières valeurs d'une liste : ```nu -> [cammomile marigold rose forget-me-not] | first 2 -╭───┬───────────╮ -│ 0 │ cammomile │ -│ 1 │ marigold │ -╰───┴───────────╯ +[cammomile marigold rose forget-me-not] | first 2 +# => ╭───┬───────────╮ +# => │ 0 │ cammomile │ +# => │ 1 │ marigold │ +# => ╰───┴───────────╯ ``` itérer sur une liste ; `elt` est la valeur actuelle de la liste : ```nu -> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] -> $planets | each { |elt| $"($elt) is a planet of the solar system" } -╭───┬─────────────────────────────────────────╮ -│ 0 │ Mercury is a planet of the solar system │ -│ 1 │ Venus is a planet of the solar system │ -│ 2 │ Earth is a planet of the solar system │ -│ 3 │ Mars is a planet of the solar system │ -│ 4 │ Jupiter is a planet of the solar system │ -│ 5 │ Saturn is a planet of the solar system │ -│ 6 │ Uranus is a planet of the solar system │ -│ 7 │ Neptune is a planet of the solar system │ -╰───┴─────────────────────────────────────────╯ +let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] +$planets | each { |elt| $"($elt) is a planet of the solar system" } +# => ╭───┬─────────────────────────────────────────╮ +# => │ 0 │ Mercury is a planet of the solar system │ +# => │ 1 │ Venus is a planet of the solar system │ +# => │ 2 │ Earth is a planet of the solar system │ +# => │ 3 │ Mars is a planet of the solar system │ +# => │ 4 │ Jupiter is a planet of the solar system │ +# => │ 5 │ Saturn is a planet of the solar system │ +# => │ 6 │ Uranus is a planet of the solar system │ +# => │ 7 │ Neptune is a planet of the solar system │ +# => ╰───┴─────────────────────────────────────────╯ ``` itérer sur une liste avec un index et une valeur : ```nu -> $planets | enumerate | each { |elt| $"($elt.index + 1) - ($elt.item)" } -╭───┬─────────────╮ -│ 0 │ 1 - Mercury │ -│ 1 │ 2 - Venus │ -│ 2 │ 3 - Earth │ -│ 3 │ 4 - Mars │ -│ 4 │ 5 - Jupiter │ -│ 5 │ 6 - Saturn │ -│ 6 │ 7 - Uranus │ -│ 7 │ 8 - Neptune │ -╰───┴─────────────╯ +$planets | enumerate | each { |elt| $"($elt.index + 1) - ($elt.item)" } +# => ╭───┬─────────────╮ +# => │ 0 │ 1 - Mercury │ +# => │ 1 │ 2 - Venus │ +# => │ 2 │ 3 - Earth │ +# => │ 3 │ 4 - Mars │ +# => │ 4 │ 5 - Jupiter │ +# => │ 5 │ 6 - Saturn │ +# => │ 6 │ 7 - Uranus │ +# => │ 7 │ 8 - Neptune │ +# => ╰───┴─────────────╯ ``` réduire la liste à une unique valeur ; `reduce` donne accès à un accumulateur qui est appliqué à chaque élément de la liste : ```nu -> let scores = [3 8 4] -> $"total = ($scores | reduce { |elt, acc| $acc + $elt })" -total = 15 +let scores = [3 8 4] +$"total = ($scores | reduce { |elt, acc| $acc + $elt })" +# => total = 15 ``` réduire avec une valeur initiale (`--fold`) : ```nu -> let scores = [3 8 4] -> $"total = ($scores | reduce --fold 1 { |elt, acc| $acc * $elt })" -total = 96 +let scores = [3 8 4] +$"total = ($scores | reduce --fold 1 { |elt, acc| $acc * $elt })" +# => total = 96 ``` donner accès au 3ème élément de la liste : ```nu -> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] -> $planets.2 -Earth +let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] +$planets.2 +# => Earth ``` vérifier si une string dans la liste commence par `E` : ```nu -> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] -> $planets | any {|elt| $elt | str starts-with "E" } -true +let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] +$planets | any {|elt| $elt | str starts-with "E" } +# => true ``` découper les éléments qui satisfont la condition donnée : ```nu -> let cond = {|x| $x < 0 }; [-1 -2 9 1] | take while $cond -╭───┬────╮ -│ 0 │ -1 │ -│ 1 │ -2 │ -╰───┴────╯ +let cond = {|x| $x < 0 }; [-1 -2 9 1] | take while $cond +# => ╭───┬────╮ +# => │ 0 │ -1 │ +# => │ 1 │ -2 │ +# => ╰───┴────╯ ``` ## Tablaux @@ -268,30 +268,28 @@ ls | sort-by size | first 5 concaténer deux tableaux avec les mêmes colonnes : ```nu -> let $a = [[first_column second_column third_column]; [foo bar snooze]] -> let $b = [[first_column second_column third_column]; [hex seeze feeze]] -> $a | append $b - -╭───┬──────────────┬───────────────┬──────────────╮ -│ # │ first_column │ second_column │ third_column │ -├───┼──────────────┼───────────────┼──────────────┤ -│ 0 │ foo │ bar │ snooze │ -│ 1 │ hex │ seeze │ feeze │ -╰───┴──────────────┴───────────────┴──────────────╯ +let $a = [[first_column second_column third_column]; [foo bar snooze]] +let $b = [[first_column second_column third_column]; [hex seeze feeze]] +$a | append $b +# => ╭───┬──────────────┬───────────────┬──────────────╮ +# => │ # │ first_column │ second_column │ third_column │ +# => ├───┼──────────────┼───────────────┼──────────────┤ +# => │ 0 │ foo │ bar │ snooze │ +# => │ 1 │ hex │ seeze │ feeze │ +# => ╰───┴──────────────┴───────────────┴──────────────╯ ``` retirer la dernière colonne d'un tableau : ```nu -> let teams_scores = [[team score plays]; ['Boston Celtics' 311 3] ['Golden State Warriors', 245 2]] -> $teams_scores | drop column - -╭───┬───────────────────────┬───────╮ -│ # │ team │ score │ -├───┼───────────────────────┼───────┤ -│ 0 │ Boston Celtics │ 311 │ -│ 1 │ Golden State Warriors │ 245 │ -╰───┴───────────────────────┴───────╯ +let teams_scores = [[team score plays]; ['Boston Celtics' 311 3] ['Golden State Warriors', 245 2]] +$teams_scores | drop column +# => ╭───┬───────────────────────┬───────╮ +# => │ # │ team │ score │ +# => ├───┼───────────────────────┼───────┤ +# => │ 0 │ Boston Celtics │ 311 │ +# => │ 1 │ Golden State Warriors │ 245 │ +# => ╰───┴───────────────────────┴───────╯ ``` ## Fichiers et système de fichier @@ -337,7 +335,7 @@ watch . --glob=**/*.rs {|| cargo test } commande personnalisée avec un paramètre de type string : ```nu -> def greet [name: string] { +def greet [name: string] { $"hello ($name)" } ``` @@ -345,7 +343,7 @@ commande personnalisée avec un paramètre de type string : commande personnalisée avec un paramètre par défaut fixé à nushell : ```nu -> def greet [name = "nushell"] { +def greet [name = "nushell"] { $"hello ($name)" } ``` @@ -353,20 +351,20 @@ commande personnalisée avec un paramètre par défaut fixé à nushell : passer un paramètre nommé en définissant un flag pour une commande personnalisée : ```nu -> def greet [ +def greet [ name: string --age: int ] { [$name $age] } -> greet world --age 10 +greet world --age 10 ``` utiliser le flag comme un switch avec un racourcis (-a) pour l'âge : ```nu -> def greet [ +def greet [ name: string --age (-a): int --twice @@ -377,24 +375,24 @@ utiliser le flag comme un switch avec un racourcis (-a) pour l'âge : [$name $age] } } -> greet -a 10 --twice hello +greet -a 10 --twice hello ``` commande personnalisée qui prend un nombre quelconque d'arguments positionnels en utilisant des paramètres restants : ```nu -> def greet [...name: string] { +def greet [...name: string] { print "hello all:" for $n in $name { print $n } } -> greet earth mars jupiter venus -hello all: -earth -mars -jupiter -venus +greet earth mars jupiter venus +# => hello all: +# => earth +# => mars +# => jupiter +# => venus ``` ## Variables @@ -402,64 +400,64 @@ venus une variable immuable ne peut pas changer de valeur après déclaration : ```nu -> let val = 42 -> print $val -42 +let val = 42 +print $val +# => 42 ``` le shadowing d'une variable (déclaration d'une variable avec le même nom dans un autre scope) : ```nu -> let val = 42 -> do { let val = 101; $val } -101 -> $val -42 +let val = 42 +do { let val = 101; $val } +# => 101 +$val +# => 42 ``` déclarer une variable mutable avec le mot-clé mut : ```nu -> mut val = 42 -> $val += 27 -> $val -69 +mut val = 42 +$val += 27 +$val +# => 69 ``` les closures et définitions imbriquées ne peuvent pas capturer des variables mutables de leur environnement (erreurs) : ```nu -> mut x = 0 -> [1 2 3] | each { $x += 1 } -Error: nu::parser::expected_keyword - - × Capture of mutable variable. - ╭─[entry #83:1:18] - 1 │ [1 2 3] | each { $x += 1 } - · ─┬ - · ╰── capture of mutable variable - ╰──── +mut x = 0 +# => [1 2 3] | each { $x += 1 } +# => Error: nu::parser::expected_keyword +# => +# => × Capture of mutable variable. +# => ╭─[entry #83:1:18] +# => 1 │ [1 2 3] | each { $x += 1 } +# => · ─┬ +# => · ╰── capture of mutable variable +# => ╰──── ``` une variable constante est immuable et est entièrement évaluée au moment du parsing : ```nu -> const file = 'path/to/file.nu' -> source $file +const file = 'path/to/file.nu' +source $file ``` utiliser l'opérateur point d'interrogation `?` pour retourner null au lieu d'une erreur si le chemin fourni est incorrect : ```nu -> let files = (ls) -> $files.name?.0? +let files = (ls) +$files.name?.0? ``` assigner le résultat d'un pipeline à une variable : ```nu -> let big_files = (ls | where size > 10kb) -> $big_files +let big_files = (ls | where size > 10kb) +$big_files ``` ## Modules @@ -467,7 +465,7 @@ assigner le résultat d'un pipeline à une variable : utiliser un module inline : ```nu -> module greetings { +module greetings { export def hello [name: string] { $"hello ($name)!" } @@ -476,8 +474,8 @@ utiliser un module inline : $"hi ($where)!" } } -> use greetings hello -> hello "world" +use greetings hello +hello "world" ``` importer un module depuis un fichier et utiliser son environnement dans le scope actuel : @@ -491,11 +489,11 @@ export def hello [] { $"hello ($env.MYNAME)" } -> use greetings.nu -> $env.MYNAME -Arthur, King of the Britons -> greetings hello -hello Arthur, King of the Britons! +use greetings.nu +$env.MYNAME +# => Arthur, King of the Britons +greetings hello +# => hello Arthur, King of the Britons! ``` utiliser la commande main dans un module : @@ -514,9 +512,9 @@ export def main [] { "greetings and salutations!" } -> use greetings.nu -> greetings -greetings and salutations! -> greetings hello world -hello world! +use greetings.nu +greetings +# => greetings and salutations! +greetings hello world +# => hello world! ``` diff --git a/fr/book/thinking_in_nu.md b/fr/book/thinking_in_nu.md index 96674799859..3b95fd053b5 100644 --- a/fr/book/thinking_in_nu.md +++ b/fr/book/thinking_in_nu.md @@ -9,7 +9,7 @@ Alors, que signifie penser en Nushell ? Voici quelques sujets courants qui revie Nushell est à la fois un langage de programmation et un shell. Pour cette raison, Nushell possède sa propre manière de fonctionner avec les fichiers, les dossiers, les sites web, et plus encore. Nous l'avons conçu pour fonctionner en étroite collaboration avec ce que vous connaissez peut-être d'autres shells. Les pipelines fonctionnent en reliant deux commandes ensemble : ```nu -> ls | length +ls | length ``` Nushell, par exemple, prend également en charge d'autres fonctionnalités courantes comme la récupération du code de sortie des commandes précédemment exécutées. @@ -17,13 +17,13 @@ Nushell, par exemple, prend également en charge d'autres fonctionnalités coura Bien que Nushell dispose de ces commodités, Nushell n'est pas bash. La manière de travailler avec bash, et le style POSIX en général, ne sont pas pris en charge par Nushell. Par exemple, dans bash, vous pourriez utiliser : ```sh -> echo "hello" > output.txt +echo "hello" > output.txt ``` En Nushell, nous utilisons `>` comme l'opérateur supérieur à. Cela s'accorde mieux avec l'aspect langage de Nushell. Au lieu de cela, vous redirigez vers une commande qui a pour tâche de sauvegarder le contenu : ```nu -> "hello" | save output.txt +"hello" | save output.txt ``` **Penser en Nushell :** La manière dont Nushell voit les données est que celles-ci circulent à travers le pipeline jusqu'à atteindre l'utilisateur ou être traitées par une commande finale. Vous pouvez simplement taper des données, des chaînes de caractères aux listes et records en style JSON, et les suivre par `|` pour les envoyer dans le pipeline. Nushell utilise des commandes pour effectuer des tâches et produire plus de données. Apprendre ces commandes et savoir quand les utiliser vous aidera à composer de nombreux types de pipelines. @@ -45,7 +45,7 @@ La commande [`source`](/commands/docs/source.md) va augmenter les sources qui vo Un autre problème courant est d'essayer de créer dynamiquement le nom du fichier à inclure : ```nu -> source $"($my_path)/common.nu" +source $"($my_path)/common.nu" ``` Cela ne fonctionne pas si `my_path` est une variable déclarée au runtime avec `let`. Cela nécessiterait que l'évaluateur exécute et évalue la chaîne de caractères, mais malheureusement, Nushell a besoin de cette information au moment de la compilation. @@ -53,8 +53,8 @@ Cela ne fonctionne pas si `my_path` est une variable déclarée au runtime avec Cependant, si `my_path` est une [constante](/book/variables#constant-variables), cela fonctionnera, car la chaîne de caractères peut être évaluée au moment de la compilation : ```nu -> const my_path = ([$nu.home-path nushell] | path join) -> source $"($my_path)/common.nu" # sources /home/user/nushell/common.nu +const my_path = ([$nu.home-path nushell] | path join) +source $"($my_path)/common.nu" # sources /home/user/nushell/common.nu ``` **Penser en Nushell :** Nushell est conçu pour utiliser une unique étape de compilation pour toutes les sources que vous lui envoyez, et cela est distinct de l'évaluation. Cela permettra un support solide pour les IDEs, des messages d'erreur précis, un langage plus facile à utiliser pour les outils tiers, et à l'avenir, même des possibilités plus sophistiquées comme la possibilité de compiler Nushell directement en un fichier binaire. @@ -79,7 +79,7 @@ Dans Nushell, les blocs contrôlent leur propre environnement. Les modifications En pratique, cela vous permet d'écrire du code concis pour travailler avec des sous-répertoires. Par exemple, si vous vouliez compiler chaque sous-projet dans le répertoire courant, vous pourriez exécuter : ```nu -> ls | each { |row| +ls | each { |row| cd $row.name make }