Mudanças Notáveis

Comandos

No Nushell, vários comandos tradicionais perderam seu sentido original ou foram substituídos por abordagens mais modernas e estruturadas. Alguns exemplos notáveis incluem:

• awk: O Nushell oferece funcionalidades nativas para manipulação de dados estruturados, tornando o awk em grande parte desnecessário.
• sed: Assim como o awk, muitas das funções do sed são substituídas por comandos internos do Nushell para manipulação de strings e dados.
• grep: O Nushell possui comandos nativos para filtragem e busca de dados, reduzindo a necessidade do grep tradicional.
• find: O Nushell implementa sua própria versão de busca de arquivos, que é mais integrada com o sistema de manipulação de dados estruturados.
• wc: Funções como contagem de linhas são realizadas de maneira diferente no Nushell, usando pipelines e comandos nativos.
• jq e yq: Com o Nushell tratando dados JSON e Yaml nativamente, ferramentas como jq se tornam menos necessárias.

Esses comandos tradicionais como sed, grep, awk, e outros ainda existem no Nushell, mas por razões diferentes das encontradas em shells tradicionais: O Nushell mantém esses comandos para garantir compatibilidade com scripts e fluxos de trabalho existentes, transição gradual, interoperabilidade, etc.

Em Flags

Ao migrar para o Nushell, uma das diferenças mais marcantes é a nova abordagem em relação aos comandos e suas flags. Usuários familiarizados com shells como Bash ou Zsh podem inicialmente estranhar a ausência de flags tradicionais em muitos comandos conhecidos. Esta mudança reflete a filosofia central do Nushell: tratar dados de forma estruturada e oferecer uma sintaxe de comando mais simplificada.

No Nushell, muitos comandos foram redesenhados para operar sem flags, adotando uma abordagem baseada em subcomandos e pipelines. Esta nova estrutura promove o uso de pipelines para filtrar e manipular dados, substituindo flags tradicionais por uma série de comandos interconectados. Essa metodologia, embora inicialmente diferente, proporciona uma maneira mais intuitiva e flexível de interagir com o sistema e processar informações.

Porém, como mensionando anteriormente a documentação para os comandos help é muito bem feita facilitando essa migração.

Um exemplo seria o comando ps aux que utilizamos para ver os processos que perderam praticamente todas as flags restando somente -l para visualizar todas as colunas.

~/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  

É possível executar um comando pelo nushell como é implementado pelo sistema operacional ao invés de utilizar o comando redesenhado.

O comando ls -lha não existe no nushell por a flag -h não existe mais. Mas se quisermos invocar o ls nativo do sistema podemos utilizando o ˆ na frente do comando. Verá que os dados voltam a ficar na forma de texto e não são mais estruturados.

# Esta buscando o ls direto 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

Os comandos por dentro do Nushell não são binário tradicionais do sistema operacional, mas sim uma implementação interna do próprio Nushell. Essa implementação faz parte do código-fonte do Nushell e é compilada junto com o shell.

Erros

A maneira como o Nushell lida com erros é um show à parte! As mensagens de erro são apresentadas de forma clara, concisa e altamente informativa.

• Simplicidade: Os erros são exibidos de maneira direta, sem jargões técnicos desnecessários.
• Facilidade de compreensão: As mensagens são formuladas em linguagem acessível, facilitando o entendimento rápido do problema.
• Sugestões úteis: Em muitos casos, o Nushell vai além da simples notificação do erro, oferecendo sugestões práticas para resolução.
• Contextualização: Os erros são frequentemente acompanhados de informações contextuais relevantes, ajudando a identificar a origem do problema.
• Formatação visual: A apresentação visual dos erros é bem estruturada, utilizando cores e formatação para destacar informações importantes.

Esta abordagem intuitiva para o tratamento de erros parece antecipar as necessidades do usuário, tornando o processo de depuração e correção de problemas significativamente mais eficiente e 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 não 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

Variáveis de Ambiente

No Nushell o comando env é um comando externo do sistema, não específico do Nushell por isso:

• Mostra as variáveis de ambiente no formato tradicional de chave=valor.
• A saída é texto simples, não estruturado.

Já o comando $env é um comando interno do Nushell.

• Mostra as variáveis de ambiente como uma estrutura de dados.
• A saída é estruturada, tipicamente em formato de tabela.

