Nushell

Shell moderno de datos estructurados que trata la salida de comandos como tablas y soporta pipelines con datos tipados, filtrado y scripting multiplataforma.

Instalación

Comando	Descripción
brew install nushell	Instalar en macOS con Homebrew
cargo install nu	Instalar desde crates.io
winget install nushell	Instalar en Windows con winget
sudo apt install nushell	Instalar en Debian/Ubuntu
pacman -S nushell	Instalar en Arch Linux
nix-env -i nushell	Instalar en NixOS
nu	Iniciar Nushell
nu --version	Mostrar la versión instalada
nu -c "ls"	Ejecutar un solo comando y salir
nu script.nu	Ejecutar un archivo de script Nushell
chsh -s /usr/bin/nu	Establecer Nushell como shell predeterminado

Comandos Básicos

Información del Sistema

Comando	Descripción
sys	Mostrar información completa del sistema
sys host	Mostrar detalles del host (nombre, SO, kernel)
sys mem	Mostrar uso de memoria
sys cpu	Mostrar información de la CPU
sys disks	Mostrar uso de disco
sys net	Mostrar interfaces de red
sys temp	Mostrar sensores de temperatura
date now	Mostrar fecha y hora actual
date now | format date "%Y-%m-%d"	Formatear la fecha actual
$nu.home-path	Mostrar la ruta del directorio home
$nu.os-info	Mostrar detalles del SO

Listado de Archivos

Comando	Descripción
ls	Listar archivos como tabla estructurada
ls -l	Listado largo con detalles
ls -a	Mostrar archivos ocultos
ls **/*.rs	Glob recursivo para archivos Rust
ls | where size > 1mb	Filtrar archivos mayores de 1MB
ls | where type == dir	Filtrar solo directorios
ls | sort-by modified -r	Ordenar por fecha de modificación (más reciente primero)
ls | sort-by size -r	Ordenar por tamaño descendente
ls | get name	Obtener solo la columna de nombres de archivo

Gestión de Procesos

Comando	Descripción
ps	Listar procesos como tabla
ps | where cpu > 10	Encontrar procesos usando >10% de CPU
ps | where name =~ "node"	Encontrar procesos por patrón de nombre
ps | sort-by mem -r | first 10	Top 10 procesos por memoria
ps | where pid == 1234	Encontrar proceso por PID

Sistema de Ayuda

Comando	Descripción
help	Mostrar ayuda general
help commands	Listar todos los comandos disponibles
help ls	Mostrar ayuda para un comando específico
help operators	Listar operadores disponibles
help escapes	Mostrar secuencias de escape de cadenas

Pipeline y Filtros

Operaciones con Tablas

Comando	Descripción
ls | select name size	Seleccionar columnas específicas
ls | reject modified	Eliminar columnas específicas
ls | rename filename filesize	Renombrar columnas
ls | first 5	Obtener las primeras 5 filas
ls | last 3	Obtener las últimas 3 filas
ls | skip 10	Saltar las primeras 10 filas
ls | length	Contar número de filas
ls | reverse	Invertir el orden de filas
ls | shuffle	Aleatorizar el orden de filas
ls | flatten	Aplanar tablas anidadas
ls | columns	Listar nombres de columnas

Filtrado y Ordenamiento

Comando	Descripción
ls | where size > 1mb	Filtrar por comparación
ls | where name =~ "test"	Filtrar por coincidencia regex
ls | where name starts-with "src"	Filtrar por prefijo
ls | where name ends-with ".md"	Filtrar por sufijo
ls | where type in ["file" "dir"]	Filtrar por lista de valores
ls | sort-by size -r	Ordenar descendente
ls | sort-by name -i	Ordenar sin distinción de mayúsculas
ls | uniq-by type	Eliminar duplicados por columna
ls | group-by type	Agrupar filas por valor de columna

Transformación

Comando	Descripción
ls | each { |it| $it.name }	Transformar cada fila
ls | par-each { |it| $it.name }	Transformar en paralelo
ls | update size { |it| $it.size / 1kb }	Actualizar valores de columna
ls | insert label { |it| $it.name + "-file" }	Agregar nueva columna
ls | reduce -f 0 { |it, acc| $acc + $it.size }	Acumular valores
ls | enumerate	Agregar columna de índice
ls | window 3	Ventana deslizante de 3 filas
ls | zip [1 2 3]	Combinar con otra lista
ls | transpose	Intercambiar filas y columnas

Tipos de Datos

Primitivos

Comando	Descripción
42	Entero
3.14	Flotante
"hello"	Cadena de texto
true / false	Booleano
null	Valor nulo
2024-01-15	Fecha
5sec / 3min / 2hr	Duración
1kb / 5mb / 2gb	Tamaño de archivo
0b1010	Literal binario
0xff	Literal hexadecimal

Colecciones

Comando	Descripción
[1 2 3]	Lista
[1 2 3] | append 4	Agregar al final de la lista
[1 2 3] | prepend 0	Agregar al inicio de la lista
{name: "Alice", age: 30}	Registro
{a: 1} | merge {b: 2}	Fusionar registros
[[name age]; ["Alice" 30] ["Bob" 25]]	Literal de tabla
0..9	Rango (0 a 9)
0..<9	Rango exclusivo (0 a 8)
0..2..10	Rango con paso (0, 2, 4, 6, 8, 10)

Conversiones de Tipo

Comando	Descripción
"42" | into int	Cadena a entero
"3.14" | into float	Cadena a flotante
42 | into string	Número a cadena
"true" | into bool	Cadena a booleano
"2024-01-15" | into datetime	Cadena a fecha y hora
1024 | into filesize	Número a tamaño de archivo
5 | into duration --unit sec	Número a duración
42 | into binary	Número a binario
[1 2 3] | into record	Lista a registro
{a: 1} | into record	Convertir a registro

Trabajo con Archivos

Apertura y Análisis

Comando	Descripción
open data.json	Abrir y analizar archivo JSON
open data.csv	Abrir y analizar archivo CSV
open data.yaml	Abrir y analizar archivo YAML
open data.toml	Abrir y analizar archivo TOML
open data.xml	Abrir y analizar archivo XML
open data.tsv	Abrir y analizar archivo TSV
open data.sqlite	Abrir base de datos SQLite
open file.txt	Abrir como texto plano
open data.json | get users	Abrir y navegar dentro de los datos

Guardar y Convertir

Comando	Descripción
"hello" | save hello.txt	Guardar cadena en archivo
ls | save files.json	Guardar tabla como JSON
ls | save files.csv	Guardar tabla como CSV
ls | save files.yaml	Guardar tabla como YAML
open data.json | to csv	Convertir JSON a CSV
open data.csv | to json	Convertir CSV a JSON
open data.json | save data.yaml	Convertir entre formatos
open data.csv | save -f data.csv	Forzar sobrescritura de archivo existente
"line1\nline2" | save -a log.txt	Agregar al final de un archivo

Manipulación de Archivos

Comando	Descripción
open file.txt | lines	Dividir archivo en líneas
open file.txt | lines | length	Contar líneas en archivo
open file.csv | where status == "active"	Filtrar filas de CSV
open file.json | select name email	Seleccionar campos de JSON
open file.json | to yaml | save file.yaml	Convertir JSON a YAML
glob "**/*.md" | each { |f| open $f }	Abrir todos los archivos que coincidan

