Guia completo de curingas no shell Linux

Links rápidos

• O que são curingas?
• Especificar um carácter: “?”
• Matchede múltiplos caracteres com “*”
• Intervalos de caracteres com colchetes
• Alternância com parênteses e extglob
• Excluir correspondências com “!” e “^”
• Desativar curingas com aspas
• Opções do shell: extglob, globstar, nullglob, failglob
• Boas práticas e segurança
• Folha de consulta rápida (cheat sheet)
• Casos de teste e critérios de aceitação

O que são curingas?

Curingas (wildcards), também chamados metacaracteres, são símbolos que representam um ou vários caracteres em padrões de nomes de ficheiros. O shell — não os programas — expande esses padrões antes de chamar o comando. Ou seja, ao digitar ls .jpg, o shell substitui .jpg pela lista de ficheiros correspondentes e só depois invoca ls.

Definição rápida: um curinga é um padrão textual que o shell transforma numa lista de nomes de ficheiros que correspondem ao padrão.

Importante: diferentes shells (bash, zsh, ksh) têm capacidades distintas. Os dois padrões mais portáveis são ? (um carácter) e (zero ou mais caracteres). Para recursos avançados (como extglob +(…), !(…), ou globstar *) pode ser necessário ativar opções do shell.

Especificar um carácter: “?”

O curinga ? corresponde exatamente a um carácter. Use-o quando souber o número de caracteres, mas não o carácter exato.

Exemplo: listar fotos com nomes photo.01.jpg, photo.02.jpg:

ls photo.0?.jpg

Se não houver correspondências, o comportamento depende do shell e das opções: pode receber o próprio padrão, uma linha em branco ou uma mensagem de erro.

Encontrar vários caracteres com “*”

O asterisco * corresponde a zero ou mais caracteres. É o curinga mais usado.

Exemplos básicos:

