Fundamentos de scripts de shell

Um script de shell salva uma sequência de comandos em um arquivo de texto simples. O Bash lê os comandos em ordem, assim como lê os comandos que você digita em um prompt. Um script pode repetir uma tarefa sem que alguém digite cada etapa e oferece um único lugar para corrigir ou melhorar essa tarefa.

Coloque o interpretador na primeira linha

O shebang informa ao Linux qual programa deve ler um script executável. Comece um script Bash com #!/bin/bash. #! deve ser os dois primeiros caracteres do arquivo: sem espaços ou linha em branco antes deles. Bash significa Bourne Again Shell. Ele é amplamente usado como shell interativo no Linux e também lê arquivos de script.

Um interpretador é um programa que lê e executa outra linguagem. O mesmo mecanismo permite que #!/usr/bin/python3 selecione o Python ou que #!/usr/bin/awk -f selecione o awk. O restante de um script Bash deve conter comandos de shell que o Bash entenda.

Crie backup-notes.sh em um editor de texto simples, como nano ou vi:

#!/bin/bash
# Keep a copy of the notes and show the backup folder.
mkdir -p ~/backup
cp ~/notes.txt ~/backup/
ls -l ~/backup

O Bash primeiro cria o diretório de destino, depois copia as anotações e, em seguida, lista o destino. mkdir -p também é bem-sucedido quando o diretório já existe, portanto uma execução posterior pode reutilizá-lo. O arquivo de origem ~/notes.txt deve existir para que a cópia funcione. Salvar os comandos não cria esse arquivo de origem.

Torne o arquivo legível para as pessoas

A segunda linha é um comentário. Fora de texto entre aspas, # inicia um comentário no começo de uma palavra; o Bash ignora o restante dessa linha. Escreva comentários sobre a finalidade de uma etapa, como o motivo para manter uma cópia de segurança. Linhas em branco e indentação facilitam a identificação de grupos de comandos. Mantenha a indentação consistente ao adicionar condições e laços.

A terminação .sh ajuda o leitor a reconhecer um script de shell. O Linux não exige essa terminação, e adicioná-la não seleciona o Bash nem concede permissão de execução. Um arquivo chamado backup-notes pode executar os mesmos comandos.

Escolha o shell adequado à linguagem

No Debian e no Ubuntu, /bin/sh normalmente seleciona o dash. Recursos do Bash, como [[ ... ]], falham nele. Um script Bash precisa de um interpretador Bash, mesmo que comandos simples funcionem em ambos os shells. Chamar um arquivo de something.sh não corrige um shebang incompatível.

Reconheça um problema de terminador de linha

Editores do Windows podem salvar um retorno de carro antes de cada caractere de nova linha. No Linux, esse caractere invisível pode se tornar parte do caminho no shebang. Um erro como /bin/bash^M: bad interpreter: No such file or directory aponta para esse problema, mesmo que /bin/bash exista.

Converta o arquivo para terminadores de linha do Unix com dos2unix backup-notes.sh e, depois, salve os próximos scripts com terminadores de linha do Unix no editor. Os comandos do arquivo podem estar corretos enquanto o caractere extra impede o Linux de iniciar seu interpretador.

Um script pode ser lido diretamente pelo Bash ou iniciado como um programa. Essas formas diferem nas permissões necessárias e em como o interpretador é escolhido. O caminho digitado também determina se o shell busca um comando ou usa um arquivo específico.

Duas maneiras de iniciar o mesmo arquivo

bash backup-notes.sh
chmod u+x backup-notes.sh
./backup-notes.sh

O primeiro comando inicia o Bash e pede que ele leia o arquivo. O script precisa de permissão de leitura; seu próprio bit de execução não é necessário. O Bash trata o shebang como comentário porque o interpretador já foi escolhido.

O segundo comando adiciona permissão de execução para o proprietário do arquivo. Em uma sequência de permissões como -rwxr--r--, o x do proprietário significa que o arquivo é executável. O terceiro comando executa o arquivo como um programa e usa seu shebang. chmod +x também é comum; sem uma classe de permissões indicada, a umask limita quais classes recebem permissão de execução. chmod u+x direciona a alteração explicitamente ao proprietário.

Se ./backup-notes.sh informar “Permission denied”, verifique a permissão de execução e o acesso ao caminho. Se bash backup-notes.sh funcionar, isso não comprova que a execução direta tenha as permissões necessárias.

Entenda a busca de comandos

./ significa o diretório atual. Quando um comando contém uma barra, o Bash segue esse caminho. Quando você digita um nome sem barra, o Bash busca nos diretórios do PATH. O diretório atual normalmente está ausente dessa lista, portanto estar dentro do diretório de um script não basta para executá-lo apenas pelo nome.

echo "$PATH"
command -v backup-notes.sh
type backup-notes.sh

PATH é uma lista separada por dois-pontos, como /home/sam/.local/bin:/usr/local/bin:/usr/bin:/bin. O primeiro executável correspondente prevalece. Os dois últimos comandos ajudam a identificar o que será executado para um nome, incluindo uma cópia mais antiga em outro lugar do PATH.

Para disponibilizar um script pessoal pelo nome, coloque-o em um diretório do seu PATH. Muitas distribuições adicionam ~/bin ou ~/.local/bin no login quando esse diretório existe; confira seu PATH. /usr/local/bin é um local comum para scripts compartilhados entre usuários e exige direitos de administrador para gravação.

Escolha um shell filho ou o shell atual

Executar ./settings.sh ou bash settings.sh inicia um processo Bash filho. Suas variáveis e mudanças de diretório pertencem a esse processo filho. Um script que contém cd /var/log não muda o diretório do terminal que o iniciou. Quando ele termina, você ainda está no diretório original do terminal.

A execução no shell atual (sourcing) lê comandos no shell atual:

source ./settings.sh
# Equivalent short form:
. ./settings.sh

Use essa forma para um arquivo de configuração destinado a alterar sua sessão. Ela exige permissão de leitura, não de execução, e um shebang não inicia um interpretador separado. Portanto, executar um arquivo de configuração Bash no shell atual pressupõe que esse shell entenda a sintaxe do Bash.

