Zsh (Português) - ArchWiki

Jump to content

# Zsh (Português)

From ArchWiki
Status de tradução: Esse artigo é uma tradução de Zsh. Data da última tradução: 2024-09-22. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Zsh é um shell poderoso que opera tanto como um shell interativo quanto como um interpretador de linguagem de script. Embora seja compatível com o POSIX sh (não por padrão, apenas se emitir `emulate sh`), ele oferece vantagens como a conclusão de comando (preenchimento por tabulação) e globbing aprimorados.

O Zsh FAQ oferece mais motivos para usar o Zsh.

## Instalação

Antes de começar, os usuários podem querer ver qual shell está sendo usado no momento:

    $ echo $SHELL

Instale o pacote zsh. Para complementar com definições de preenchimento automático de comandos, instale também o pacote zsh-completions.

### Configuração inicial

Certifique-se de que o Zsh foi instalado corretamente executando o comando a seguir em um terminal:

    $ zsh

Agora você deverá ver o zsh-newuser-install, que o guiará por algumas configurações básicas. Se quiser pular isso, pressione `q`. Se você não o viu, então você pode invocá-lo manualmente com:

    $ autoload -Uz zsh-newuser-install
    $ zsh-newuser-install -f

Nota Certifique-se de que o tamanho do seu terminal seja de pelo menos 72×15, caso contrário o zsh-newuser-install não será executado.

### Tornando o Zsh seu shell padrão

Mude seu shell para `/usr/bin/zsh`. Veja Shell - linha de comando#Alterando seu shell padrão.

Dica Se estiver substituindo o bash, os usuários podem querer mover algum código de `~/.bashrc` para `~/.zshrc` (por exemplo o prompt e os aliases) e de `~/.bash_profile` para `~/.zprofile` (por exemplo o código que inicia o sistema de janelas do X (X Window System)).

## Arquivos de inicialização/desligamento

Dica Veja Um guia do usuário para o Z-Shell para conhecer a relação de shells interativos e de login, e sobre o que colocar em seus arquivos de inicialização.
Nota

- Se `$ZDOTDIR` não estiver definida, `$HOME` será usada.
- Se a opção `RCS` não estiver definida em nenhum dos arquivos, nenhum arquivo de configuração será lido depois desse arquivo.
- Se a opção `GLOBAL_RCS` não estiver definida em nenhum dos arquivos, nenhum arquivo de configuração global (`/etc/zsh/*`) será lido depois desse arquivo.

Ao iniciar, o Zsh lerá os comandos dos seguintes arquivos respectivamente nesta ordem por padrão, considerando que os mesmos existam.

- `/etc/zsh/zshenv` Usado para definir variáveis de ambiente para todos os usuários. Não deve conter comandos que produzem saídas ou assumem que o shell está anexado a um TTY; quando esse arquivo existir, ele sempre será lido, isto não pode ser modificado ou anulado.

- `$ZDOTDIR/.zshenv` Usado para definir variáveis ​​de ambiente do usuário. Não deve conter comandos que produzam saída ou assumam que o shell está anexado a um TTY; quando esse arquivo existir, ele sempre será lido.

- `/etc/zsh/zprofile` Usado para executar comandos na inicialização para todos os usuários, será lido ao iniciar como um shell de login. Observe que no Arch Linux, por padrão, ele contém uma linha da qual condiciona (pelo comando source) o funcionamento do shell a partir do arquivo `/etc/profile`. Veja o aviso abaixo antes de querer remover isso!

- - `/etc/profile` Este arquivo deverá fornecer as condições (como uma fonte direta das definições, ou seja, pelo source) e as mesmas serão incluídas por todos os shells compatíveis com POSIX shell desde o login: em outras palavras, ele define o `$PATH`, as outras variáveis de ambiente e as configurações de aplicação específica (`/etc/profile.d/*.sh`) desde o login.

- `$ZDOTDIR/.zprofile` Usado para executar comandos do usuário na inicialização, será lido ao iniciar como um shell de login. Normalmente usado para iniciar automaticamente sessões gráficas e para definir variáveis de ambiente para toda a sessão.

- `/etc/zsh/zshrc` Usado para definir a configuração do shell interativo do usuário e executar comandos, será lido ao iniciar como um shell interativo.

- `$ZDOTDIR/.zshrc` Usado para definir a configuração do shell interativo do usuário e executar comandos, será lido ao iniciar como um shell interativo.

- `/etc/zsh/zlogin` Usado para executar comandos para todos os usuários ao final do progresso inicial, será lido ao iniciar como um shell de login.
- `$ZDOTDIR/.zlogin` Usado para executar comandos do usuário no final do progresso inicial, será lido ao iniciar como um shell de login. Normalmente usado para iniciar automaticamente utilitários de linha de comando. Não deve ser usado para iniciar automaticamente sessões gráficas, pois neste ponto a sessão pode conter configuração destinada apenas a um shell interativo.

- `$ZDOTDIR/.zlogout` Usado para executar comandos quando um shell de login sai.

- `/etc/zsh/zlogout` Usado para executar comandos para todos os usuários quando um shell de login sai.

Veja a representação gráfica.

