# Introducción
Hola, y bienvenido al proyecto Nushell. El objetivo de este proyecto es tomar la filosofía Unix de shells, dónde tuberías -pipes- conectan comandos simples juntos y llevarlos al estilo moderno de desarrollo.
Nu toma ideas de muchos territorios familiares: shells tradicionales como bash, shells basadas en objetos como PowerShell, programación funcional, programación de sistemas, y más. Pero, en lugar de ser un "Todo en uno", Nu enfoca su energía en hacer algunas cosas bien:
- Crear una multiplataforma shell flexible con un toque moderno.
- Permitir mezclar y combinar aplicaciones de línea de comandos con una shell que entiende la estructura de sus datos.
- Tenga el brillo UX que proporcionan las aplicaciones modernas CLI.
La manera más facil de ver qué puede hacer Nu es con ejemplos, iniciemos.
Lo primero que notarás al ejercutar un comando como ls es que en lugar de un bloque de texto que regresa, recibirás una tabla estructurada.
> ls
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ 404.html │ file │ 429 B │ 3 days ago │
│ 1 │ CONTRIBUTING.md │ file │ 955 B │ 8 mins ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 4 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 5 │ README.md │ file │ 213 B │ 3 days ago │
...
La tabla no solamente muestra lo que hay en el directorio de una manera distinta sino algo más. Como las tablas de una hoja de cálculo -spreadsheet-, esta tabla te permite trabajar con los datos más interactivamente.
Lo primero que vamos hacer es ordenar nuestra tabla por tamaño. Para poder hacerlo tomaremos la salida de ls y la alimentaremos al comando que ordena tablas basado en los valores de una columna (para este ejemplo sería la columna size).
> ls | sort-by size | reverse
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 1 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 4 │ CONTRIBUTING.md │ file │ 955 B │ 9 mins ago │
│ 5 │ books.md │ file │ 687 B │ 3 days ago │
...
Puedes observar que para lograrlo no tuvimos que pasar argumentos al comando ls. En cambio, nosotros usamos el comando sort-by que proporciona Nu para ordenar la salida del comando ls. Para ver los archivos más grandes en las primeras filas usamos el comando reverse.
Nu proporciona muchos comandos que trabajan con tablas. Por ejemplo, podemos filtrar los contenidos de la tabla de ls para únicamente mostrar archivos superiores a 1 kilobytes:
> ls | where size > 1kb
╭───┬───────────────────┬──────┬─────────┬────────────╮
│ # │ name │ type │ size │ modified │
├───┼───────────────────┼──────┼─────────┼────────────┤
│ 0 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 1 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 2 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
╰───┴───────────────────┴──────┴─────────┴────────────╯
Al igual que en la filosofía Unix, poder hacer que los comandos hablen entre ellos nos da maneras de mezclar y combinar de formas distintas. Miremos otro ejemplo:
> ps
╭─────┬──────┬──────────────────────┬─────────┬───────┬───────────┬──────────╮
│ # │ pid │ name │ status │ cpu │ mem │ virtual │
├─────┼──────┼──────────────────────┼─────────┼───────┼───────────┼──────────┤
│ 0 │ 7570 │ nu │ Running │ 1.96 │ 23.2 MiB │ 32.8 GiB │
│ 1 │ 3533 │ remindd │ Sleep │ 0.00 │ 103.6 MiB │ 32.3 GiB │
│ 2 │ 3495 │ TVCacheExtension │ Sleep │ 0.00 │ 11.9 MiB │ 32.2 GiB │
│ 3 │ 3490 │ MusicCacheExtension │ Sleep │ 0.00 │ 12.9 MiB │ 32.2 GiB │
...
Es posible que estés familiarizado con el comando ps si has utilizado Linux. Con dicho comando, podemos tener una lista de los procesos actuales que ejecuta el sistema, qué estado tienen y sus nombres. También podemos ver la carga CPU del proceso.
¿Qué tal si quisiéramos mostrar los procesos que activamente usan el CPU? Así como hicimos con el comando ls previamente, también podemos trabajar con la tabla que nos devuelve ps:
> ps | where cpu > 5
╭───┬──────┬────────────────┬─────────┬────────┬───────────┬──────────╮
│ # │ pid │ name │ status │ cpu │ mem │ virtual │
├───┼──────┼────────────────┼─────────┼────────┼───────────┼──────────┤
│ 0 │ 1583 │ Terminal │ Running │ 20.69 │ 127.8 MiB │ 33.0 GiB │
│ 1 │ 579 │ photoanalysisd │ Running │ 139.50 │ 99.9 MiB │ 32.3 GiB │
╰───┴──────┴────────────────┴─────────┴────────┴───────────┴──────────╯
Hasta ahora, hemos visto el uso de ls y ps para enumerar archivos y procesos. Nu también ofrece otros comandos que pueden crear tablas con información de gran utilidad. Exploremos date y sys.
Ejecutando date now nos proporciona información del día y tiempo:
> date now
2022-03-07 14:14:51.684619600 -08:00
Para obtener una tabla podemos alimentar la salida a date to-table
> date now | date to-table
╭───┬──────┬───────┬─────┬──────┬────────┬────────┬──────────╮
│ # │ year │ month │ day │ hour │ minute │ second │ timezone │
├───┼──────┼───────┼─────┼──────┼────────┼────────┼──────────┤
│ 0 │ 2022 │ 3 │ 7 │ 14 │ 45 │ 3 │ -08:00 │
╰───┴──────┴───────┴─────┴──────┴────────┴────────┴──────────╯
Ejecutando sys devuelve información sobre el sistema en el que se ejecuta Nu:
> sys
╭───────┬───────────────────╮
│ host │ {record 6 fields} │
│ cpu │ [table 4 rows] │
│ disks │ [table 3 rows] │
│ mem │ {record 4 fields} │
│ temp │ [table 1 row] │
│ net │ [table 4 rows] │
╰───────┴───────────────────╯
Esta tabla se ve un poco diferente con las que ya hemos trabajado. El comando sys nos regresa una tabla que también contiene tablas estructuradas en las celdas en vez de valores simples. Para explorar esos datos, necesitamos obtener la columna deseada para mostrar:
> sys | get host
╭────────────────┬────────────────────────╮
│ name │ Debian GNU/Linux │
│ os version │ 11 │
│ kernel version │ 5.10.92-v8+ │
│ hostname │ lifeless │
│ uptime │ 19day 21hr 34min 45sec │
│ sessions │ [table 1 row] │
╰────────────────┴────────────────────────╯
El comando get nos permite ir directo al valor de una columa de la tabla. Aquí estamos mirando la columna "host" que contiene información del host dónde se está ejecutando Nu. El nombre del sistema operativo, hostname, CPU, y más. Miremos los nombres de los usuarios en el sistema:
> sys | get host.sessions.name
╭───┬────╮
│ 0 │ jt │
╰───┴────╯
En este momento, solo hay un usuario en el sistema llamado "jt". Notarás que podemos pasar una ruta de columna -column path- y no únicamente el nombre de una columna. Nu tomará esta ruta de columna e irá a los datos correspondientes en la tabla.
Es posible que hayas notado algo más diferente también. En lugar de tener una tabla de datos, tenemos solo un elemento individual: la cadena "jt". Nu trabaja tanto con tabla de datos así como cadenas. Cadenas son una parte importante de trabajar con comandos fuera de Nu.
Miremos en acción cómo funcionan las cadenas fuera de Nu. Tomaremos el ejemplo anterior y ejecutaremos el comando externo echo (el carácter ^ le informa a Nu que no se desea usar el comando interno también llamado echo):
> sys | get host.sessions.name | each { |it| ^echo $it }
jt
Si esto se parece mucho a lo que teníamos antes, ¡tienes buen ojo! Es similar, pero con una diferencia importante: hemos llamado echo con el valor que vimos antes. Esto nos permite pasar datos fuera de Nu a echo (o cualquier comando fuera de Nu, como git por ejemplo)
Nota: Para texto de ayuda de los comandos internos de Nu, puedes descubrirlos con el comando help:
> help path
Explore and manipulate paths.
There are three ways to represent a path:
* As a path literal, e.g., '/home/viking/spam.txt'
* As a structured path: a table with 'parent', 'stem', and 'extension' (and
* 'prefix' on Windows) columns. This format is produced by the 'path parse'
subcommand.
* As an inner list of path parts, e.g., '[[ / home viking spam.txt ]]'.
Splitting into parts is done by the `path split` command.
All subcommands accept all three variants as an input. Furthermore, the 'path
join' subcommand can be used to join the structured path or path parts back into
the path literal.
Usage:
> path
Subcommands:
path basename - Get the final component of a path
path dirname - Get the parent directory of a path
path exists - Check whether a path exists
path expand - Try to expand a path to its absolute form
path join - Join a structured path or a list of path parts.
path parse - Convert a path into structured data.
path relative-to - Get a path as relative to another path.
path split - Split a path into parts by a separator.
path type - Get the type of the object a path refers to (e.g., file, dir, symlink)
Flags:
-h, --help
Display this help message