Leia o resultado de uma execução

Imediatamente após o término de um script, echo $? mostra seu código de saída. A menos que o script use exit com um código escolhido, seu código vem do último comando. Assim, uma listagem final bem-sucedida pode ocultar uma falha anterior na cópia; as verificações de erro apresentadas mais adiante permitirão que o script informe o resultado real da tarefa.

Uma variável dá um nome a um valor para que o mesmo script possa reutilizá-lo. Variáveis do Bash normalmente armazenam texto, mesmo quando esse texto parece um número. Você atribui o valor uma vez e expande o nome sempre que um comando precisar dele.

Faça atribuições sem espaços

city=Lisbon
greeting="Good morning"
echo "$greeting from $city"

A saída é “Good morning from Lisbon.” Não há espaços ao redor do = de atribuição. Em city = Lisbon, o Bash trata city como comando e as outras palavras como argumentos. As aspas ao redor de "Good morning" mantêm as duas palavras em um único valor.

Use letras, dígitos e sublinhados nos nomes de variáveis, começando com uma letra ou um sublinhado. Os nomes diferenciam maiúsculas de minúsculas: file, File e FILE são diferentes. Escolha nomes em minúsculas, como backup_dir, para valores pertencentes ao seu script. Isso ajuda a evitar a substituição de variáveis de ambiente como PATH ou HOME. Definir PATH=/data altera a localização de comandos e pode fazer com que comandos comuns deixem de ser encontrados.

Marque onde um nome termina

Um cifrão introduz uma expansão. As chaves mostram o limite quando há mais texto imediatamente em seguida:

file=report
echo "${file}_old"

Isso imprime “report_old.” Com "$file_old", o Bash procura uma variável chamada file_old, não file seguida de _old. Sem set -u, um nome não definido é expandido para texto vazio. Assim, um erro de digitação pode produzir um caminho ou uma mensagem vazia sem erro imediato.

Um valor como count=5 armazena o texto “5.” Adicionar texto ao lado de uma expansão não faz um cálculo: echo "$count+1" imprime “5+1.” A expansão aritmética dá aos números um papel diferente quando cálculos são necessários.

Leia uma linha de entrada

read -r -p "Your name: " name
echo "Hello, $name"

read armazena a linha digitada em name. -p fornece o prompt e -r preserva as barras invertidas. Com a entrada “Lee Kim”, a saudação é “Hello, Lee Kim.” Um script executado sem uma pessoa presente precisa receber suas entradas de argumentos, arquivos ou valores padrão; um prompt não pode fornecer um valor ausente de maneira confiável.

Exporte valores para programas filhos

Uma variável comum do shell pertence ao shell no qual é definida. A exportação marca a variável para inclusão no ambiente copiado aos programas que esse shell inicia:

export BACKUP_DIR=/mnt/usb
bash backup-notes.sh

O Bash filho agora pode ler BACKUP_DIR. Se esse processo filho atribuir outro valor, o processo pai mantém seu próprio valor. A herança do ambiente passa do processo pai para o filho; ela não envia alterações posteriores de volta.

env ou printenv exibe variáveis de ambiente. unset name remove a variável chamada name; ele não atribui uma string vazia. Na expansão normal, ambos podem parecer vazios, mas uma verificação de variável não definida pode distinguir uma variável ausente de uma definida.

O Bash lê um comando antes de o programa receber seus argumentos. Espaços separam palavras, e caracteres como *, ?, $, ;, &, |, < e > têm funções especiais. A proteção com aspas ou escape controla quais dessas funções permanecem ativas.

Escolha o que deve ser expandido

Com HOME=/home/sam, compare:

echo 'Home: $HOME *'
echo "Home: \$HOME *"

O primeiro imprime “Home: $HOME *”. O segundo imprime “Home: /home/sam *”. O asterisco permanece literal em ambos, mas apenas as aspas duplas permitem que a variável seja expandida. Uma aspa simples não pode ser colocada diretamente dentro de uma string entre aspas simples.

Dentro de aspas duplas, barras invertidas podem proteger um cifrão, uma crase, uma aspa dupla ou uma barra invertida. Por exemplo, echo "Price: \$5" imprime “Price: $5”. Fora de aspas, echo 5 \* 3 imprime “5 * 3”, e touch my\ file.txt cria um arquivo com um espaço no nome.

Acompanhe um valor sem aspas pelo Bash

file="my report.txt"
cp $file backup/

Primeiro, o Bash expande a variável. Depois, a separação de palavras divide seu valor em espaços, tabulações e caracteres de nova linha. O comando recebe my, report.txt e backup/ como argumentos separados. Ele tenta copiar dois arquivos de origem em vez do único arquivo pretendido.

Se uma palavra resultante contiver caracteres curinga, a expansão de nomes de arquivo a substitui pelos nomes correspondentes. Um valor armazenado de *.txt pode se tornar vários argumentos de arquivo quando expandido sem aspas. Essas etapas adicionais ocorrem antes de cp iniciar; o programa não consegue recuperar o agrupamento pretendido.

cp "$file" backup/

Agora o valor expandido permanece como um argumento, “my report.txt”. Os próprios caracteres de aspas são removidos pelo Bash; eles são instruções de interpretação, não parte do caminho passado a cp. Coloque aspas duplas ao redor de expansões de variáveis e substituições de comando sempre que seu valor completo deva permanecer junto.

Mantenha presente um valor vazio

As aspas também importam quando um valor está vazio. Em [ $answer = yes ], um answer vazio desaparece, deixando um teste inválido. [ "$answer" = yes ] passa uma string vazia como um argumento, portanto o teste é válido e falso.

A mesma regra de agrupamento se aplica a palavras literais. mkdir new folder cria dois diretórios, enquanto mkdir "new folder" cria um. Colocar um caminho inteiro entre aspas é útil tanto quando seu espaço foi digitado diretamente quanto quando veio de uma variável.

Combine texto literal e expandido