Nota `$HOME/.profile` não faz parte dos arquivos de inicialização do Zsh e não é originado pelo Zsh a menos que o Zsh seja invocado como `sh` ou `ksh` e iniciado como um shell de login. Para mais detalhes sobre os modos de compatibilidade sh e ksh, consulte zsh(1) § COMPATIBILITY.
Atenção Não remova a linha um padrão em `/etc/zsh/zprofile`, caso contrário, isso quebrará a integridade de outros pacotes que fornecem alguns scripts em `/etc/profile.d/`.

## Configurar Zsh

Embora que o Zsh seja plenamente usável desde a instalação, ou como se diria em inglês, out of the box, é quase certo que ele não é pré-configurado da maneira que a maioria dos usuários gostaria de usá-lo; porém, devido à grande quantidade de personalização disponível no Zsh, configurá-lo pode ser uma experiência intimidadora e demorada. Para uma configuração automática, veja sobre as #Extensões de terceiros.

### Simples .zshrc

Abaixo está incluído um arquivo de configuração de exemplo. Ele fornece um conjunto decente de opções padrão, bem como dá exemplos de muitas maneiras pelas quais o Zsh pode ser personalizado. Para usar esta configuração, salve-a como um arquivo chamado `.zshrc`.

Dica Aplique as alterações sem precisar fazer logout e depois faça login novamente executando `source ~/.zshrc`.

Aqui está um simples `.zshrc`:

    ~/.zshrc

    autoload -Uz compinit promptinit
    compinit
    promptinit

    # Isso definirá o prompt padrão para o tema
    walters prompt walters

Veja #Temas de prompt para mais detalhes sobre o sistema de temas de prompt.

### Configurando $PATH

O Zsh vincula a variável `PATH` ao vetor `path`. Isso permite que você manipule `PATH` simplesmente modificando o vetor `path`. Veja A User's Guide to the Z-Shell para detalhes.

Adicione `~/.local/bin/` ao `PATH`:

    ~/.zshenv

    typeset -U path PATH
    path=(~/.local/bin $path)
    export PATH

### Conclusão de comando

Talvez o recurso mais atraente do Zsh sejam suas habilidades avançadas de autocompletar. No mínimo, habilite o autocompletar em `.zshrc`. Para habilitar o autocompletar, adicione o seguinte ao seu `~/.zshrc`:

    ~/.zshrc

    autoload -Uz compinit
    compinit

A configuração acima inclui a conclusão de nomes de host ssh/scp/sftp, mas para que esse recurso funcione, os usuários não devem habilitar o hash de nome de host do ssh (por exemplo, a opção `HashKnownHosts` na configuração do cliente ssh).

Para preenchimento automático com uma interface acionada por teclas de seta, adicione o seguinte a:

    ~/.zshrc

    zstyle ':completion:*' menu select

Para ativar o menu, pressione `Tab` Tab duas vezes.

Para habilitar o preenchimento automático de ambientes privilegiados em comandos privilegiados (por exemplo, se você concluir um comando começando com sudo, os scripts de conclusão também tentarão determinar suas conclusões com sudo), inclua:

    ~/.zshrc

    zstyle ':completion::complete:*' gain-privileges 1

Atenção Isso permitirá que scripts de conclusão Zsh executem comandos com privilégios sudo. Você não deve habilitar isso se usar scripts de conclusão automática não confiáveis.
Nota Esse tipo especial de conclusão sensível ao contexto está disponível apenas para um pequeno número de comandos.

#### Conclusão personalizada

Você pode escrever complementações personalizadas por conta própria. Se fizer isso, você pode consultar a página man zshcompsys(1).

Note que a documentação oficial pode ser difícil de ler. Você pode considerar tentar o tutorial mais simples zsh-completion-howto para um começo fácil.

### Atalhos de teclado

O Zsh não usa readline, em vez disso, ele usa seu próprio e mais poderoso Zsh Line Editor (ZLE). Ele não lê `/etc/inputrc` ou `~/.inputrc`. Leia A closer look at the zsh line editor and creating custom widgets para uma introdução à configuração do ZLE.

O ZLE tem um modo Emacs e um modo vi. Se uma das variáveis de ambiente `VISUAL` ou `EDITOR` então o modo vi será usado; caso contrário, ele será o modo Emacs por padrão. Defina o modo explicitamente com `bindkey -e` ou `bindkey -v` respectivamente para o modo Emacs ou modo vi. O atraso de pressionar a tecla Esc no modo vi é de 0,4s por padrão, e você pode torná-lo mais curto (0,05s) com `export KEYTIMEOUT=5`.

As associações de teclas são atribuídas mapeando uma sequência de escape que corresponde a um pressionamento de tecla para um widget ZLE. Os widgets disponíveis, com descrições de suas ações e suas associações de teclas padrão, estão listados em zshzle(1) § STANDARD WIDGETS e zshcontrib(1) § ZLE FUNCTIONS.

