Cambios Notables

Comandos

En Nushell, varios comandos tradicionales perdieron su sentido original o fueron reemplazados por enfoques más modernos y estructurados. Algunos ejemplos notables incluyen:

• awk: Nushell ofrece funcionalidades nativas para manipulación de datos estructurados, haciendo que awk sea en gran parte innecesario.
• sed: Así como awk, muchas de las funciones de sed son reemplazadas por comandos internos de Nushell para manipulación de strings y datos.
• grep: Nushell posee comandos nativos para filtrado y búsqueda de datos, reduciendo la necesidad del grep tradicional.
• find: Nushell implementa su propia versión de búsqueda de archivos, que está más integrada con el sistema de manipulación de datos estructurados.
• wc: Funciones como conteo de líneas son realizadas de manera diferente en Nushell, usando pipelines y comandos nativos.
• jq y yq: Con Nushell tratando datos JSON y Yaml nativamente, herramientas como jq se vuelven menos necesarias.

Estos comandos tradicionales como sed, grep, awk, y otros aún existen en Nushell, pero por razones diferentes de las encontradas en shells tradicionales: Nushell mantiene estos comandos para garantizar compatibilidad con scripts y flujos de trabajo existentes, transición gradual, interoperabilidad, etc.

En Flags

Al migrar a Nushell, una de las diferencias más marcantes es el nuevo enfoque en relación a los comandos y sus flags. Usuarios familiarizados con shells como Bash o Zsh pueden inicialmente extrañar la ausencia de flags tradicionales en muchos comandos conocidos. Este cambio refleja la filosofía central de Nushell: tratar datos de forma estructurada y ofrecer una sintaxis de comando más simplificada.

En Nushell, muchos comandos fueron rediseñados para operar sin flags, adoptando un enfoque basado en subcomandos y pipelines. Esta nueva estructura promueve el uso de pipelines para filtrar y manipular datos, reemplazando flags tradicionales por una serie de comandos interconectados. Esta metodología, aunque inicialmente diferente, proporciona una manera más intuitiva y flexible de interactuar con el sistema y procesar información.

Sin embargo, como mencionado anteriormente la documentación para los comandos help está muy bien hecha facilitando esta migración.

Un ejemplo sería el comando ps aux que utilizamos para ver los procesos que perdieron prácticamente todas las flags restando solamente -l para visualizar todas las columnas.

~/teste> ps -h
View information about system processes.

Search terms: procedures, operations, tasks, ops

Usage:
  > ps {flags}

Flags:
  -h, --help: Display the help message for this command
  -l, --long: list all available columns for each entry

Input/output types:
  ╭───┬─────────┬────────╮
  │ # │  input  │ output │
  ├───┼─────────┼────────┤
  │ 0 │ nothing │ table  │
  ╰───┴─────────┴────────╯

Examples:
  List the system processes
  > ps

  List the top 5 system processes with the highest memory usage
  > ps | sort-by mem | last 5

  List the top 3 system processes with the highest CPU usage
  > ps | sort-by cpu | last 3

  List the system processes with 'nu' in their names
  > ps | where name =~ 'nu'

  Get the parent process id of the current nu process
  > ps | where pid == $nu.pid | get ppid

Es posible ejecutar un comando por nushell como está implementado por el sistema operativo en vez de utilizar el comando rediseñado.

El comando ls -lha no existe en nushell porque la flag -h no existe más. Pero si queremos invocar el ls nativo del sistema podemos utilizando el ˆ delante del comando. Verá que los datos vuelven a quedar en forma de texto y no son más estructurados.

# Está buscando el ls directo de /bin/ls
~/teste> ^ls -lha
total 48
drwxr-xr-x@  5 davidprata  staff   160B 11 Fev 06:51 .
drwxr-x---+ 70 davidprata  staff   2,2K 11 Fev 08:32 ..
-rw-r--r--@  1 davidprata  staff    15K 13 Jan 14:31 pod.yaml
-rwxr-xr-x@  1 davidprata  staff   400B 11 Fev 06:51 script.sh

Los comandos por dentro de Nushell no son binarios tradicionales del sistema operativo, sino una implementación interna del propio Nushell. Esta implementación hace parte del código fuente de Nushell y es compilada junto con el shell.

Errores

¡La manera como Nushell maneja errores es un espectáculo aparte! Los mensajes de error son presentados de forma clara, concisa y altamente informativa.

