Nushell

Shell moderno com dados estruturados que trata a saída de comandos como tabelas e suporta pipelines com dados tipados, filtragem e scripts multiplataforma.

Instalação

Comando	Descrição
brew install nushell	Instalar no macOS com Homebrew
cargo install nu	Instalar a partir do crates.io
winget install nushell	Instalar no Windows com winget
sudo apt install nushell	Instalar no Debian/Ubuntu
pacman -S nushell	Instalar no Arch Linux
nix-env -i nushell	Instalar no NixOS
nu	Iniciar o Nushell
nu --version	Mostrar a versão instalada
nu -c "ls"	Executar um único comando e sair
nu script.nu	Executar um arquivo de script Nushell
chsh -s /usr/bin/nu	Definir Nushell como shell padrão

Comandos Básicos

Informações do Sistema

Comando	Descrição
sys	Mostrar informações completas do sistema
sys host	Mostrar detalhes do host (nome, SO, kernel)
sys mem	Mostrar uso de memória
sys cpu	Mostrar informações da CPU
sys disks	Mostrar uso de disco
sys net	Mostrar interfaces de rede
sys temp	Mostrar sensores de temperatura
date now	Mostrar data e hora atuais
date now | format date "%Y-%m-%d"	Formatar a data atual
$nu.home-path	Mostrar caminho do diretório home
$nu.os-info	Mostrar detalhes do SO

Listagem de Arquivos