Partes adjacentes entre aspas, sem espaço entre elas, formam uma palavra. Com price=8, echo 'Price: $'"$price" imprime “Price: $8”. A parte fixa está entre aspas simples e a parte variável está entre aspas duplas. Um padrão de busca também pode ser mantido fixo: grep 'cost: \$[0-9]' prices.txt passa seu padrão sem expansão pelo shell, deixando que grep o interprete.

Comandos muitas vezes produzem um valor necessário em outra etapa. O Bash pode capturar essa saída, colocá-la dentro de um texto ou usá-la em um cálculo. A substituição de comando e a expansão aritmética têm pontuação semelhante, mas cumprem funções diferentes.

Capture a saída padrão

today=$(date +%F)
cp notes.txt "notes-${today}.txt"

$(...) executa um comando e substitui a expressão por sua saída padrão. Em 2026-10-22, today contém “2026-10-22” e a cópia recebe o nome notes-2026-10-22.txt. Uma data na ordem ano-mês-dia mantém os nomes de arquivo em ordem de data quando são ordenados pelo nome. Você também pode colocar a substituição diretamente no nome: "notes-$(date +%F).txt".

Os caracteres de nova linha no final são removidos da saída capturada. A forma mais antiga com crases também captura a saída, mas $(...) é mais fácil de ler e aninhar. Coloque entre aspas uma substituição usada como argumento de comando, como "$(date +%F)", para manter seu resultado junto.

A substituição de comando captura apenas a saída padrão. Erros enviados à saída de erro padrão ainda vão para seu destino habitual. result=$(some_command 2>&1) combina ambos os fluxos dentro da captura quando isso é o que o script precisa. Misturar erros a um valor destinado a conter um número faria a aritmética posterior falhar.

Capture uma contagem sem o nome do arquivo

lines=$(wc -l < access.log)
echo "Lines: $lines"

Se o arquivo contiver 342 caracteres de nova linha, wc fornece a contagem 342. Redirecionar o arquivo para wc faz sua saída conter apenas a contagem; wc -l access.log também imprime o nome do arquivo. Um resultado com aparência numérica pode então ser reutilizado, desde que o comando tenha sido bem-sucedido.

Calcule com números inteiros

$(( ... )) realiza a expansão aritmética:

echo "$(( 17 / 5 ))"
echo "$(( 17 % 5 ))"

Os resultados são 3 e 2. A divisão inteira descarta o resto; % o retorna. Adição, subtração e multiplicação usam +, - e *. Nomes de variáveis podem aparecer sem cifrão dentro da expressão: total=$(( price * qty )).

Com a=5, echo "$a+3" imprime “5+3” como texto. echo "$(( a + 3 ))" calcula e imprime 8. Os parênteses adicionais selecionam a aritmética; $(a + 3) tentaria executar um comando chamado a.

Um contador começa com um valor como count=0 e é atualizado com count=$(( count + 1 )). O Bash também oferece (( count++ )); esse é um comando aritmético com seu próprio código de saída, o que importa em scripts que usam opções de erro.

Mantenha a precisão necessária

A aritmética do Bash usa números inteiros. 7 / 2 resulta em 3, e um valor decimal como 2.5 causa um erro de sintaxe aritmética. Uma ferramenta separada pode calcular com decimais:

echo "scale=2; 7 / 2" | bc

Isso produz 3.50. Na aritmética inteira, multiplique antes de dividir quando o produto preservar uma fração de que você ainda precisa. Para 45 de 60, $(( 45 * 100 / 60 )) resulta em 75. Dividir primeiro resulta em zero para 45 / 60, portanto $(( 45 / 60 * 100 )) permanece zero; a fração perdida não pode ser recuperada pela multiplicação posterior.

Um comando informa seu resultado de duas maneiras: ele pode imprimir texto e retorna um código de saída. Programas usam esse código para decidir o que acontece em seguida. Um script pode imprimir uma mensagem tranquilizadora e ainda assim ter falhado, ou não imprimir nada e ser bem-sucedido.

Leia um código antes que ele mude

Um código de saída é um número inteiro de 0 a 255. Zero significa sucesso. Um valor diferente de zero informa uma falha ou outro resultado documentado. grep, por exemplo, usa 0 para uma correspondência, 1 para nenhuma correspondência e 2 para um erro. Uma busca sem correspondência pode ser um resultado normal para sua tarefa, embora seu código seja diferente de zero.

$? armazena o código do comando mais recente:

grep -q root /etc/passwd
status=$?
echo "Search status: $status"

A atribuição salva o resultado antes que outro comando o substitua. Em ls /missing; echo $?; echo $?, o ls do GNU retorna 2 para o caminho inacessível fornecido na linha de comando. O primeiro echo imprime 2 e depois é bem-sucedido. O segundo imprime 0, o código desse echo, não da listagem original.

Termine com um resultado útil

exit 1 encerra um script imediatamente e informa 1 a quem o chamou. exit 0 informa sucesso. Um exit sem número usa o código do comando anterior; chegar ao fim normalmente usa o código do último comando. Escolha códigos entre 0 e 255: exit 256 dá a volta para 0 e informaria sucesso incorretamente.

Alguns códigos vêm do próprio Bash:

Ctrl+C envia o sinal 2, portanto um comando encerrado dessa forma costuma informar 130. Programas comuns também documentam seus próprios códigos; 1 e 2 não têm um significado universal para todas as ferramentas.

Encadeie comandos dependentes

mkdir -p ~/backup && cp notes.txt ~/backup/
cd /data/reports || exit 1

&& executa o próximo comando apenas após um sucesso. Aqui, a cópia depende da criação ou localização do diretório de cópia de segurança. || executa o próximo comando apenas após uma falha. Aqui, uma mudança de diretório malsucedida interrompe o script antes que comandos posteriores usem o diretório de trabalho errado.

true retorna 0; false retorna 1. Um ! no início inverte o sucesso ou a falha de um comando. ! grep -q ERROR app.log é bem-sucedido quando a busca não encontra uma linha correspondente, embora também seja bem-sucedido se grep falhar com um erro; use verificações explícitas do código de saída quando for necessário distinguir esses resultados.