A diferença reflete a filosofia do Nushell de tratar dados de forma estruturada. Quando você usa $env, está acessando diretamente o objeto de ambiente do Nushell, que mantém as variáveis em um formato mais rico e manipulável.

Na maioria dos casos, o $env no Nushell e o comando env tradicional mostrarão as mesmas variáveis de ambiente com os mesmos valores. No entanto, podem existir algumas diferenças:

• O $env no Nushell geralmente inclui todas as variáveis mostradas pelo env tradicional.
• O $env pode conter variáveis adicionais específicas do Nushell que não aparecem no env tradicional.
• Algumas variáveis podem ser apresentadas de forma diferente no $env. Por exemplo, o PATH pode ser mostrado como uma lista no Nushell, enquanto no env tradicional é uma string separada por dois pontos.
• O Nushell pode adicionar ou modificar algumas variáveis de ambiente durante a inicialização.

Só para comprar rapidamente...

~> env | wc -l
56
# É necessário formatar a saída de $env para poder ter tudo divido em linhas e colunas.
~> $env | transpose key value | length
62

Podemos observar que temos mais, porém as 56 que encontramos estão dentro das 62.

O Nushell herda as variáveis de ambiente do processo pai que o iniciou.

Esta abordagem oferece várias vantagens:

• Organização: Todas as variáveis de ambiente estão agrupadas em um único local, facilitando o gerenciamento.
• Clareza: O prefixo $env. torna explícito que você está lidando com uma variável de ambiente, não uma variável local ou global.
• Estrutura: O $env é tratado como um objeto estruturado, permitindo operações mais avançadas e consistentes.
• Tipagem: As variáveis dentro de $env podem manter seus tipos de dados originais, não sendo limitadas apenas a strings.
• Segurança: Esta estrutura ajuda a prevenir conflitos acidentais com outras variáveis no shell.

As variáveis de ambiente e as configurações específicas do Nushell são armazenadas no objeto $env. As variáveis de ambiente gerais são acessadas diretamente através de $env, enquanto as configurações do Nushell são mantidas em $env.config. Exploraremos mais detalhadamente o $env.config quando abordarmos a otimização e personalização avançada do Nushell, permitindo-nos aproveitar todo o potencial dele.

O objeto $env não engloba apenas as variáveis de ambiente padrão, mas também configurações específicas do Nushell e outras variáveis internas. Isso explica por que $env apresenta 62 entradas, enquanto o comando env mostra apenas 56.

A variável path que antes era separada por : agora tem uma estrutura que mostra cada path como um item.

~/teste> $env.PATH

# Falaremos disso mais em outro 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}  │

Algumas Facilidades

mkdir agora já tem o -p automático

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

Não é necessário digitar cd para mudar de pasta. Digitou o path vai direto.

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

Algumas Diferenças

O > para redirecionar a saída para algum lugar não funciona.

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

# nem foi criadoo arquivo file.txt
> ls
╭───┬───────┬──────┬──────┬────────────────╮
│ # │ name  │ type │ size │    modified    │
├───┼───────┼──────┼──────┼────────────────┤
│ 0 │ test3 │ dir  │ 64 B │ 10 minutes ago │
╰───┴───────┴──────┴──────┴────────────────╯

Se quer fazer isso vamos usar o 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 │

Mas por que isso não funciona? Ele esta tentando comparar coisas

4 > 10
false

Algumas coisa parecem iguais mas são diferentes. Enquanto um comando echo "Hello my friend" esta jogando o valor na saída o nushell esta retornando de um comando por isso conseguimos fazer isso.

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

Por mais que ele esta mostrando, na verdade ele esta mostrando o retorno da função e isso não irá para o console, então em um script nu utilizar echo achando que irá printar no console não funciona. Se quer isso precisamos usar o print.

print "Hello my friend"
Hello my friend

Tarefas em background como em bash por exemplo meu_comand_que_demora & não é suportado pelo nushell ainda. Existem solução usando o Pueue, dá uma lida depois, mas eu praticamente não utilizo no meu dia a dia, quando preciso de algo desse tipo simplesmente abro outro terminal. A minha intensão é utilizar o Nushell para produtividade.

Essas coisas vamos aprendendo com o tempo.

Vale a pena observar algumas diferenças com bash.

Com o tempo utilizando melhor a documentação vamos aprendendo mais, por enquanto creio que isso é o suficiente para conseguirmos nos adaptar ao Nushell.