Comando	Descrição
ls	Listar arquivos como tabela estruturada
ls -l	Listagem longa com detalhes
ls -a	Mostrar arquivos ocultos
ls **/*.rs	Glob recursivo para arquivos Rust
ls | where size > 1mb	Filtrar arquivos maiores que 1MB
ls | where type == dir	Filtrar apenas diretórios
ls | sort-by modified -r	Ordenar por data de modificação (mais recente primeiro)
ls | sort-by size -r	Ordenar por tamanho decrescente
ls | get name	Obter apenas a coluna de nomes dos arquivos

Gerenciamento de Processos

Comando	Descrição
ps	Listar processos como tabela
ps | where cpu > 10	Encontrar processos usando >10% de CPU
ps | where name =~ "node"	Encontrar processos por padrão de nome
ps | sort-by mem -r | first 10	Top 10 processos por memória
ps | where pid == 1234	Encontrar processo por PID

Sistema de Ajuda

Comando	Descrição
help	Mostrar ajuda geral
help commands	Listar todos os comandos disponíveis
help ls	Mostrar ajuda para um comando específico
help operators	Listar operadores disponíveis
help escapes	Mostrar sequências de escape de string

Pipeline e Filtros

Operações com Tabelas

Comando	Descrição
ls | select name size	Selecionar colunas específicas
ls | reject modified	Remover colunas específicas
ls | rename filename filesize	Renomear colunas
ls | first 5	Obter as primeiras 5 linhas
ls | last 3	Obter as últimas 3 linhas
ls | skip 10	Pular as primeiras 10 linhas
ls | length	Contar o número de linhas
ls | reverse	Inverter a ordem das linhas
ls | shuffle	Aleatorizar a ordem das linhas
ls | flatten	Achatar tabelas aninhadas
ls | columns	Listar nomes das colunas

Filtragem e Ordenação

Comando	Descrição
ls | where size > 1mb	Filtrar por comparação
ls | where name =~ "test"	Filtrar por correspondência regex
ls | where name starts-with "src"	Filtrar por prefixo
ls | where name ends-with ".md"	Filtrar por sufixo
ls | where type in ["file" "dir"]	Filtrar por lista de valores
ls | sort-by size -r	Ordenar decrescente
ls | sort-by name -i	Ordenar sem diferenciar maiúsculas
ls | uniq-by type	Remover duplicatas por coluna
ls | group-by type	Agrupar linhas por valor da coluna

Transformação

Comando	Descrição
ls | each { |it| $it.name }	Transformar cada linha
ls | par-each { |it| $it.name }	Transformar em paralelo
ls | update size { |it| $it.size / 1kb }	Atualizar valores da coluna
ls | insert label { |it| $it.name + "-file" }	Adicionar nova coluna
ls | reduce -f 0 { |it, acc| $acc + $it.size }	Acumular valores
ls | enumerate	Adicionar coluna de índice
ls | window 3	Janela deslizante de 3 linhas
ls | zip [1 2 3]	Combinar com outra lista
ls | transpose	Trocar linhas e colunas

Tipos de Dados

Primitivos

Comando	Descrição
42	Inteiro
3.14	Ponto flutuante
"hello"	String
true / false	Booleano
null	Valor nulo
2024-01-15	Data
5sec / 3min / 2hr	Duração
1kb / 5mb / 2gb	Tamanho de arquivo
0b1010	Literal binário
0xff	Literal hexadecimal

Coleções

Comando	Descrição
[1 2 3]	Lista
[1 2 3] | append 4	Anexar à lista
[1 2 3] | prepend 0	Inserir no início da lista
{name: "Alice", age: 30}	Registro
{a: 1} | merge {b: 2}	Mesclar registros
[[name age]; ["Alice" 30] ["Bob" 25]]	Literal de tabela
0..9	Intervalo (0 a 9)
0..<9	Intervalo exclusivo (0 a 8)
0..2..10	Intervalo com passo (0, 2, 4, 6, 8, 10)

Conversões de Tipo

Comando	Descrição
"42" | into int	String para inteiro
"3.14" | into float	String para ponto flutuante
42 | into string	Número para string
"true" | into bool	String para booleano
"2024-01-15" | into datetime	String para datetime
1024 | into filesize	Número para tamanho de arquivo
5 | into duration --unit sec	Número para duração
42 | into binary	Número para binário
[1 2 3] | into record	Lista para registro
{a: 1} | into record	Converter para registro

Trabalhando com Arquivos

Abertura e Análise

Comando	Descrição
open data.json	Abrir e analisar arquivo JSON
open data.csv	Abrir e analisar arquivo CSV
open data.yaml	Abrir e analisar arquivo YAML
open data.toml	Abrir e analisar arquivo TOML
open data.xml	Abrir e analisar arquivo XML
open data.tsv	Abrir e analisar arquivo TSV
open data.sqlite	Abrir banco de dados SQLite
open file.txt	Abrir como texto simples
open data.json | get users	Abrir e navegar nos dados

Salvamento e Conversão

Comando	Descrição
"hello" | save hello.txt	Salvar string em arquivo
ls | save files.json	Salvar tabela como JSON
ls | save files.csv	Salvar tabela como CSV
ls | save files.yaml	Salvar tabela como YAML
open data.json | to csv	Converter JSON para CSV
open data.csv | to json	Converter CSV para JSON
open data.json | save data.yaml	Converter entre formatos
open data.csv | save -f data.csv	Forçar sobrescrita do arquivo existente
"line1\nline2" | save -a log.txt	Anexar ao arquivo

Manipulação de Arquivos

Comando	Descrição
open file.txt | lines	Dividir arquivo em linhas
open file.txt | lines | length	Contar linhas do arquivo
open file.csv | where status == "active"	Filtrar linhas do CSV
open file.json | select name email	Selecionar campos do JSON
open file.json | to yaml | save file.yaml	Converter JSON para YAML
glob "**/*.md" | each { |f| open $f }	Abrir todos os arquivos correspondentes

Operações com Strings

Caixa e Formatação

Comando	Descrição
"hello world" | str upcase	Converter para maiúsculas
"HELLO" | str downcase	Converter para minúsculas
"hello" | str capitalize	Capitalizar a primeira letra
" hello " | str trim	Remover espaços em branco
"hello" | str trim --char "h"	Remover caractere específico
"hello" | str reverse	Inverter string

Busca e Substituição

Comando	Descrição
"hello world" | str replace "world" "nu"	Substituir primeira ocorrência
"aabaa" | str replace -a "a" "x"	Substituir todas as ocorrências
"hello world" | str replace -r '\w+' 'word'	Substituir com regex
"hello world" | str contains "world"	Verificar se a string contém
"hello world" | str starts-with "hello"	Verificar prefixo
"hello world" | str ends-with "world"	Verificar sufixo
"hello world" | str index-of "world"	Encontrar posição da substring