Verifique um encadeamento inteiro

grep ERROR missing.log | wc -l

Por padrão, um encadeamento tem o código de saída de seu comando final. grep falha devido ao arquivo ausente, mas wc lê um fluxo vazio, imprime 0 e é bem-sucedido. Portanto, o código do encadeamento é 0.

set -o pipefail faz um encadeamento falhar quando qualquer um de seus comandos falha. Ele informa o código diferente de zero mais à direita, ou 0 se todos os comandos forem bem-sucedidos. Isso torna os erros anteriores no encadeamento visíveis para if, &&, || e quem chamou o script. Um agendador pode então distinguir um relatório bem-sucedido de um que nunca leu sua entrada.

O Bash normalmente continua após a falha de um comando. Se o próximo comando depender desse trabalho, continuar pode transformar uma pequena falha em um problema maior. Verifique explicitamente as etapas dependentes e use a verificação de sintaxe e o rastreamento para descobrir por que uma execução se comporta de forma diferente do planejado.

Interrompa a execução antes que uma falha se propague

cd /backups || exit 1

Agora, os comandos seguintes só podem ser executados após uma mudança de diretório bem-sucedida. Isso importa antes de operações com arquivos: se uma mudança de diretório falhar e o script continuar, os caminhos relativos ainda se referirão ao diretório antigo. Verifique o destino antes de executar comandos que alteram ou excluem arquivos.

Uma mensagem de erro e um código de falha atendem a leitores diferentes:

echo "Error: $file not found" >&2
exit 1

A mensagem vai para a saída de erro padrão, deixando a saída padrão disponível para dados. Com ./report.sh > report.txt, a mensagem permanece visível no terminal enquanto a saída normal entra no arquivo. O código diferente de zero permite que outro programa detecte o erro sem ler a frase.

Verifique a sintaxe e depois rastreie a execução

A falta de fi, done ou de uma aspa de fechamento é um problema de sintaxe. bash -n pode localizá-lo, muitas vezes por meio de uma mensagem “unexpected end of file”. Um caminho de arquivo com sintaxe válida, mas digitado incorretamente, precisa de uma verificação durante a execução.

O rastreamento precede os comandos com +. Uma linha como cp "$src" "$dest" revela os caminhos reais recebidos. set -x e set +x ativam e desativam o rastreamento em torno de uma seção.

Entenda as opções de erro

set -euo pipefail combina três controles:

• -e encerra a execução após uma falha de comando não tratada.
• -u informa uma variável não definida como erro.
• pipefail faz com que falhas de comandos afetem o código de saída do encadeamento.

-e permite falhas esperadas em condições if, while e until, comandos negados e comandos que não são os últimos em listas && ou ||. Sem pipefail, uma falha antes do comando final de um encadeamento não provoca a saída. Verificações explícitas continuam úteis porque indicam o que o script deve fazer quando uma etapa específica falha.

Um comando aritmético também informa verdadeiro ou falso. (( count++ )) retorna o código 1 quando o valor antigo é 0, portanto um uso não tratado sob -e pode interromper o script mesmo que o incremento tenha ocorrido. A atribuição count=$(( count + 1 )) evita esse código de saída do comando aritmético.

-u detecta um erro de digitação como $filname quando apenas filename foi definida. Ele não rejeita uma variável que existe, mas está vazia. ${dir:?not set} verifica se dir está ausente ou vazia nessa expansão. Um resultado esperado sem correspondência pode ser tratado com um teste; command || true suprime todas as falhas desse comando, portanto use-o apenas quando todas elas forem aceitáveis.

Leia as mensagens e faça a limpeza

“Command not found” aponta para um problema no nome, no programa instalado ou no PATH. “Permission denied” aponta para execução ou acesso a arquivo. “Unary operator expected” normalmente decorre de um valor vazio sem aspas em [ ]; “integer expression expected” significa que um teste numérico recebeu texto.

Um trap em EXIT define uma ação de limpeza, como trap 'rm -f "$tmpfile"' EXIT, depois que tmpfile recebe um valor. O comando entre aspas é executado quando o Bash sai, inclusive após um exit explícito ou uma saída por erro sob -e. O ShellCheck também pode inspecionar scripts antes da execução em busca de erros comuns de proteção com aspas e de lógica.

Uma condição no Bash é um comando cujo código de saída significa verdadeiro ou falso. Testes permitem fazer perguntas sobre caminhos, textos e números. Escolha um operador adequado ao tipo de valor; os mesmos caracteres impressos podem ter significados diferentes como texto e como número.

Separe os elementos do teste

test -f notes.txt e [ -f notes.txt ] verificam se um caminho se refere a um arquivo comum existente. [ é um comando, e seu último argumento deve ser ]. Espaços separam seus argumentos:

[ -f "$file" ]