ls *.jpg
ls photos/*.jpg
ls *.p?
ls *d*

Observações importantes:

• • não corresponde a ficheiros que comecem com um ponto (ficheiros “ocultos”), salvo se você incluir explicitamente o ponto no padrão (por exemplo, .*), ou ativar dotglob no Bash.
• Em shells modernos pode haver comportamento recursivo com (globstar). Em Bash, shopt -s globstar habilita para corresponder recursivamente a subdiretórios.

Exemplos de pesquisa recursiva em zsh/bash com globstar:

ls ~/
ls /usr//bin

A forma * (três asteriscos) pode ser mencionada em algumas implementações como analisando também links simbólicos; comportamento concreto varia por shell. Sempre consulte a documentação do shell quando precisar de correspondência através de links simbólicos.

Cuidado: comandos destrutivos combinados com curingas (por exemplo, rm *) podem eliminar muitos ficheiros. Teste sempre primeiro com echo ou ls.

Intervalos de caracteres com colchetes

Os colchetes [ ] permitem declarar classes ou intervalos de caracteres.

Exemplos:

[a b c]       # qualquer um dos caracteres a, b ou c
[a-z]         # qualquer letra minúscula
[A-Z]         # qualquer letra maiúscula
[0-9]         # qualquer dígito
[a-zA-Z0-9]   # alfanuméricos
*.p[ly]       # termina em .pl ou .py

Combinações com * e ? são muito comuns. Por exemplo:

ls *.p[ly]

Também existem expansões por chaves (brace expansion), que são feitas antes da expansão de curingas e não devem ser confundidas com globbing:

echo {cat,dog}
echo {a..d}
echo {1..10}

As expansões por chaves não consultam o sistema de ficheiros — apenas produzem strings expandidas.

Alternância com parênteses e extglob

Alguns comportamentos de alternância mais poderosos exigem “expanded globbing” (extglob) no Bash ou funcionalidades nativas em shells como zsh.

Sintaxe comum do extglob (Bash com shopt -s extglob):

• ?(pattern) — corresponde a zero ou uma ocorrência de pattern
• *(pattern) — corresponde a zero ou mais ocorrências
• +(pattern) — corresponde a uma ou mais ocorrências
• @(pattern) — corresponde exatamente a uma das alternativas (equivalente a (a|b))
• !(pattern) — corresponde a tudo exceto o que casa com pattern

Exemplos:

shopt -s extglob        # habilita extglob no Bash
ls *.(pl|py)
ls @(*.jpg|*.png)
ls !(*.tmp)             # liste tudo exceto ficheiros .tmp

Outra forma de alternância, suportada por shells que entendem parênteses com |, é:

ls *.(pl|py)
.*p(l|y)

Esses padrões permitem escrever correspondências complexas e compactas.

Excluir correspondências com “!” e “^”

Nos colchetes, o caracter inicial ! ou ^ nega a classe:

ls [!a-z]   # nomes cujo primeiro carácter não seja letra minúscula
ls [^a-z]   # idem

No extglob, !(a|b|c) corresponde a tudo exceto as alternativas a, b ou c:

ls !(a|b|c)

Desativar curingas com aspas

Quando quer que os curingas sejam passados literalmente (por exemplo, para grep ou para construir expressões regulares), use aspas.

• Aspas simples ‘ ‘ desativam expansão de variáveis e de curingas.
• Aspas duplas “ “ desativam somente a expansão de curingas; variáveis ainda são expandidas.

Exemplos:

grep '^foo'            # ^ interpretado pelo grep, não pelo shell
pattern='^foo'
grep "$pattern"      # variável expandida, ^ preservado para o grep

Se precisar de desativar completamente a expansão de nomes de ficheiro no shell, pode usar:

set -f    # desliga globbing (Bash e sh)
set +f    # liga novamente

Em scripts, evite confiar em curingas sem verificar o resultado — use sempre testes e tratamento de erros.

Opções do shell que afetam o comportamento dos curingas

Bash e zsh têm opções que mudam o comportamento padrão dos curingas. Aqui estão as mais úteis e portáveis para Bash:

• shopt -s extglob — ativa as construções extglob (+(…), ?(…), etc.).
• shopt -s globstar — ativa ** para correspondência recursiva a subdiretórios.
• shopt -s nullglob — faz com que padrões que não correspondam a nada expandam para nada (em vez do próprio padrão).
• shopt -s failglob — faz o shell falhar com erro se um padrão não corresponder a nada.
• set -f — desliga completamente a expansão de nomes de ficheiro (noglob).

Exemplo de ativação no Bash:

shopt -s extglob globstar nullglob

No zsh, muitas capacidades estão ativas por padrão. Para recursos avançados recomenda-se consultar man zshoptions e ativar EXTENDED_GLOB se necessário:

setopt EXTENDED_GLOB

Sempre prefira documentar as opções que o seu script exige no topo do script (com comentários) e, quando possível, detecte o shell ou defina as opções necessárias explicitamente.

comportamentos de dotfiles e correspondência de nomes que começam com “.”

Por padrão, * e ? não correspondem a nomes que começam por “.” (dotfiles). Para incluir esses ficheiros usa-se padrões que comecem com “.” ou ativa-se dotglob no Bash:

shopt -s dotglob
ls *    # agora inclui ficheiros que começam com .

Caso contrário, use padrões explícitos:

ls .[^.]*  # ficheiros cujo primeiro carácter é . seguido de outro que não seja .

Boas práticas e segurança

• Teste sempre antes: use echo ou printf para ver a expansão antes de executar comandos destrutivos.

echo rm *.log
printf '%s
' *.log

• Use – para indicar fim de opções quando trabalhar com nomes que começam com -:

rm -- -file-with-leading-dash

• Para apagar muitos ficheiros de forma segura prefira opções interativas ou confirmações (rm -i) e mantenha backups.
• Use arrays e nomes entre aspas em scripts para tratar espaços e caracteres especiais.

Exemplo (bash) para copiar ficheiros numa array:

files=( *.jpg )
cp -- "${files[@]}" /out/dir/

• Cuidado com input não confiável: não construa padrões com conteúdo fornecido por utilizadores sem sanitização — um padrão mal formado pode expandir para ficheiros inesperados.

Situações em que curingas falham ou enganham

• Ficheiros com espaços, novas linhas ou caracteres especiais — sem aspas e arrays, a expansão pode separar campos incorretamente.
• Pontos iniciais (dotfiles) não correspondem a . Evite supor que lista absolutamente tudo.
• Em sistemas com muitas correspondências, a expansão pode exceder limites de tamanho de linha do shell (ARG_MAX). Nesses casos, use find + -exec, xargs -0 ou processamentos por lotes.

Exemplo com find para evitar limitações de expansões massivas:

find . -name '*.log' -print0 | xargs -0 rm --

Folha de consulta rápida (cheat sheet)

• •     : zero ou mais caracteres

• ? : exatamente um carácter
• [abc] : qualquer um dos caracteres listados
• [a-z] : intervalo de caracteres
• {a,b,c} : brace expansion (gera cadeias, não globbing)
• ** : recursivo (com globstar ligado)
• .?* : ficheiros que começam por . (dotfiles — exigem padrão explícito ou dotglob)
• shopt -s extglob : ativa +(), ?(), @(), !() no Bash
• set -f : desliga expansão de nomes de ficheiro (noglob)

Mini-metodologia para usar curingas em scripts (passo a passo)

1. Identifique o resultado pretendido (lista de ficheiros, padrão textual, passagem literal para outro programa).
2. Escolha o curinga adequado (*, ?, [..], extglob) e escreva o padrão.
3. Teste localmente: echo, printf, ls.
4. Considere opções do shell: dotglob, nullglob, globstar, extglob.
5. Proteja-se contra ficheiros com espaços: use arrays e aspas.
6. Para operações destrutivas, peça confirmação ou faça backup.
7. Documente as opções exigidas pelo script (ex.: shopt -s extglob).

Casos de teste / critérios de aceitação

Dado um diretório com estes ficheiros:

photo.01.jpg
photo.02.jpg
script.pl
script.py
.readme
archive.tar.gz
file-1.txt
file-2.txt

Exemplos de padrões e o que devem expandir para (aceitação):

• ls photo.0?.jpg -> photo.01.jpg photo.02.jpg
• ls *.jpg -> photo.01.jpg photo.02.jpg
• ls *.p? -> script.pl script.py
• ls [a-z]*.txt -> file-1.txt file-2.txt
• ls .* -> .readme (incluir só .readme)
• shopt -s nullglob; echo .exe -> (expande para nada, sem imprimir “.exe”)

Se o resultado real corresponder às expansões previstas, o teste passa. Em scripts, considere também casos com nenhum ficheiro correspondente (nullglob vs failglob).

Checklists por função

Iniciante:

• Testar padrões com echo antes de executar
• Evitar rm sem verificação
• Preferir GUI ou ls para confirmar

Administrador de sistemas:

• Usar find/xargs para conjuntos muito grandes
• Documentar opções de shell no topo de scripts
• Fazer backups antes de operações massivas

Desenvolvedor de scripts:

• Usar arrays e aspas para variáveis com nomes
• Definir shopt/set -f explicitamente quando necessário
• Tratar dotfiles conscientemente

Exemplos avançados e armadilhas comuns

1. Problema: ficheiros com espaços

# ficheiros: "a file.txt" "b file.txt"
ls *.txt    # expande para a file.txt b file.txt -> é perigoso se não estiver entre aspas
files=( *.txt )
for f in "${files[@]}"; do
  echo "Ficheiro: $f"
done

2. Problema: usar rm * em diretório errado

Sempre confirme o diretório com pwd e use echo rm antes de executar.

3. Limites de ARG_MAX

Se houver milhares de ficheiros, a expansão pode gerar uma lista tão grande que o kernel recuse a execução do comando. Use find -exec ou xargs.

find . -type f -name '*.log' -exec gzip '{}' +

Matriz de compatibilidade rápida

• Bash (moderno): suporta *, ?, [..], brace expansion; extglob e globstar via shopt.
• zsh: funcionalidades avançadas de globbing nativas; muitas opções já ativas.
• ksh: influência histórica; muitas construções similares, mas variar por versão.

Resumo

Curingas são ferramentas essenciais para trabalhar no shell. Comece pelos padrões simples (* e ?), aprenda intervalos com [..], e só depois passe para extglob e globstar quando precisar de correspondências mais finas. Sempre teste padrões antes de usar comandos destrutivos e documente as opções de shell necessárias para scripts.

Principais cuidados: ficheiros que começam com ponto, ficheiros com espaços, e limites do sistema (ARG_MAX). Para conjuntos muito grandes, prefira find/xargs. Para segurança, use echo, arrays com aspas e – para terminar opções.

Principais recursos citados para consulta adicional: man bash, man zsh, e a página info de cada shell.

Fim.