A maneira recomendada de definir associações de teclas no Zsh é usando recursos de string do terminfo(5). Por exemplo [1][2]:

    ~/.zshrc

    # create a zkbd compatible hash;
    # to add other keys to this hash, see: man 5 terminfo
    typeset -g -A key

    key[Home]="${terminfo[khome]}"
    key[End]="${terminfo[kend]}"
    key[Insert]="${terminfo[kich1]}"
    key[Backspace]="${terminfo[kbs]}"
    key[Delete]="${terminfo[kdch1]}"
    key[Up]="${terminfo[kcuu1]}"
    key[Down]="${terminfo[kcud1]}"
    key[Left]="${terminfo[kcub1]}"
    key[Right]="${terminfo[kcuf1]}"
    key[PageUp]="${terminfo[kpp]}"
    key[PageDown]="${terminfo[knp]}"
    key[Shift-Tab]="${terminfo[kcbt]}"

    # setup key accordingly
    [[ -n "${key[Home]}"      ]] && bindkey -- "${key[Home]}"       beginning-of-line
    [[ -n "${key[End]}"       ]] && bindkey -- "${key[End]}"        end-of-line
    [[ -n "${key[Insert]}"    ]] && bindkey -- "${key[Insert]}"     overwrite-mode
    [[ -n "${key[Backspace]}" ]] && bindkey -- "${key[Backspace]}"  backward-delete-char
    [[ -n "${key[Delete]}"    ]] && bindkey -- "${key[Delete]}"     delete-char
    [[ -n "${key[Up]}"        ]] && bindkey -- "${key[Up]}"         up-line-or-history
    [[ -n "${key[Down]}"      ]] && bindkey -- "${key[Down]}"       down-line-or-history
    [[ -n "${key[Left]}"      ]] && bindkey -- "${key[Left]}"       backward-char
    [[ -n "${key[Right]}"     ]] && bindkey -- "${key[Right]}"      forward-char
    [[ -n "${key[PageUp]}"    ]] && bindkey -- "${key[PageUp]}"     beginning-of-buffer-or-history
    [[ -n "${key[PageDown]}"  ]] && bindkey -- "${key[PageDown]}"   end-of-buffer-or-history
    [[ -n "${key[Shift-Tab]}" ]] && bindkey -- "${key[Shift-Tab]}"  reverse-menu-complete

    # Finally, make sure the terminal is in application mode, when zle is
    # active. Only then are the values from $terminfo valid.
    if (( ${+terminfo[smkx]} && ${+terminfo[rmkx]} )); then
    	autoload -Uz add-zle-hook-widget
    	function zle_application_mode_start { echoti smkx }
    	function zle_application_mode_stop { echoti rmkx }
    	add-zle-hook-widget -Uz zle-line-init zle_application_mode_start
    	add-zle-hook-widget -Uz zle-line-finish zle_application_mode_stop
    fi

#### Pesquisa de histórico

Você precisa configurar o conjunto de `key` e certificar-se de que o ZLE entre no modo de aplicativo para usar as seguintes instruções; veja #Atalhos de teclado.

Para habilitar a pesquisa de histórico, adicione estas linhas ao arquivo `.zshrc` :

    ~/.zshrc

    autoload -Uz up-line-or-beginning-search down-line-or-beginning-search
    zle -N up-line-or-beginning-search
    zle -N down-line-or-beginning-search

    [[ -n "${key[Up]}"   ]] && bindkey -- "${key[Up]}"   up-line-or-beginning-search
    [[ -n "${key[Down]}" ]] && bindkey -- "${key[Down]}" down-line-or-beginning-search

Ao fazer isso, somente os comandos anteriores que correspondem à linha atual até a posição atual do cursor serão exibidos quando as teclas `Up` ou `Down` forem pressionadas.

#### Modificadores Shift, Alt, Ctrl and Meta

Terminais compatíveis com xterm podem usar definições de teclas estendidas de user_caps(5). Essas são combinações de `Shift`, `Alt`, `Ctrl` e `Meta` junto com `Up`, `Down`, `Left`, `Right`, `PageUp`, `PageDown`, `Home`, `End` ou `Del`. Consulte zkbd source para obter uma lista de nomes recomendados para as teclas modificadoras e combinações de teclas.

Por exemplo, `Ctrl+Left` para mover para o início da palavra anterior e `Ctrl+Right` para mover para o início da próxima palavra:

    ~/.zshrc

    key[Control-Left]="${terminfo[kLFT5]}"
    key[Control-Right]="${terminfo[kRIT5]}"

    [[ -n "${key[Control-Left]}"  ]] && bindkey -- "${key[Control-Left]}"  backward-word
    [[ -n "${key[Control-Right]}" ]] && bindkey -- "${key[Control-Right]}" forward-word

### Prompts

O Zsh oferece a opção de usar um tema de prompt ou, para usuários que não estão satisfeitos com os temas (ou querem expandir sua utilidade), a possibilidade de criar um prompt personalizado.

#### Temas de prompt

Os temas de prompt são uma maneira rápida e fácil de configurar um prompt colorido no Zsh. Veja zshcontrib(1) § PROMPT THEMES para obter informações sobre temas de prompt e como escrever seu próprio tema.

Para usar um tema, certifique-se de que o prompt theme system esteja definido para autoload em `.zshrc`. Isso pode ser feito adicionando estas linhas a:

    ~/.zshrc

    autoload -Uz promptinit
    promptinit

Os temas de prompt disponíveis são listados executando o comando:

    $ prompt -l

Por exemplo, para usar o tema `walters`, digite:

    $ prompt walters

Para visualizar todos os temas disponíveis, use este comando:

    $ prompt -p

##### Instalando manualmente temas de prompt

É possível instalar temas manualmente, sem ferramentas de gerenciador de configuração externas. Para uma instalação local, primeiro crie uma pasta e adicione-a ao array `fpath`, por exemplo:

    $ mkdir ~/.zprompts
    $ fpath=("$HOME/.zprompts" "$fpath[@]")