Divisão e Junção

Comando	Descrição
"hello world" | split row " "	Dividir por delimitador
"a,b,c" | split row ","	Dividir string estilo CSV
"hello" | split chars	Dividir em caracteres
["hello" "world"] | str join " "	Juntar lista em string
["a" "b" "c"] | str join ","	Juntar com vírgula
"hello" | str length	Obter comprimento da string
"hello world" | str substring 0..5	Extrair substring

Interpolação de Strings

# Interpolação básica
let name = "World"
$"Hello, ($name)!"

# Interpolação com expressão
$"Total: (1 + 2 + 3)"

# Strings de múltiplas linhas
$"Line 1
Line 2
Line 3"

# Strings brutas (sem escapes)
r#'C:\Users\path'#

Comandos Personalizados

Definindo Funções

Comando	Descrição
def greet [name: string] { $"Hello, ($name)!" }	Comando personalizado básico
def add [a: int, b: int] -> int { $a + $b }	Comando com anotações de tipo
def greet [name = "World"] { ... }	Comando com parâmetro padrão
def "git branches" [] { git branch | lines }	Nome estilo subcomando
def --wrapped cmd [...rest] { ... }	Aceitar argumentos extras

Variáveis e Fluxo de Controle

Comando	Descrição
let x = 42	Variável imutável
mut x = 0; $x = $x + 1	Variável mutável
const PI = 3.14159	Constante em tempo de compilação
if $x > 0 { "pos" } else { "neg" }	Expressão condicional
match $x { 1 => "one", 2 => "two", _ => "other" }	Correspondência de padrões
for item in [1 2 3] { print $item }	Laço for
while $x < 10 { $x = $x + 1 }	Laço while
loop { if $x > 10 { break }; $x += 1 }	Laço infinito com break
try { risky_op } catch { "failed" }	Tratamento de erros

Funções Avançadas

# Função com parâmetro de flag
def greet [
  name: string       # Nome para cumprimentar
  --excited (-e)     # Usar ponto de exclamação
] {
  if $excited {
    $"Hello, ($name)!"
  } else {
    $"Hello, ($name)."
  }
}

# Função com parâmetros rest
def sum [...nums: int] -> int {
  $nums | math sum
}

# Função com entrada de pipeline
def double-all [] {
  each { |x| $x * 2 }
}
# Uso: [1 2 3] | double-all

Matemática e Agregação

Comando	Descrição
[1 2 3 4 5] | math sum	Soma dos valores
[1 2 3 4 5] | math avg	Média dos 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	Desvio padrão
[1 2 3 4 5] | math variance	Variância
[1 2 3] | math product	Produto dos valores
10 | math abs	Valor absoluto
10 | math sqrt	Raiz quadrada
2 | math round -p 2	Arredondar com precisão
10 | math log 2	Logaritmo na base 2

HTTP e Rede

Comando	Descrição
http get https://api.example.com/data	Requisição GET
http post https://api.example.com/data {name: "test"}	Requisição POST com JSON
http put https://api.example.com/data/1 {name: "updated"}	Requisição PUT
http delete https://api.example.com/data/1	Requisição DELETE
http get url --headers [Accept application/json]	GET com cabeçalhos personalizados
http get url | get data	GET e extrair campo
port 8080	Verificar se a porta está em uso

Exemplo HTTP

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

# POST com cabeçalhos e corpo
http post "https://api.example.com/items" {
  name: "New Item"
  price: 29.99
} --headers [Authorization $"Bearer ($env.API_TOKEN)"]

Configuração

Caminhos de Configuração

Comando	Descrição
$nu.config-path	Mostrar caminho do arquivo de configuração
$nu.env-path	Mostrar caminho do arquivo de configuração de ambiente
$nu.default-config-dir	Mostrar diretório de configuração
config nu	Abrir configuração no editor
config env	Abrir configuração de ambiente no editor

Definições de Configuração