Operaciones con Cadenas

Mayúsculas/Minúsculas y Formato

Comando	Descripción
"hello world" | str upcase	Convertir a mayúsculas
"HELLO" | str downcase	Convertir a minúsculas
"hello" | str capitalize	Capitalizar primera letra
" hello " | str trim	Recortar espacios en blanco
"hello" | str trim --char "h"	Recortar carácter específico
"hello" | str reverse	Invertir cadena

Búsqueda y Reemplazo

Comando	Descripción
"hello world" | str replace "world" "nu"	Reemplazar primera ocurrencia
"aabaa" | str replace -a "a" "x"	Reemplazar todas las ocurrencias
"hello world" | str replace -r '\w+' 'word'	Reemplazar con regex
"hello world" | str contains "world"	Verificar si la cadena contiene
"hello world" | str starts-with "hello"	Verificar prefijo
"hello world" | str ends-with "world"	Verificar sufijo
"hello world" | str index-of "world"	Encontrar posición de subcadena

División y Unión

Comando	Descripción
"hello world" | split row " "	Dividir por delimitador
"a,b,c" | split row ","	Dividir cadena estilo CSV
"hello" | split chars	Dividir en caracteres
["hello" "world"] | str join " "	Unir lista en cadena
["a" "b" "c"] | str join ","	Unir con coma
"hello" | str length	Obtener longitud de cadena
"hello world" | str substring 0..5	Extraer subcadena

Interpolación de Cadenas

# Interpolación básica
let name = "World"
$"Hello, ($name)!"

# Interpolación de expresiones
$"Total: (1 + 2 + 3)"

# Cadenas multilínea
$"Line 1
Line 2
Line 3"

# Cadenas sin procesar (sin escapes)
r#'C:\Users\path'#