Sem o espaço após [, o Bash pode procurar um comando chamado [-f. Em [ "$a"="$b" ], a falta de espaços ao redor de = forma uma palavra não vazia, cujo teste é verdadeiro mesmo que os valores sejam diferentes. Operadores devem ser argumentos separados.

Escolha um teste de arquivo

Para um diretório chamado logs, -e e -d são bem-sucedidos, enquanto -f falha. Testes de arquivo normalmente seguem um link simbólico até seu destino; -L verifica o próprio link. Portanto, um link quebrado pode satisfazer -L e falhar em -e.

Compare textos ou números inteiros

Testes de strings usam = e != para igualdade e desigualdade. -z verifica se o comprimento é zero e -n se o comprimento é diferente de zero. [ "$answer" = yes ] corresponde exatamente a “yes”; “Yes” e “yes ” são textos diferentes. Aspas duplas mantêm um valor vazio no teste.

Comparações de números inteiros usam -eq, -ne, -lt, -le, -gt e -ge: igual, diferente, menor que, menor ou igual, maior que e maior ou igual. [ "$count" -gt 100 ] verifica se o número é maior que 100.

[ 07 -eq 7 ]
[ 07 = 7 ]

A comparação numérica é bem-sucedida porque os valores são iguais. A comparação de strings falha porque um dos textos começa com um zero a mais.

Não use > isolado para um teste numérico dentro de [ ]. Em [ 10 > 9 ], o Bash redireciona a saída para um arquivo chamado 9 e testa a palavra não vazia restante. Em [[ 10 < 9 ]] no Bash, o operador compara strings, portanto o caractere inicial 1 vem antes de 9. Use -lt ou -gt para comparações numéricas, ou aritmética do Bash, como (( count > 100 )).

Combine condições

[ ! -d "$dir" ] é bem-sucedido quando o caminho não é um diretório existente; ele pode ser um arquivo comum ou estar ausente. [ -f "$f" ] && [ -r "$f" ] é bem-sucedido apenas quando ambos os testes são bem-sucedidos. Testes separados unidos por || são bem-sucedidos quando pelo menos um é bem-sucedido.

O Bash também tem a palavra-chave condicional [[ ... ]]. Ela impede a separação em palavras das expansões de variáveis e permite && e || em seu interior. Um padrão sem aspas à direita de == faz uma correspondência de padrões: [[ $file == *.log ]] corresponde a “app.log”. Colocar esse padrão entre aspas o tornaria literal. Essa sintaxe exige o Bash; dash não a implementa.

Condições se tornam úteis quando selecionam ações. Um bloco if escolhe um ramo com base nos resultados de comandos. Um bloco case seleciona um ramo comparando um valor com padrões. Ambos tornam visíveis as ações disponíveis no script.

Deixe um comando escolher um ramo

if grep -q ERROR app.log; then
  echo "Errors found"
else
  echo "No successful match"
fi

if executa o comando e entra no primeiro ramo quando ele retorna 0. Caso contrário, entra em else. A própria busca é a condição; não é necessário executá-la, imprimir algo e depois examinar $?. Um erro de grep também retorna um valor diferente de zero, portanto este exemplo descreve o ramo else como ausência de correspondência bem-sucedida, não como prova de que o arquivo não contém erros.

then deve iniciar um novo comando: coloque-o na linha seguinte ou após um ponto e vírgula. fi fecha o bloco. A falta de fi muitas vezes produz um erro de sintaxe de fim de arquivo porque o Bash ainda está esperando o fechamento do bloco.

Ordene condições sobrepostas

elif adiciona um teste executado apenas quando os testes anteriores falharam. Para uma porcentagem inteira de uso de disco:

if [ "$usage" -ge 90 ]; then
  echo "CRITICAL: disk ${usage}% full"
elif [ "$usage" -ge 75 ]; then
  echo "WARNING: disk ${usage}% full"
else
  echo "OK: disk ${usage}% full"
fi

Com usage=82, o primeiro teste falha e o segundo é bem-sucedido, produzindo “WARNING: disk 82% full”. Com 95, o primeiro ramo é executado e o ramo de aviso é ignorado. Se o teste de 75 viesse primeiro, 95 corresponderia a ele e nunca chegaria ao teste crítico. Organize intervalos sobrepostos para que a condição mais restritiva seja verificada primeiro.

Apenas o primeiro ramo bem-sucedido é executado. else não precisa de condição e trata o que resta. Tanto elif quanto else podem ser omitidos quando a tarefa não precisa deles.

Compare um valor com case

case "$1" in
  start) echo "Starting" ;;
  stop) echo "Stopping" ;;
  y|Y|yes) echo "Confirmed" ;;
  *) echo "Usage: $0 start|stop|y|Y|yes" >&2; exit 2 ;;
esac

Cada padrão termina com ), cada ramo termina com ;; e esac fecha o bloco. O | dentro de um padrão fornece alternativas. O * final corresponde a qualquer valor e fica por último porque abrange todos eles.

case usa padrões de nomes de arquivo, não expressões regulares. *.jpg corresponde a um valor terminado em .jpg. [0-9]* corresponde a um valor cujo primeiro caractere é um dígito; o * pode corresponder a qualquer texto seguinte, portanto também corresponde a “7draft”. Isso não prova que um valor inteiro contenha apenas dígitos.

Escolha a estrutura adequada

Use case quando uma entrada, como um subcomando ou uma resposta, tiver várias formas identificadas. Use if quando as condições examinarem coisas diferentes, como a existência de um arquivo e se uma contagem ultrapassa um limite. Uma correspondência de padrão verifica os caracteres de um valor; um teste de arquivo verifica o caminho no disco. Um nome terminado em .log pode corresponder a um padrão mesmo quando esse arquivo não existe.

Um laço for fornece ao mesmo corpo de comandos um novo valor a cada passagem. A lista pode conter palavras literais, nomes de arquivo correspondentes, um intervalo de números ou os argumentos do script. O Bash atribui um item da lista à variável do laço antes de executar o corpo.

Percorra uma lista fixa

for host in web1 web2 db1; do
  echo "Checking $host"
done

A primeira passagem tem host=web1, a segunda host=web2 e a terceira host=db1. O laço imprime três linhas. do abre o corpo e done o fecha. A variável permanece disponível após o laço, contendo seu último valor atribuído.

Um laço também pode acumular um resultado:

total=0
for n in 4 8 15; do
  total=$(( total + n ))
done
echo "$total"

O total armazenado muda de 0 para 4, depois 12 e depois 27. Inicialize o total antes do laço para que a primeira soma tenha um valor inicial definido.

Percorra arquivos correspondentes

for f in *.log; do
  [ -f "$f" ] || continue
  gzip -- "$f"
done

O Bash expande o padrão para os nomes correspondentes antes de executar o corpo do laço. Cada nome de arquivo correspondente permanece como um item da lista, mesmo que contenha espaços. Colocar "$f" entre aspas dentro do corpo mantém esse item junto quando ele é passado a gzip. Aqui, o teste de arquivo comum também ignora diretórios com nomes terminados em .log.

Com as configurações padrão de expansão de nomes de arquivo do Bash, um *.log sem correspondência permanece literal. Um laço sem verificação seria executado uma vez com os caracteres *.log e o comando falharia. [ -e "$f" ] || continue ignora caminhos inexistentes; use -f quando quiser apenas arquivos comuns.