• Simplicidad: Los errores son exhibidos de manera directa, sin jergas técnicas innecesarias.
• Facilidad de comprensión: Los mensajes son formulados en lenguaje accesible, facilitando el entendimiento rápido del problema.
• Sugerencias útiles: En muchos casos, Nushell va más allá de la simple notificación del error, ofreciendo sugerencias prácticas para resolución.
• Contextualización: Los errores son frecuentemente acompañados de información contextual relevante, ayudando a identificar el origen del problema.
• Formateo visual: La presentación visual de los errores está bien estructurada, utilizando colores y formateo para destacar información importante.

Este enfoque intuitivo para el tratamiento de errores parece anticipar las necesidades del usuario, haciendo el proceso de depuración y corrección de problemas significativamente más eficiente y menos frustrante.

~> open deploy.yaml | get spec.template.spec.container
Error: nu::shell::name_not_found

  × Name not found
   ╭─[entry #8:1:43]
 1 │ open deploy.yaml | get spec.template.spec.container
   ·                                           ────┬────
   ·                                               ╰── did you mean 'containers'?
   ╰────
~> open deploy.yaml | get spec.template.spec.containers
╭───┬───────┬───────┬───────────────────╮
│ # │ image │ name  │     resources     │
├───┼───────┼───────┼───────────────────┤
│ 0 │ nginx │ nginx │ {record 0 fields} │
╰───┴───────┴───────┴───────────────────╯

# -p no existe...
~> ls -lp
Error: nu::parser::unknown_flag

  × The `ls` command doesn't have flag `-p`.
   ╭─[entry #9:1:6]
 1 │ ls -lp
   ·      ┬
   ·      ╰── unknown flag
   ╰────
  help: Available flags: --help(-h), --all(-a), --long(-l), --short-names(-s), --full-paths(-f), --du(-d), --directory(-D),
        --mime-type(-m), --threads(-t). Use `--help` for more information.

~> echo $LANG
Error: nu::parser::env_var_not_var

  × Use $env.LANG instead of $LANG.
   ╭─[entry #30:1:6]
 1 │ echo $LANG
   ·      ──┬──
   ·        ╰── use $env.LANG instead of $LANG
   ╰────

~> echo $env.LANG
pt_BR.UTF-8

Variables de Ambiente

En Nushell el comando env es un comando externo del sistema, no específico de Nushell por eso:

• Muestra las variables de ambiente en el formato tradicional de clave=valor.
• La salida es texto simple, no estructurado.

Ya el comando $env es un comando interno de Nushell.

• Muestra las variables de ambiente como una estructura de datos.
• La salida es estructurada, típicamente en formato de tabla.

La diferencia refleja la filosofía de Nushell de tratar datos de forma estructurada. Cuando usas $env, estás accediendo directamente al objeto de ambiente de Nushell, que mantiene las variables en un formato más rico y manipulable.

En la mayoría de los casos, el $env en Nushell y el comando env tradicional mostrarán las mismas variables de ambiente con los mismos valores. Sin embargo, pueden existir algunas diferencias:

• El $env en Nushell generalmente incluye todas las variables mostradas por el env tradicional.
• El $env puede contener variables adicionales específicas de Nushell que no aparecen en el env tradicional.
• Algunas variables pueden ser presentadas de forma diferente en el $env. Por ejemplo, el PATH puede ser mostrado como una lista en Nushell, mientras que en el env tradicional es una string separada por dos puntos.
• Nushell puede adicionar o modificar algunas variables de ambiente durante la inicialización.

Solo para comparar rápidamente...

~> env | wc -l
56
# Es necesario formatear la salida de $env para poder tener todo dividido en líneas y columnas.
~> $env | transpose key value | length
62

Podemos observar que tenemos más, pero las 56 que encontramos están dentro de las 62.

Nushell hereda las variables de ambiente del proceso padre que lo inició.

Este enfoque ofrece varias ventajas:

• Organización: Todas las variables de ambiente están agrupadas en un único lugar, facilitando la gestión.
• Claridad: El prefijo $env. hace explícito que estás lidiando con una variable de ambiente, no una variable local o global.
• Estructura: El $env es tratado como un objeto estructurado, permitiendo operaciones más avanzadas y consistentes.
• Tipado: Las variables dentro de $env pueden mantener sus tipos de datos originales, no siendo limitadas solo a strings.
• Seguridad: Esta estructura ayuda a prevenir conflictos accidentales con otras variables en el shell.

Las variables de ambiente y las configuraciones específicas de Nushell son almacenadas en el objeto $env. Las variables de ambiente generales son accedidas directamente a través de $env, mientras que las configuraciones de Nushell son mantenidas en $env.config. Exploraremos más detalladamente el $env.config cuando abordemos la optimización y personalización avanzada de Nushell, permitiéndonos aprovechar todo su potencial.

El objeto $env no engloba apenas las variables de ambiente estándar, sino también configuraciones específicas de Nushell y otras variables internas. Esto explica por qué $env presenta 62 entradas, mientras que el comando env muestra apenas 56.

La variable path que antes era separada por : ahora tiene una estructura que muestra cada path como un ítem.

~/teste> $env.PATH

# Hablaremos de esto más en otro momento.
~/teste> $env.config
╭──────────────────────────────────┬────────────────────╮
│ filesize                         │ {record 2 fields}  │
│ table                            │ {record 8 fields}  │
│ ls                               │ {record 2 fields}  │
│ color_config                     │ {record 59 fields} │
│ footer_mode                      │ 25                 │
│ float_precision                  │ 2                  │
│ recursion_limit                  │ 50                 │
│ use_ansi_coloring                │ true               │
│ completions                      │ {record 7 fields}  │
│ edit_mode                        │ emacs              │
│ history                          │ {record 4 fields}  │
│ keybindings                      │ [list 0 items]     │
│ menus                            │ [list 0 items]     │
│ hooks                            │ {record 5 fields}  │
│ rm                               │ {record 1 field}   │
│ shell_integration                │ {record 7 fields}  │
│ buffer_editor                    │ vim                │
│ show_banner                      │ false              │
│ bracketed_paste                  │ true               │
│ render_right_prompt_on_last_line │ false              │
│ explore                          │ {record 0 fields}  │
│ cursor_shape                     │ {record 3 fields}  │
│ datetime_format                  │ {record 2 fields}  │
│ error_style                      │ fancy              │
│ display_errors                   │ {record 2 fields}  │
│ use_kitty_protocol               │ false              │
│ highlight_resolved_externals     │ false              │
│ plugins                          │ {record 0 fields}  │
│ plugin_gc                        │ {record 2 fields}  │

Algunas Facilidades

mkdir ahora ya tiene el -p automático

mkdir test1/test2/test3
tree test1/
test1/
└── test2
    └── test3

No es necesario digitar cd para cambiar de carpeta. Escribiste el path va directo.

> pwd
/home/david/teste
> test1/
> pwd
/home/david/teste/test1
>..
>pwd
/home/david/teste

Algunas Diferencias

El > para redirigir la salida a algún lugar no funciona.

# Esto no funciona
> echo "david" > file.txt
╭───┬──────────╮
│ 0 │ david    │
│ 1 │ >        │
│ 2 │ file.txt │
╰───┴──────────╯

# ni fue creado el archivo file.txt
> ls
╭───┬───────┬──────┬──────┬────────────────╮
│ # │ name  │ type │ size │    modified    │
├───┼───────┼──────┼──────┼────────────────┤
│ 0 │ test3 │ dir  │ 64 B │ 10 minutes ago │
╰───┴───────┴──────┴──────┴────────────────╯

Si quieres hacer esto vamos a usar save.

>echo "david" | save file.txt
> ls
╭───┬──────────┬──────┬──────┬────────────────╮
│ # │   name   │ type │ size │    modified    │
├───┼──────────┼──────┼──────┼────────────────┤
│ 0 │ file.txt │ file │  5 B │ now            │
│ 1 │ test3    │ dir  │ 64 B │ 11 minutes ago │

¿Pero por qué esto no funciona? Está intentando comparar cosas

4 > 10
false

Algunas cosas parecen iguales pero son diferentes. Mientras que un comando echo "Hello my friend" está arrojando el valor en la salida, nushell está retornando de un comando por eso logramos hacer esto.

"Hello my friend" == (echo "Hello my friend")
true

Por más que esté mostrando, en verdad está mostrando el retorno de la función y esto no irá a la consola, entonces en un script nu utilizar echo pensando que irá a printar en la consola no funciona. Si quieres eso necesitamos usar print.

print "Hello my friend"
Hello my friend

Tareas en background como en bash por ejemplo mi_comando_que_demora & no es soportado por nushell todavía. Existen soluciones usando Pueue, dale una leída después, pero yo prácticamente no lo utilizo en mi día a día, cuando necesito algo de ese tipo simplemente abro otra terminal. Mi intención es utilizar Nushell para productividad.

Estas cosas vamos aprendiendo con el tiempo.

Vale la pena observar algunas diferencias con bash.

Con el tiempo utilizando mejor la documentación vamos aprendiendo más, por ahora creo que esto es suficiente para que logremos adaptarnos a Nushell.