Comandos Personalizados

Definición de Funciones

Comando	Descripción
def greet [name: string] { $"Hello, ($name)!" }	Comando personalizado básico
def add [a: int, b: int] -> int { $a + $b }	Comando con anotaciones de tipo
def greet [name = "World"] { ... }	Comando con parámetro por defecto
def "git branches" [] { git branch | lines }	Nombre estilo subcomando
def --wrapped cmd [...rest] { ... }	Aceptar argumentos extra

Variables y Flujo de Control

Comando	Descripción
let x = 42	Variable inmutable
mut x = 0; $x = $x + 1	Variable mutable
const PI = 3.14159	Constante en tiempo de compilación
if $x > 0 { "pos" } else { "neg" }	Expresión condicional
match $x { 1 => "one", 2 => "two", _ => "other" }	Coincidencia de patrones
for item in [1 2 3] { print $item }	Bucle for
while $x < 10 { $x = $x + 1 }	Bucle while
loop { if $x > 10 { break }; $x += 1 }	Bucle infinito con break
try { risky_op } catch { "failed" }	Manejo de errores

Funciones Avanzadas

# Función con parámetro de bandera
def greet [
  name: string       # Nombre para saludar
  --excited (-e)     # Usar signo de exclamación
] {
  if $excited {
    $"Hello, ($name)!"
  } else {
    $"Hello, ($name)."
  }
}

# Función con parámetros rest
def sum [...nums: int] -> int {
  $nums | math sum
}

# Función con entrada de pipeline
def double-all [] {
  each { |x| $x * 2 }
}
# Uso: [1 2 3] | double-all

Matemáticas y Agregación

Comando	Descripción
[1 2 3 4 5] | math sum	Suma de valores
[1 2 3 4 5] | math avg	Promedio de valores
[1 2 3 4 5] | math min	Valor mínimo
[1 2 3 4 5] | math max	Valor máximo
[1 2 3 4 5] | math median	Valor mediano
[1 2 3 4 5] | math stddev	Desviación estándar
[1 2 3 4 5] | math variance	Varianza
[1 2 3] | math product	Producto de valores
10 | math abs	Valor absoluto
10 | math sqrt	Raíz cuadrada
2 | math round -p 2	Redondear a precisión
10 | math log 2	Logaritmo base 2

HTTP y Redes

Comando	Descripción
http get https://api.example.com/data	Solicitud GET
http post https://api.example.com/data {name: "test"}	Solicitud POST con JSON
http put https://api.example.com/data/1 {name: "updated"}	Solicitud PUT
http delete https://api.example.com/data/1	Solicitud DELETE
http get url --headers [Accept application/json]	GET con encabezados personalizados
http get url | get data	GET y extraer campo
port 8080	Verificar si un puerto está en uso

Ejemplo HTTP

# Obtener y procesar API JSON
let users = (http get "https://jsonplaceholder.typicode.com/users")
$users | select name email | first 5

# POST con encabezados y cuerpo
http post "https://api.example.com/items" {
  name: "New Item"
  price: 29.99
} --headers [Authorization $"Bearer ($env.API_TOKEN)"]

Configuración

Rutas de Configuración

Comando	Descripción
$nu.config-path	Mostrar ruta del archivo de configuración
$nu.env-path	Mostrar ruta del archivo de configuración de entorno
$nu.default-config-dir	Mostrar directorio de configuración
config nu	Abrir configuración en el editor
config env	Abrir configuración de entorno en el editor

Ajustes de Configuración

Comando	Descripción
$env.config.show_banner = false	Desactivar banner de inicio
$env.config.buffer_editor = "vim"	Establecer editor para Ctrl+O
$env.config.history.file_format = "sqlite"	Usar historial SQLite
$env.config.history.max_size = 100_000	Establecer máximo de entradas de historial
$env.config.completions.external.enable = true	Activar completado externo
$env.config.cursor_shape.emacs = "line"	Establecer forma del cursor
$env.config.footer_mode = "25"	Mostrar pie de página para tablas grandes
$env.config.table.mode = "rounded"	Establecer estilo de borde de tabla

Entorno y PATH

Comando	Descripción
$env.PATH = ($env.PATH | prepend "/usr/local/bin")	Agregar al PATH
$env.PATH = ($env.PATH | append "~/.local/bin")	Agregar al final del PATH
$env.EDITOR = "vim"	Establecer variable de entorno
alias ll = ls -l	Crear alias de comando
source ~/.config/nushell/custom.nu	Cargar configuración adicional

Ejemplo de Configuración