Agora crie um link simbólico do seu arquivo de tema nesta pasta:

    $ ln -s mytheme.zsh ~/.zprompts/prompt_mytheme_setup

Se, em vez disso, você deseja instalar um tema globalmente, faça:

    # ln -s mytheme.zsh /usr/share/zsh/functions/Prompts/prompt_mytheme_setup

Agora você deve conseguir ativá-lo usando:

    $ prompt mytheme

Se tudo funcionar, você pode editar seu `.zshrc` adequadamente.

##### Adicionar temas de prompt sem um arquivo separado para cada um

Além de adicionar um tema de prompt por meio de seu próprio arquivo, é possível adicionar temas de dentro de outro arquivo (como seu `.zshrc`), por exemplo:

    ~/.zshrc

    # Load promptinit
    autoload -Uz promptinit && promptinit

    # Define the theme
    prompt_mytheme_setup() {
      PS1="%~%# "
    }

    # Add the theme to promptsys
    prompt_themes+=( mytheme )

    # Load the theme
    prompt mytheme

#### Prompt personalizado

Além de um prompt primário do lado esquerdo `PS1` (`PROMPT`, `prompt`) que é comum a todos os shells, o Zsh também suporta um prompt do lado direito `RPS1` (`RPROMPT`). Essas duas variáveis são as que você vai querer definir para um valor personalizado.

Outros prompts de propósito especial, como `PS2` (`PROMPT2`), `PS3` (`PROMPT3`), `PS4` (`PROMPT4`), `RPS1` (`RPROMPT`), `RPS2` (`RPROMPT2`) e `SPROMPT`, são explicados em zshparam(1) § PARAMETERS USED BY THE SHELL.

Todos os prompts podem ser personalizados com escapes de prompt. Os escapes de prompt disponíveis estão listados em zshmisc(1) § EXPANSION OF PROMPT SEQUENCES.

##### Cores

O Zsh define as cores de forma diferente do Bash; Você não precisa usar sequências de escape ANSI profusas ou recursos de terminal do terminfo(5). O Zsh fornece escapes de prompt convenientes para definir a cor de primeiro plano, cor de fundo e outros efeitos visuais; veja zshmisc(1) § Visual effects para uma lista deles e suas descrições.

As cores podem ser especificadas usando um inteiro decimal, o nome de uma das oito cores mais amplamente suportadas ou como um # seguido por um trio RGB em formato hexadecimal. Veja a descrição de fg=colour em zshzle(1) § CHARACTER HIGHLIGHTING para mais detalhes.

A maioria dos terminais suporta as seguintes cores por nome:

Name | Number
--- | ---
`preta` | `0`
`vermelha` | `1`
`verde` | `2`
`amarela` | `3`
`azul` | `4`
`magenta` | `5`
`ciano` | `6`
`branca` | `7`

Os números de cores 0–255 para emuladores de terminal compatíveis com xterm 256 cores podem ser encontrados no xterm-256color chart.

Com uma variável de ambiente TERM definida corretamente, o número máximo de cores suportado pelo terminal pode ser encontrado no banco de dados terminfo(5) usando `echoti colors`. No caso de cores de 24-bit, verifique também a variável de ambiente COLORTERM com `print $COLORTERM`. Se retornar `24bit` ou `truecolor` seu terminal suporta 16777216 (224) cores, mesmo que terminfo mostre um número menor.

Nota

- As cores 0-15 podem diferir entre emuladores de terminal e seus esquemas de cores usados.
- Muitos emuladores de terminal exibem negrito com uma cor mais brilhante.

Dica

- Escapes de prompt podem ser testados com o comando `print -P "prompt escapes"`, por exemplo:

      $ print -P '%B%F{red}co%F{green}lo%F{blue}rs%f%b'

- Se você usar cores de 24 bits, talvez queira carregar o módulo `zsh/nearcolor` em terminais que não as suportam. Por exemplo:

      [[ "$COLORTERM" == (24bit|truecolor) || "${terminfo[colors]}" -eq '16777216' ]] || zmodload zsh/nearcolor

  Veja zshmodules(1) § THE ZSH/NEARCOLOR MODULE para detalhes sobreo módulo `zsh/nearcolor`.

##### Exemplo

Um exemplo de um prompt simples e incolor:

    PROMPT='%n@%m %~ %# '

Como será exibido:

username@host ~ %

Este é um exemplo de um prompt de dois lados com cor:

    PROMPT='%F{green}%n%f@%F{magenta}%m%f %F{blue}%B%~%b%f %# '
    RPROMPT='[%F{yellow}%?%f]'

E aqui está como será exibido:

username@host ~ % [0]

Para usar cores da faixa de 16 a 255 e cores verdadeiras de 24 bits, você pode usar o número de 0 a 255 atribuído à cor desejada e seu código de cor hexadecimal, respectivamente:

    PROMPT='%F{2}%n%f@%F{5}%m%f %F{4}%B%~%b%f %# '
    RPROMPT='[%F{3}%?%f]'

    PROMPT='%F{#c0c0c0}%n%f@%F{#008000}%m%f %F{#800080}%B%~%b%f %# '
    RPROMPT='[%F{#0000ff}%?%f]'

### Arquivos de exemplo .zshrc