Não construa um laço de nomes de arquivo a partir de $(ls). Sua saída é texto, portanto a separação de palavras pode transformar “my report.txt” em dois itens da lista. Um padrão já produz os nomes de arquivo com seus limites intactos.

Crie um novo nome a partir de cada nome antigo

for f in *.jpeg; do
  [ -f "$f" ] || continue
  mv -- "$f" "${f%.jpeg}.jpg"
done

${f%.jpeg} remove a terminação .jpeg do valor. Para “beach day.jpeg”, o destino se torna “beach day.jpg”. Os dois argumentos entre aspas mantêm ambos os caminhos intactos. -- informa a mv que os argumentos seguintes são nomes, mesmo que um comece com -. Use uma pasta de destino sem nomes conflitantes ao experimentar o exemplo, pois mv pode substituir um destino existente.

Conte em um intervalo

for i in {1..5} fornece os números de 1 a 5. O Bash expande as chaves antes de expandir variáveis, portanto {1..$n} não produz um intervalo de comprimento variável. Para um limite armazenado, use a forma aritmética:

for (( i = 1; i <= n; i++ )); do
  echo "$i"
done

A primeira expressão inicializa o contador, a do meio o testa antes de cada passagem e a última o atualiza. for i in $(seq 1 "$n") também produz uma lista de números para um limite inteiro positivo adequado. A substituição intencionalmente sem aspas fornece números separados.

Para argumentos, for arg in "$@" fornece um item por argumento original. A forma mais curta for arg; do significa a mesma coisa, incluindo a preservação de espaços dentro de cada argumento.

Algumas repetições terminam quando uma condição muda, não quando uma lista acaba. while e until testam a condição antes de cada passagem. O corpo de while é executado enquanto sua condição é bem-sucedida; o corpo de until é executado enquanto sua condição falha. Qualquer um dos laços pode ser executado zero vezes.

Atualize aquilo de que a condição depende

i=1
while [ "$i" -le 3 ]; do
  echo "Attempt $i"
  i=$(( i + 1 ))
done

A condição primeiro vê 1, depois 2 e depois 3. O corpo imprime esses três números de tentativa e aumenta o contador a cada vez. Após a atualização para 4, o teste seguinte falha e o laço termina. Se a atualização estivesse ausente, i permaneceria em 1 e o laço continuaria executando. Ctrl+C interrompe um laço em primeiro plano que esteja em execução.

Para aguardar um arquivo:

until [ -f /tmp/export.done ]; do
  sleep 5
done

Se o arquivo já existir, o corpo do laço nunca será executado. Caso contrário, sleep 5 pausa por cinco segundos antes da próxima verificação. Uma pausa impede que o laço teste continuamente e desperdice tempo do processador.

Leia registros como linhas

while IFS= read -r line; do
  echo "Host: $line"
done < hosts.txt

read fornece uma linha a cada passagem e retorna um código de falha no fim do arquivo. IFS= preserva espaços no início e no fim da linha; -r mantém barras invertidas. O redirecionamento de entrada após done fornece dados a todo o laço, não apenas ao comando final.

Uma linha como “web1 production” permanece como um valor. for line in $(cat hosts.txt) separaria em espaços, tabulações e caracteres de nova linha, tratando essas duas palavras como iterações separadas. Essa forma não consegue preservar registros arbitrários baseados em linhas.

Mantenha as alterações após o laço

Um pipe para um laço, como cat hosts.txt | while read -r line; do ...; done, normalmente executa o laço em um processo filho no Bash. Um contador alterado ali é perdido para o processo pai quando o filho termina. Redirecione o arquivo para o laço quando comandos posteriores precisarem de seus valores acumulados:

count=0
while IFS= read -r line; do
  count=$(( count + 1 ))
done < hosts.txt
echo "$count"

Isso processa linhas terminadas por um caractere de nova linha e mantém a contagem atualizada no shell atual. Nenhum encadeamento cria um processo filho para o laço.

Trate o registro final e saídas antecipadas

Um arquivo pode terminar com texto, mas sem um caractere final de nova linha. read armazena esse último texto, mas informa falha, portanto um while read simples não entra em seu corpo para esse registro. Adicione um segundo teste para aceitar o texto não vazio armazenado:

while IFS= read -r line || [ -n "$line" ]; do
  echo "Host: $line"
done < hosts.txt

break sai do laço imediatamente. continue pula os comandos restantes na passagem atual e retorna à próxima verificação da condição. Portanto, um laço while true precisa de um break, um exit ou um sinal para terminar; ele pode servir a um menu que é encerrado quando a entrada é “q”. Coloque uma atualização antes de qualquer continue que a ignoraria em um laço com contador, ou essa passagem poderá se repetir indefinidamente.

Argumentos transformam um script com entrada fixa em um comando reutilizável. O Bash coloca as palavras após o nome do script em parâmetros posicionais. Seus limites são definidos pelo shell que faz a chamada, portanto as aspas importam tanto na chamada do script quanto no uso desses valores.

Identifique os parâmetros

./backup.sh /home/sam/docs /mnt/usb

Dentro do script, $0 é ./backup.sh, $1 é /home/sam/docs e $2 é /mnt/usb. $# é 2, a quantidade de argumentos. O script pode usar cp -r "$1" "$2" para copiar a pasta de origem para o destino sem fixar nenhum dos caminhos no código.

$0 descreve o nome usado para iniciar o script; ele não é contado em $#. Com ./greet.sh Ana "Lee Kim", o primeiro argumento é “Ana” e o segundo é “Lee Kim”. Sem as aspas ao redor do segundo nome, o script receberia três argumentos.

Use chaves após o nono argumento

$1 a $9 nomeiam os primeiros nove parâmetros posicionais. O décimo precisa de ${10}, e as posições seguintes usam a mesma forma. $10 significa a expansão de $1 seguida do caractere literal 0. Se o primeiro argumento for “Ana”, $10 se torna “Ana0” mesmo quando há um décimo argumento.