Comando	Descrição
$env.config.show_banner = false	Desativar banner de inicialização
$env.config.buffer_editor = "vim"	Definir editor para Ctrl+O
$env.config.history.file_format = "sqlite"	Usar histórico SQLite
$env.config.history.max_size = 100_000	Definir máximo de entradas no histórico
$env.config.completions.external.enable = true	Ativar completações externas
$env.config.cursor_shape.emacs = "line"	Definir formato do cursor
$env.config.footer_mode = "25"	Mostrar rodapé para tabelas grandes
$env.config.table.mode = "rounded"	Definir estilo de borda da tabela

Ambiente e PATH

Comando	Descrição
$env.PATH = ($env.PATH | prepend "/usr/local/bin")	Adicionar ao PATH
$env.PATH = ($env.PATH | append "~/.local/bin")	Anexar ao PATH
$env.EDITOR = "vim"	Definir variável de ambiente
alias ll = ls -l	Criar alias de comando
source ~/.config/nushell/custom.nu	Carregar configuração adicional

Exemplo de Configuração

# env.nu — configuração de ambiente
$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 — configuração do 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 e Overlays

Comando	Descrição
module greet { export def hello [] { "hi" } }	Definir um módulo inline
use greet hello	Importar comando do módulo
use greet *	Importar tudo do módulo
use utils.nu	Importar de arquivo de módulo
overlay use spam	Ativar overlay
overlay hide spam	Desativar overlay
overlay list	Listar overlays ativos

Exemplo de Módulo

# arquivo: 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"

Operações com Banco de Dados

Comando	Descrição
open data.db	Abrir banco de dados SQLite
open data.db | query db "SELECT * FROM users"	Executar consulta SQL
open data.db | query db "SELECT * FROM users WHERE age > 30"	Consulta filtrada
open data.db | schema	Mostrar esquema do banco de dados
[[name age]; ["Alice" 30]] | into sqlite data.db	Criar SQLite a partir de tabela
ls | into sqlite -t files data.db	Salvar tabela no SQLite

Sistema de Plugins

Comando	Descrição
plugin list	Listar plugins instalados
plugin add /path/to/plugin	Registrar um plugin
plugin rm plugin_name	Remover um plugin
plugin use plugin_name	Carregar um 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 status git

Boas Práticas

1. Use dados estruturados — O Nushell brilha quando você trabalha com tabelas e registros em vez de strings brutas. Encadeie comandos com select, where e sort-by em vez de grep e awk.

2. Tipage os parâmetros das funções — Adicione anotações de tipo aos comandos personalizados (name: string, count: int) para detectar erros cedo e habilitar melhor autocompletar.

3. Prefira variáveis imutáveis — Use let por padrão e use mut apenas quando realmente precisar de mutação. Isso evita mudanças acidentais de estado em scripts.

4. Use histórico SQLite — Defina $env.config.history.file_format = "sqlite" para buscas mais rápidas, melhor resistência a corrupção e metadados mais ricos.

5. Aproveite par-each para desempenho — Ao processar muitos itens independentemente, par-each executa em threads paralelas e pode ser significativamente mais rápido que each.

6. Use módulos para código reutilizável — Organize comandos personalizados em arquivos de módulo .nu e use use em vez de source. Módulos têm namespacing e exportações adequados.

7. Use into para conversões de tipo — Sempre use conversão explícita de tipo (into int, into string, etc.) em vez de depender de coerção implícita para scripts confiáveis.

8. Configure completações — Ative completações externas e carapace para suporte de autocompletar em todas as ferramentas CLI.

9. Use interpolação de strings — Prefira $"Hello, ($name)!" em vez de concatenação de strings com + para código mais limpo e legível.

10. Trate erros com try/catch — Envolva operações que podem falhar (acesso a arquivos, HTTP, análise) em blocos try { } catch { } para scripts robustos.

11. Teste com describe — Use expression | describe para inspecionar o tipo de qualquer valor durante o desenvolvimento e depuração.

12. Use closures consistentemente — Closures do Nushell usam a sintaxe { |params| body }. Sempre inclua os caracteres pipe mesmo para parâmetros únicos para maior clareza.