- Para obter a mesma configuração dos lançamentos mensais de ISO (que usam Zsh por padrão), instale grml-zsh-config. Ele inclui muitos ajustes e otimizações avançadas do grml.
- https://github.com/MrElendig/dotfiles-alice/blob/master/.zshrc - configuração básica, com prompt dinâmico e título da janela/hardinfo.
- https://github.com/slashbeast/conf-mgmt/blob/master/roles/home_files/files/DOTzshrc[link inativo 2025-08-16 ⓘ] - zshrc com vários recursos, certifique-se de verificar os comentários nele. Recursos notáveis: função de confirmação para garantir que o usuário deseja executar poweroff, reboot ou hibernate, suporte para GIT em prompt (feito sem vcsinfo), conclusão de tabulação com menu, impressão do comando executado atualmente na barra de título da janela e mais.

Veja dotfiles (Português)#Repositórios de usuários para mais informações.

## Dicas e truques

### Inicialização automática do X no login

Veja xinit#Inicializar automaticamente o X no login.

### Restaurar as configurações do terminal após um programa sair de forma anormal

Muitos programas alteram o estado do terminal e, muitas vezes, não restauram as configurações do terminal ao sair de forma anormal (por exemplo, ao travar ou encontrar SIGINT).

Isso normalmente pode ser resolvido executando reset(1):

    $ reset

As seções a seguir descrevem maneiras de evitar a necessidade de redefinir manualmente o terminal.

#### O comando ttyctl

O comando ttyctl pode ser usado para "congelar/descongelar" o terminal. Para congelar o shell interativo na inicialização, use o seguinte:

    ~/.zshrc

    ttyctl -f

#### Redefinindo o terminal com sequências de escape

Alternate linedrawing character set pode bagunçar o terminal de uma forma que o ttyctl não consegue evitar.

Uma solução simples é emitir as sequências de escape que reiniciam o terminal da função hook `precmd`, para que sejam executadas sempre antes que o prompt seja desenhado. Por exemplo, usando a sequência de escape `\e[0m\e(B\e)0\017\e[?5l\e7\e[0;0r\e8`:

    ~/.zshrc

    autoload -Uz add-zsh-hook

    function reset_broken_terminal () {
    	printf '%b' '\e[0m\e(B\e)0\017\e[?5l\e7\e[0;0r\e8'
    }

    add-zsh-hook -Uz precmd reset_broken_terminal

27 / 5.000 Para testar se funciona, execute:

    $ print '\e(0\e)B'

### Lembrando diretórios recentes

#### Dirstack