Um parâmetro omitido é expandido para texto vazio nas configurações normais. Com dois argumentos, $3 está ausente; sob set -u, expandi-lo causa um erro de variável não definida. Verifique a quantidade antes de ler posições obrigatórias ou use uma expansão que forneça um valor padrão.

Preserve todos os limites dos argumentos

Suponha que um script receba "a b" e c. Compare:

"$@" é a escolha usual para repassar argumentos:

for arg in "$@"; do
  echo "Argument: $arg"
done

O laço é executado duas vezes para essa chamada, uma vez por argumento original. Sem argumentos, ele é executado zero vezes. Colocar "$@" entre aspas duplas tem um significado especial: cada parâmetro posicional permanece como uma palavra separada, portanto as aspas não unem toda a lista em uma palavra.

"$*" une valores usando o primeiro caractere de IFS, que normalmente é um espaço. Isso pode ser útil para uma única string de exibição, mas perde os limites individuais de que um comando posterior pode precisar.

Processe parâmetros com shift

shift remove o primeiro parâmetro posicional, desloca os seguintes e reduz $#. Na chamada de cópia de segurança, um shift faz $1 se tornar /mnt/usb e a contagem se tornar 1. shift 2 remove os dois primeiros parâmetros de uma vez.

Isso permite criar um laço que examina $1, o trata e depois executa shift antes da próxima passagem. Verifique se restam argumentos com [ "$#" -gt 0 ]; caso contrário, o script pode ler um valor ausente ou tentar deslocar além dos argumentos disponíveis. O deslocamento não altera $0 e não pode alterar a lista de argumentos do shell pai que iniciou o script.

Um script deve confirmar que sua entrada pode ser usada antes de começar o trabalho. Verifique a quantidade de argumentos e depois seu significado. Entradas opcionais podem ter valores padrão; entradas obrigatórias ausentes precisam de uma mensagem clara e de um código de saída diferente de zero.

Explique a chamada esperada

if [ "$#" -ne 2 ]; then
  echo "Usage: $0 SOURCE DEST" >&2
  exit 2
fi

Isso verifica a quantidade antes de expandir $1 ou $2, portanto também funciona sob set -u. A mensagem de uso vai para a saída de erro padrão. Maiúsculas nomeiam valores fornecidos pelo usuário, [DEST] significaria um destino opcional e FILE... significa um ou mais argumentos de arquivo. Uma opção de ajuda como -h normalmente imprime as instruções de uso e sai com 0 porque pedir ajuda é um uso bem-sucedido.

A quantidade de argumentos, por si só, não mostra se uma origem pode ser usada. [ -d "$1" ] verifica se há um diretório existente. Um teste de arquivo comum pode selecionar arquivos, mas a própria operação ainda precisa de uma verificação de resultado: permissões ou outros erros podem impedir uma leitura.

Use um valor padrão ou exija um valor

logdir=${1:-/var/log}
src=${1:?Usage: backup.sh SOURCE [DEST]}

A primeira forma usa /var/log quando o primeiro parâmetro está ausente ou vazio. A segunda interrompe um script não interativo em ambos os casos e imprime sua mensagem na saída de erro padrão. Os dois-pontos fazem parte de ambas as formas. Um valor padrão é usado para essa expansão; ${1:-...} não adiciona um argumento à lista de parâmetros posicionais.

Registre falhas parciais

Um script de contagem de arquivos pode continuar após uma entrada inválida e ainda informar que a tarefa inteira ficou incompleta:

#!/bin/bash
if [ "$#" -eq 0 ]; then
  echo "Usage: $0 FILE..." >&2
  exit 2
fi
status=0
for f in "$@"; do
  if [ -f "$f" ]; then
    if lines=$(wc -l < "$f"); then
      echo "$f: $lines lines"
    else
      echo "$f: could not count lines" >&2
      status=1
    fi
  else
    echo "$f: not a regular file" >&2
    status=1
  fi
done
exit "$status"

Para notes.txt missing.txt, o script imprime a contagem do arquivo legível e informa o arquivo ausente, depois sai com 1. A atribuição é testada diretamente, portanto uma falha de leitura não se transforma em uma contagem vazia bem-sucedida. Um sucesso posterior nunca redefine o indicador de falha armazenado para 0.

Trate opções simples antes dos nomes de arquivo

verbose=0
while [ "$#" -gt 0 ]; do
  case "$1" in
    -v) verbose=1; shift ;;
    -h) echo "Usage: $0 [-v] FILE..."; exit 0 ;;
    --) shift; break ;;
    -*) echo "Unknown option: $1" >&2; exit 2 ;;
    *) break ;;
  esac
done

Cada opção reconhecida é consumida com shift. O primeiro argumento comum encerra a análise de opções; -- também a encerra e é consumido. O "$@" restante contém os nomes de arquivo, incluindo um nome que começa com - após --. O getopts do Bash aceita uma análise mais completa de opções curtas.

Um script sem acompanhamento precisa de todas as entradas obrigatórias em argumentos, valores padrão ou configuração. read pode bloquear a execução enquanto espera um terminal ou falhar imediatamente no fim do arquivo. Substituir um argumento ausente por um prompt deixaria uma tarefa agendada sem uma forma confiável de continuar.

O cron inicia comandos nos horários correspondentes. O crontab de cada usuário armazena seu agendamento, e as tarefas são executadas com a identidade desse usuário. Um script agendado precisa de uma expressão de tempo correta e de um ambiente que forneça seus caminhos, entradas e destino de saída.

Leia os cinco campos

Use crontab -e para editar sua tabela e crontab -l para inspecioná-la. crontab -r exclui toda a tabela sem perguntar; use o editor para remover uma única tarefa.

30 2 * * * /home/sam/bin/backup.sh

Isso executa todos os dias às 02:30. Asteriscos aceitam todos os valores de um campo. 0 9 * * 1-5 seleciona 09:00 nos dias úteis, e 0 0 1 * * seleciona a meia-noite no primeiro dia de cada mês. Os horários usam o fuso horário do sistema, a menos que a configuração do cron especifique outro fuso compatível.

Combine intervalos, listas e passos