# env.nu — configuración de entorno
$env.PATH = ($env.PATH | split row (char esep)
  | prepend "/usr/local/bin"
  | prepend ($env.HOME | path join ".cargo" "bin")
  | append ($env.HOME | path join "go" "bin")
)

$env.EDITOR = "nvim"
$env.VISUAL = "nvim"
$env.PAGER = "less"

# config.nu — configuración del shell
$env.config = {
  show_banner: false
  buffer_editor: "nvim"
  table: {
    mode: rounded
    index_mode: auto
    trim: {
      methodology: wrapping
      wrapping_try_keep_words: true
    }
  }
  history: {
    file_format: "sqlite"
    max_size: 100_000
    sync_on_enter: true
    isolation: false
  }
  completions: {
    case_sensitive: false
    quick: true
    partial: true
    algorithm: "prefix"
    external: {
      enable: true
      max_results: 100
    }
  }
}

Módulos y Overlays

Comando	Descripción
module greet { export def hello [] { "hi" } }	Definir un módulo en línea
use greet hello	Importar comando desde módulo
use greet *	Importar todo desde módulo
use utils.nu	Importar desde archivo de módulo
overlay use spam	Activar overlay
overlay hide spam	Desactivar overlay
overlay list	Listar overlays activos

Ejemplo de Módulo

# archivo: utils.nu
export def "str kebab" [] {
  $in | str downcase | str replace -a " " "-"
}

export def "str title" [] {
  $in | split row " "
  | each { |w| $w | str capitalize }
  | str join " "
}

# Uso:
# use utils.nu
# "Hello World" | str kebab    # "hello-world"
# "hello world" | str title    # "Hello World"

Operaciones de Base de Datos

Comando	Descripción
open data.db	Abrir base de datos SQLite
open data.db | query db "SELECT * FROM users"	Ejecutar consulta SQL
open data.db | query db "SELECT * FROM users WHERE age > 30"	Consulta filtrada
open data.db | schema	Mostrar esquema de base de datos
[[name age]; ["Alice" 30]] | into sqlite data.db	Crear SQLite desde tabla
ls | into sqlite -t files data.db	Guardar tabla en SQLite

Sistema de Plugins

Comando	Descripción
plugin list	Listar plugins instalados
plugin add /path/to/plugin	Registrar un plugin
plugin rm plugin_name	Eliminar un plugin
plugin use plugin_name	Cargar un plugin
cargo install nu_plugin_formats	Instalar plugin de formatos
cargo install nu_plugin_query	Instalar plugin de consultas
cargo install nu_plugin_gstat	Instalar plugin de estado git

Mejores Prácticas

1. Usar datos estructurados — Nushell brilla cuando se trabaja con tablas y registros en lugar de cadenas de texto sin formato. Usa select, where y sort-by en lugar de grep y awk.

2. Tipar los parámetros de las funciones — Agrega anotaciones de tipo a los comandos personalizados (name: string, count: int) para detectar errores temprano y mejorar el autocompletado.

3. Preferir variables inmutables — Usa let por defecto y solo usa mut cuando realmente necesites mutación. Esto previene cambios de estado accidentales en los scripts.

4. Usar historial SQLite — Configura $env.config.history.file_format = "sqlite" para búsquedas más rápidas, mejor resistencia a la corrupción y metadatos más ricos.

5. Aprovechar par-each para rendimiento — Al procesar muchos elementos de forma independiente, par-each se ejecuta en hilos paralelos y puede ser significativamente más rápido que each.

6. Usar módulos para código reutilizable — Organiza los comandos personalizados en archivos de módulo .nu y usa use en lugar de source. Los módulos tienen namespacing y exportaciones adecuados.

7. Usar into para conversiones de tipo — Siempre usa conversión explícita de tipo (into int, into string, etc.) en lugar de confiar en la coerción implícita para scripts confiables.

8. Configurar completados — Activa los completados externos y carapace para soporte de completado en todas las herramientas CLI.

9. Usar interpolación de cadenas — Prefiere $"Hello, ($name)!" sobre la concatenación de cadenas con + para un código más limpio y legible.

10. Manejar errores con try/catch — Envuelve las operaciones que pueden fallar (acceso a archivos, HTTP, análisis) en bloques try { } catch { } para scripts robustos.

11. Probar con describe — Usa expression | describe para inspeccionar el tipo de cualquier valor durante el desarrollo y la depuración.

12. Usar closures de forma consistente — Los closures de Nushell usan la sintaxis { |params| body }. Siempre incluye los caracteres pipe incluso para parámetros únicos por claridad.