O Zsh pode ser configurado para lembrar os últimos diretórios visitados do DIRSTACKSIZE. Isso pode ser usado para cd eles muito rapidamente. Você precisa adicionar algumas linhas ao seu arquivo de configuração:

    ~/.zshrc

    autoload -Uz add-zsh-hook

    DIRSTACKFILE="${XDG_CACHE_HOME:-$HOME/.cache}/zsh/dirs"
    if [[ -f "$DIRSTACKFILE" ]] && (( ${#dirstack} == 0 )); then
    	dirstack=("${(@f)"$(< "$DIRSTACKFILE")"}")
    	[[ -d "${dirstack[1]}" ]] && cd -- "${dirstack[1]}"
    fi
    chpwd_dirstack() {
    	print -l -- "$PWD" "${(u)dirstack[@]}" > "$DIRSTACKFILE"
    }
    add-zsh-hook -Uz chpwd chpwd_dirstack

    DIRSTACKSIZE='20'

    setopt AUTO_PUSHD PUSHD_SILENT PUSHD_TO_HOME

    ## Remove duplicate entries
    setopt PUSHD_IGNORE_DUPS

    ## This reverts the +/- operators.
    setopt PUSHD_MINUS

Agora use

    $ dirs -v

para imprimir o dirstack. Use `cd -<NUM>` para voltar para uma pasta visitada. Use autocompletar depois do hífen. Isso é muito útil se estiver usando o menu de autocompletar.

Nota Se você tiver mais de uma sessão zsh aberta e tentar executar o `cd`, isso não funcionará devido a um conflito em ambas as sessões gravando no mesmo arquivo.

#### cdr

cdr permite que você altere o diretório de trabalho para um diretório de trabalho anterior de uma lista mantida automaticamente. Ele armazena todas as entradas em arquivos que são mantidos entre sessões e (por padrão) entre emuladores de terminal na sessão atual.

Veja zshcontrib(1) § REMEMBERING RECENT DIRECTORIES para instruções de configuração.

#### zoxide

zoxide é um comando cd mais inteligente que permite que você navegue em qualquer lugar com apenas algumas teclas. Ele lembra seus diretórios usados com frequência e usa um mecanismo de pontuação para adivinhar onde você quer ir.

### Comando Help

Ao contrário do Bash, o Zsh não habilita um comando `help` embutido, em vez disso, ele fornece `run-help`. Por padrão `run-help` é um alias para `man`, ele pode ser executado manualmente adicionando-o a um comando ou pode ser invocado para o comando digitado atualmente com os atalhos de teclado `Alt+h` ou `Esc` `h`.

Como por padrão é apenas um alias para man, ele só funcionará em comandos externos. Para melhorar sua funcionalidade, para que funcione em builtins de shell e outros recursos de shell, você precisa usar a função `run-help`. Veja zshcontrib(1) para mais informações sobre o `run-help` e suas funções de assistente.

Primeiro carregue a função `run-help` e então remova o alias `run-help` existente. Por conveniência, `help` pode ser aliasado "apelidado" para `run-help`. Por exemplo, adicione o seguinte ao seu `zshrc`:

    autoload -Uz run-help
    (( ${+aliases[run-help]} )) && unalias run-help
    alias help=run-help

As funções do assistente devem ser habilitadas separadamente:

    autoload -Uz run-help-git run-help-ip run-help-openssl run-help-p4 run-help-sudo run-help-svk run-help-svn

Por exemplo, o comando `run-help git commit` agora abrirá a página de manual git-commit(1) em vez de git(1).

### Rehash persistente

Normalmente, o compinit não encontrará automaticamente novos executáveis ​​no `$PATH`. Por exemplo, após instalar um novo pacote, os arquivos em `/usr/bin/` não seriam incluídos imediatamente ou automaticamente na conclusão. Assim, para ter esses novos executáveis ​​incluídos, executaria:

    $ rehash

This 'rehash' can be set to happen automatically.[3] Simply include the following in your `zshrc`:

    ~/.zshrc

    zstyle ':completion:*' rehash true

#### Rehash sob demanda

Como acima, no entanto, o pacman pode ser configurado com hooks para solicitar automaticamente um `rehash`, o que não incorre na penalidade de desempenho do rehashing constante como acima. Para habilitar isso, crie o diretório `/etc/pacman.d/hooks` e um diretório `/var/cache/zsh`, então crie um arquivo de hook:

    /etc/pacman.d/hooks/zsh.hook

    [Trigger]
    Operation = Install
    Operation = Upgrade
    Operation = Remove
    Type = Path
    Target = usr/bin/*
    [Action]
    Depends = zsh
    When = PostTransaction
    Exec = /usr/bin/install -Dm644 /dev/null /var/cache/zsh/pacman

Isso mantém a data de modificação do arquivo `/var/cache/zsh/pacman` consistente com a última vez que um pacote foi instalado, atualizado ou removido. Então, `zsh` deve ser persuadido a refazer o hash de seu próprio cache de comando quando ele ficar desatualizado, adicionando ao seu `~/.zshrc`:

    ~/.zshrc

    zshcache_time="$(date +%s%N)"

    autoload -Uz add-zsh-hook

    rehash_precmd() {
      if [[ -a /var/cache/zsh/pacman ]]; then
        local paccache_time="$(date -r /var/cache/zsh/pacman +%s%N)"
        if (( zshcache_time < paccache_time )); then
          rehash
          zshcache_time="$paccache_time"
        fi
      fi
    }

    add-zsh-hook -Uz precmd rehash_precmd

Se o hook `precmd` for acionado antes de `/var/cache/zsh/pacman` ser atualizado, a conclusão pode não funcionar até que um novo prompt seja iniciado. Executar um comando vazio, por exemplo, pressionar `enter`, deve ser suficiente.

#### Rehash alternativo sob demanda usando SIGUSR1

Como acima, porém o arquivo hook se parece com isto:

    /etc/pacman.d/hooks/zsh-rehash.hook

    [Trigger]
    Operation = Install
    Operation = Upgrade
    Operation = Remove
    Type = Path
    Target = usr/bin/*

    [Action]
    Depends = zsh
    Depends = procps-ng
    When = PostTransaction
    Exec = /usr/bin/pkill zsh --signal=USR1

Atenção Isso envia SIGUSR1 para todas as instâncias `zsh` em execução. Observe que o comportamento padrão para SIGUSR1 é encerrar, então quando você configura isso pela primeira vez, todas as instâncias `zsh` em execução de todos os usuários (incluindo shells de login) serão encerradas se eles não tiverem originado a armadilha abaixo.

    ~/.zshrc

    TRAPUSR1() { rehash }

A função trap acima pode ser substituída por uma lista trap `trap 'rehash' USR1`. Veja zshmisc(1) § Funções Trap para diferenças entre tipos de traps.

Este método irá instantaneamente `rehash` todas as instâncias `zsh`, eliminando a necessidade de pressionar enter para acionar `precmd`.

### Vincular tecla ao aplicativo ncurses

Vincule um aplicativo ncurses a um pressionamento de tecla, mas ele não aceitará interação. Use a variável `BUFFER` para fazê-lo funcionar. O exemplo a seguir permite que os usuários abram ncmpcpp usando `Alt+\`:

    ~/.zshrc

    ncmpcppShow() {
      BUFFER="ncmpcpp"
      zle accept-line
    }
    zle -N ncmpcppShow
    bindkey '^[\' ncmpcppShow

Um método alternativo, que manterá tudo o que você inseriu na linha antes de chamar o aplicativo:

    ~/.zshrc

    ncmpcppShow() {
      ncmpcpp <$TTY
      zle redisplay
    }
    zle -N ncmpcppShow
    bindkey '^[\' ncmpcppShow

### Atalhos de teclado do gerenciador de arquivos

Atalhos de teclado como os usados ​​em gerenciadores de arquivos gráficos podem ser úteis. O primeiro retorna ao histórico do diretório (`Alt+Left`), o segundo permite que o usuário vá para o diretório pai (`Alt+Up`). Eles também exibem o conteúdo do diretório.

    ~/.zshrc

    cdUndoKey() {
      popd
      zle       reset-prompt
      print
      ls
      zle       reset-prompt
    }

    cdParentKey() {
      pushd ..
      zle      reset-prompt
      print
      ls
      zle       reset-prompt
    }

    zle -N                 cdParentKey
    zle -N                 cdUndoKey
    bindkey '^[[1;3A'      cdParentKey
    bindkey '^[[1;3D'      cdUndoKey

### Título do xterm

Se o seu emulador de terminal suportar, você pode definir seu título a partir do Zsh. Isso permite alterar dinamicamente o título para exibir informações relevantes sobre o estado do shell, por exemplo, mostrando o nome do usuário e o diretório atual ou o comando em execução no momento.

O título xterm é definido com o xterm control sequence operating system command `\e]2;``\a` ou `\e]2;``\e\\`. Por exemplo:

    $ print -n '\e]2;Meu título xterm\a'

irá definir o título para

    Meu título xterm

Uma maneira simples de ter um título dinâmico é definir o título nas funções hook `precmd` e `preexec`. Veja zshmisc(1) § Hook Functions para uma lista de funções hook disponíveis e suas descrições.

Ao usar `print -P`, você também pode aproveitar os escapes de prompt do Zsh.

Dica

- A impressão de títulos pode ser dividida em vários comandos, desde que sejam sequenciais.
- GNU Screen envia o título xterm para o hardstatus (`%h`). Se você quiser usar os escapes de string do Screen (por exemplo, para cores), você deve definir o hardstatus com a sequência de escape `\e_``\e\\`. Caso contrário, se escapes de string forem usados ​​em `\e]2;``\a`, o emulador de terminal obterá um título ilegível devido à incapacidade de interpretar os escapes de string do Screen.

Note

- Não use a opção `-P` de `print` ao imprimir variáveis ​​para evitar que elas sejam analisadas como escapes de prompt.
- Use o `q` parameter expansion flag ao imprimir variáveis para evitar que elas sejam analisadas como sequências de escape.

    ~/.zshrc

    autoload -Uz add-zsh-hook

    function xterm_title_precmd () {
    	print -Pn -- '\e]2;%n@%m %~\a'
    	[[ "$TERM" == 'screen'* ]] && print -Pn -- '\e_\005{2}%n\005{-}@\005{5}%m\005{-} \005{+b 4}%~\005{-}\e\\'
    }

    function xterm_title_preexec () {
    	print -Pn -- '\e]2;%n@%m %~ %# ' && print -n -- "${(q)1}\a"
    	[[ "$TERM" == 'screen'* ]] && { print -Pn -- '\e_\005{2}%n\005{-}@\005{5}%m\005{-} \005{+b 4}%~\005{-} %# ' && print -n -- "${(q)1}\e\\"; }
    }

    if [[ "$TERM" == (Eterm*|alacritty*|aterm*|foot*|gnome*|konsole*|kterm*|putty*|rxvt*|screen*|wezterm*|tmux*|xterm*) ]]; then
    	add-zsh-hook -Uz precmd xterm_title_precmd
    	add-zsh-hook -Uz preexec xterm_title_preexec
    fi

#### Título da aba do emulador de terminal

Alguns emuladores de terminal e multiplexadores suportam a configuração do título da aba. As sequências de escape dependem do terminal:

Terminal | Escape sequences | Description
--- | --- | ---
GNU Screen | `\ek``\e\\` | Título da janela do Screen (`%t`).
Konsole | `\e]30;``\a` | Título da aba do Konsole.

### Detecção de ambiente de shell

Veja a repository about shell environment detection para testes para detectar o ambiente shell. Isso inclui login/shell interativo, sessão Xorg, sessão TTY e SSH.

### /dev/tcp equivalente: ztcp

Use o módulo `zsh/net/tcp`:

    $ zmodload zsh/net/tcp

Agora você pode estabelecer conexões TCP:

    $ ztcp example.com 80

Mais detalhes estão disponíveis em zshmodules(1) § THE_ZSH/NET/TCP_MODULE e zshtcpsys(1).

### Atalho para sair do shell na linha de comando parcial

Por padrão, `Ctrl+d` não fechará seu shell se a linha de comando estiver preenchida. Isso corrige o problema:

    .zshrc

    exit_zsh() { exit }
    zle -N exit_zsh
    bindkey '^D' exit_zsh

### Manipulador pacman -F "command not found"

pacman inclui funcionalidade para procurar por pacotes contendo um arquivo. O seguinte manipulador command-not-found usará pacman diretamente para procurar por pacotes correspondentes quando um comando desconhecido for executado.

    ~/.zshrc

    ...
    function command_not_found_handler {
        local purple='\e[1;35m' bright='\e[0;1m' green='\e[1;32m' reset='\e[0m'
        printf 'zsh: command not found: %s\n' "$1"
        local entries=(
            ${(f)"$(/usr/bin/pacman -F --machinereadable -- "/usr/bin/$1")"}
        )
        if (( ${#entries[@]} ))
        then
            printf "${bright}$1${reset} may be found in the following packages:\n"
            local pkg
            for entry in "${entries[@]}"
            do
                # (repo package version file)
                local fields=(
                    ${(0)entry}
                )
                if [[ "$pkg" != "${fields[2]}" ]]
                then
                    printf "${purple}%s/${bright}%s ${green}%s${reset}\n" "${fields[1]}" "${fields[2]}" "${fields[3]}"
                fi
                printf '    /%s\n' "${fields[4]}"
                pkg="${fields[2]}"
            done
        fi
        return 127
    }
    ...

Note O banco de dados de arquivos do pacman é separado do banco de dados de sincronização normal e precisa ser obtido usando `pacman -Fy`. Veja pacman (Português)#Pesquisar por um pacote que contenha um arquivo específico para detalhes.

Para uma alternativa usando pkgfile, veja #Manipulador pacman -F "command not found".

### Limpe o backbuffer usando uma combinação de teclas

Por padrão, a tecla de atalho clear screen não limpará o backbuffer (a parte que você precisa rolar para cima para vê-lo) na maioria dos emuladores de terminal. Uma possível solução para esse problema é a seguinte.

    ~/.zshrc

    ...
    function clear-screen-and-scrollback() {
        printf '\x1Bc'
        zle clear-screen
    }

    zle -N clear-screen-and-scrollback
    bindkey '^L' clear-screen-and-scrollback
    ...

## Extensões de terceiros

### Frameworks de configuração

Note Frameworks introduzem um nível de abstração e complexidade. Eles podem, e frequentemente o fazem, introduzir comportamento indefinido. Em caso de quebra de shell, o primeiro passo de depuração deve ser reverter para o shell simples.

- oh-my-posh — Oh My Posh é um mecanismo de prompt personalizado para qualquer shell que tenha a capacidade de ajustar a sequência de prompts com uma função ou variável.

  https://github.com/JanDeDobbeleer/oh-my-posh || oh-my-poshAUR

- oh-my-zsh — Um framework popular, conduzido pela comunidade, para gerenciar sua configuração Zsh. Ele vem com uma tonelada de funções úteis, auxiliares, plugins, temas.

  https://github.com/ohmyzsh/ohmyzsh || oh-my-zsh-gitAUR

- Prezto — Um framework de configuração para Zsh. Ela vem com módulos, enriquecendo o ambiente de interface de linha de comando com padrões sensatos, aliases, funções, preenchimento automático e temas de prompt.

  https://github.com/sorin-ionescu/prezto || prezto-gitAUR

- ZIM — Um framework de configuração com velocidade incrível e extensões modulares. O Zim é muito fácil de personalizar e vem com um rico conjunto de módulos e recursos sem comprometer a velocidade ou a funcionalidade.

  https://github.com/zimfw/zimfw || zsh-zim-gitAUR

### Gerenciadores de plugins

- Antidote — Um recurso de implementação completa do Zsh do gerenciador de plugins Antibody legado.

  https://github.com/mattmc3/antidote || zsh-antidoteAUR

- zinit (previously "zplugin") — Gerenciador de plugins Zsh flexível com fpath limpo, relatórios, gerenciamento de conclusão, modo turbo REVIVED

  https://github.com/zdharma-continuum/zinit || zinitAUR

- zi (previously "zplugin") — Fork alternativo do zplugin com o objetivo de expandir o projeto original, em vez de preservação e manutenção do projeto original como o zinit.

  https://github.com/z-shell/zi || not packaged? search in AUR

- sheldon — Gerenciador de plugins de shell rápido e configurável, escrito em Rust [4]

  https://github.com/rossmacarthur/sheldon || sheldon

- Antigen — Um gerenciador de plugins para Zsh, inspirado em oh-my-zsh e vundle. ABANDONED

  https://github.com/zsh-users/antigen || antigen-gitAUR

- zgen — Um gerenciador de plugins leve e simples para Zsh. ABANDONED

  https://github.com/tarjoilija/zgen || zgen-gitAUR

- zplug — Um gerenciador de plugins de última geração para Zsh. ABANDONED

  https://github.com/zplug/zplug || zplugAUR

### Realce de sintaxe e sugestões automáticas semelhantes às do Fish

Fish fornece realce de sintaxe de shell e autosuggestions muito poderosos. Para usar ambos no Zsh, você pode instalar zsh-syntax-highlighting, zsh-autosuggestions e, finalmente, source um ou ambos os scripts fornecidos do seu zshrc:

    ~/.zshrc

    source /usr/share/zsh/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
    source /usr/share/zsh/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh

### Manipulador pkgfile "command not found"

pkgfile inclui um arquivo de script Zsh que fornece uma função `command_not_found_handler` que pesquisará automaticamente o banco de dados pkgfile ao inserir um comando não reconhecido.

Você precisa source o script para habilitá-lo. Por exemplo:

    ~/.zshrc

    source /usr/share/doc/pkgfile/command-not-found.zsh

Nota O banco de dados pkgfile pode precisar ser atualizado antes que isso funcione. Veja pkgfile#Instalação para detalhes.

Para uma alternativa usando a funcionalidade nativa do pacman, veja #Manipulador pacman -F "command not found".

## See also

- Wikipedia:Zsh
- Uma introdução ao Z Shell
- Um guia do usuário para ZSH
- Manual do Z Shell (formato diferente disponível aqui)
- Zsh FAQ
- zsh-lovers(1) (disponível como pacote zsh-lovers)
- Gentoo: Zsh/Guide
- Cartão de referência Bash2Zsh

Category:

- Command-line shells (Português)

Hidden categories:

- Pages with dead links
- Pages with missing package links

Zsh (Português)
Add topic