Uma vírgula lista valores: 1,15 no campo de dia do mês seleciona o primeiro e o décimo quinto dia. Um hífen indica um intervalo, e / introduz um passo. */15 no campo de minutos seleciona 0, 15, 30 e 45.

*/20 8-10 * * * seleciona três minutos em cada uma de três horas: nove execuções diárias, começando às 08:00 e terminando às 10:40. Os passos recomeçam dentro de seu campo. */45 executa no minuto 0 e no minuto 45 de cada hora; o intervalo até o minuto 0 da hora seguinte é de apenas 15 minutos.

Quando os campos de dia do mês e dia da semana estão ambos restritos, a correspondência de qualquer um deles basta. 0 12 13 * 5 seleciona o meio-dia no dia 13 e nas sextas-feiras, não apenas na sexta-feira 13. Os outros campos ainda precisam corresponder.

Strings especiais substituem os cinco campos: @hourly, @daily, @weekly, @monthly, @yearly e @reboot. @daily significa meia-noite, enquanto @reboot executa uma vez na inicialização.

Forneça caminhos e mantenha a saída

O cron normalmente usa /bin/sh para sua linha de comando, um PATH curto e nenhuma configuração de inicialização de shell interativo. O próprio shebang Bash de um script executável ainda seleciona o Bash. Use caminhos absolutos para o script e seus arquivos ou defina PATH no início do crontab.

30 2 * * * /home/sam/bin/backup.sh >> /home/sam/backup.log 2>&1

A tarefa acrescenta ambos os fluxos de saída ao log. Sem redirecionamento, o cron envia a saída por e-mail quando o correio está configurado, inclusive por meio de MAILTO; caso contrário, a saída pode ser perdida. Um sinal de porcentagem tem uma função especial em um comando do crontab: ele inicia uma nova linha e a entrada subsequente. Use escape em um formato de data ali, como em date +\%F. Um comando de data dentro de um script separado usa %F normalmente.

Distinga agendamentos do sistema e tarefas recuperadas

/etc/crontab e os arquivos em /etc/cron.d/ adicionam um campo de usuário após os cinco campos de tempo. Por exemplo, 30 2 * * * root /usr/local/bin/backup.sh é executado como root. Não adicione esse campo de usuário a um crontab pessoal.

Muitas distribuições também executam arquivos executáveis elegíveis em /etc/cron.daily/, /etc/cron.weekly/ e /etc/cron.monthly/. As regras padrão de nomenclatura de run-parts no Debian ignoram nomes que contêm pontos, portanto use backup-notes, não backup-notes.sh, nesses locais. O cron perde horários que passam enquanto o computador está desligado. O Anacron pode executar tarefas periódicas diárias, semanais ou mensais perdidas após a inicialização.

O systemd separa o trabalho de seu agendamento. Uma unidade de serviço descreve o comando a ser executado. Uma unidade de temporizador descreve quando iniciá-lo. Por padrão, backup.timer ativa backup.service, usando o nome-base compartilhado para conectar o par.

Escreva o serviço e o agendamento de calendário

Coloque estas unidades de sistema em /etc/systemd/system/:

# backup.service
[Unit]
Description=Nightly backup

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

Type=oneshot é adequado para um script que é executado uma vez e termina. Use um caminho de comando absoluto e torne o script executável com um shebang Bash. O temporizador fornece o agendamento:

# backup.timer
[Unit]
Description=Run backup.service daily at 02:30

[Timer]
OnCalendar=*-*-* 02:30:00
Persistent=true

[Install]
WantedBy=timers.target

OnCalendar corresponde a datas e horários. Aqui, a data com caracteres curinga aceita todos os dias. Persistent=true habilita a recuperação de execuções após a inatividade do temporizador: se pelo menos uma execução de calendário foi perdida, ele inicia o serviço uma vez na reativação. Ele não repete cada execução perdida.

Carregue e ative o temporizador

sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer

Recarregue após criar ou alterar arquivos de unidade. enable --now inicia o temporizador imediatamente e o habilita para inicializações futuras. Habilitar apenas o serviço não cria um agendamento. Teste o trabalho separadamente com sudo systemctl start backup.service.

Escolha um horário ou tempo decorrido

Expressões de calendário podem usar daily para a meia-noite de cada dia ou weekly para segunda-feira à meia-noite. Verifique uma expressão com systemd-analyze calendar "Mon..Fri 09:00" para ver sua interpretação e próxima ocorrência.

As duas últimas configurações são temporizadores monotônicos: eles medem o tempo decorrido desde um evento. Combine-os para uma primeira execução após a inicialização e ativações posteriores a cada hora. Persistent=true se aplica a temporizadores de calendário; ele não adiciona recuperação de calendário a temporizadores monotônicos.

Inspecione o agendamento e os resultados separadamente

systemctl list-timers mostra as próximas e as últimas ativações. systemctl status backup.service mostra o resultado do serviço, e journalctl -u backup.service mostra sua saída e seus erros. Uma próxima execução listada comprova que um agendamento está ativo, não que a tarefa anterior do script foi bem-sucedida.

Temporizadores têm uma janela de disparo. AccuracySec tem como padrão um minuto; AccuracySec=1s reduz a janela de agrupamento. RandomizedDelaySec adiciona deliberadamente um atraso aleatório para distribuir o trabalho entre máquinas. Essas configurações não garantem um segundo exato de início sob carga.

Execute um temporizador próprio do usuário

Arquivos de unidade de usuário ficam em ~/.config/systemd/user/, e os comandos usam systemctl --user, incluindo daemon-reload, enable --now e list-timers. Um gerenciador de usuário normalmente é executado durante a sessão desse usuário. Um administrador pode habilitar a permanência sem sessão ativa com loginctl enable-linger username para mantê-lo disponível sem login.

O cron precisa de uma linha compacta de tempo e funciona sem systemd. Temporizadores acrescentam um resultado de serviço e um diário de registros, recuperação de execuções de calendário e mais controle. Nenhum dos dois normalmente carrega ~/.bashrc; ambos precisam de scripts que funcionem com caminhos explícitos e sem prompts interativos.