Shell Scripting Prático: Funções, Arrays e Técnicas de Operação com Arquivos

Shell Scripting Prático: Funções, Arrays e Técnicas de Operação com Arquivos
Tempo de leitura: Cerca de 20 min Dificuldade: Intermediário+

O que você vai conseguir fazer

  • Dividir o trabalho em funções com variáveis locais e arrays reutilizáveis
  • Escrever scripts que param na falha usando `set -euo pipefail` e `trap`
  • Executar scripts de backup, monitoramento de log e organização de arquivos sem destruir dados

Pré-requisitos (leia estes primeiro)

Depois de dominar os fundamentos de shell scripting, é hora de construir habilidades avançadas práticas. Este guia cobre funções, arrays, operações com arquivos e tratamento de erros. No final, apresenta três scripts prontos para uso.

Termos usados neste artigo (definidos antes de começar)

  • Função: um bloco de trabalho com nome, para não repetir os mesmos passos duas vezes
  • Variável local: uma variável que existe apenas dentro da função. Declare com local. Sem local, ela vira uma variável global compartilhada por todo o script
  • Array: vários valores em uma única variável, acessados por índice como em ${arr[0]}
  • Array associativo: um array indexado por texto em vez de número. Também chamado de hash ou dicionário. Disponível a partir do Bash 4.0
  • Código de saída: o número que um comando retorna ao terminar. 0 significa sucesso; qualquer outro valor, falha. Também chamado de status de saída
  • Modo estrito: o apelido de set -euo pipefail, o conjunto de opções que interrompe o script em vez de deixar uma falha passar
  • trap: o mecanismo que registra o que executar quando algo acontece, como um erro ou o fim do script
  • Subshell: um processo de shell separado, derivado do shell pai. Variáveis alteradas dentro dele não voltam para fora

O Que Você Vai Aprender

  • Como definir funções com variáveis locais, valores de retorno e tratamento de erros
  • Como criar e manipular arrays indexados e associativos
  • Técnicas para ler arquivos linha por linha, escrever saída e processar dados CSV
  • Como set -euo pipefail e trap constroem tratamento robusto de erros em scripts
  • Três scripts de automação do mundo real: backup do sistema, monitoramento de logs e organizador de arquivos

Funções

Conclusão: Em funções: local para escopo, echo para retornar valores, return 1 para sinalizar erros.

Definindo e Chamando Funções

Função Básica

$1 é o primeiro argumento passado à função; $2 é o segundo.

#!/bin/bash

greet() {
    echo "Ola, $1!"
}

greet "Alice"
greet "Bob"
Ola, Alice!
Ola, Bob!

Função com Valor de Retorno

Uma função de shell não devolve valores como em outras linguagens. O return carrega apenas um código de saída entre 0 e 255. Para devolver um valor, use echo e capture com $(nome_da_funcao) no ponto de chamada.

#!/bin/bash

square() {
    local num=$1
    local result=$((num * num))
    echo $result
}

number=5
result=$(square $number)
echo "Quadrado de $number e $result"

Função com Múltiplos Argumentos

#!/bin/bash

file_info() {
    local filepath=$1

    if [ -f "$filepath" ]; then
        echo "Arquivo: $filepath"
        echo "Tamanho: $(wc -c < "$filepath") bytes"
        echo "Linhas: $(wc -l < "$filepath") linhas"
        echo "Ultima modificacao: $(stat -c %y "$filepath")"
    else
        echo "Arquivo $filepath nao existe"
        return 1
    fi
}

file_info "/etc/passwd"
file_info "nonexistent.txt"

Funções Avançadas

Variáveis Locais vs Globais

#!/bin/bash

global_var="global"

demo_scope() {
    local local_var="local"
    global_var="global modificado"

    echo "Dentro da funcao: local_var = $local_var"
    echo "Dentro da funcao: global_var = $global_var"
}

echo "Antes da chamada: global_var = $global_var"
demo_scope
echo "Apos a chamada: global_var = $global_var"
echo "Fora da funcao: local_var = $local_var"  # vazio

Função Recursiva

#!/bin/bash

factorial() {
    local n=$1

    if [ $n -le 1 ]; then
        echo 1
    else
        local prev=$(factorial $((n - 1)))
        echo $((n * prev))
    fi
}

for i in {1..5}; do
    result=$(factorial $i)
    echo "$i! = $result"
done

Função com Tratamento de Erros

#!/bin/bash

safe_mkdir() {
    local dir_path=$1

    if [ -z "$dir_path" ]; then
        echo "Erro: caminho do diretorio nao especificado" >&2
        return 1
    fi

    if [ -d "$dir_path" ]; then
        echo "Diretorio $dir_path ja existe"
        return 0
    fi

    if mkdir -p "$dir_path" 2>/dev/null; then
        echo "Diretorio $dir_path criado"
        return 0
    else
        echo "Erro: falha ao criar diretorio $dir_path" >&2
        return 1
    fi
}

safe_mkdir "/tmp/test_dir"
safe_mkdir "/root/forbidden"  # exemplo de erro de permissao

Arrays

Conclusão: "${arr[@]}" para expansão segura; declare -A para arrays associativos (Bash 4.0+).

Operações Básicas com Arrays

Criando Arrays e Acessando Elementos

#!/bin/bash

fruits=("apple" "banana" "orange" "grape")
numbers=(1 2 3 4 5)

echo "Primeira fruta: ${fruits[0]}"
echo "Terceiro numero: ${numbers[2]}"
echo "Todas as frutas: ${fruits[@]}"
echo "Numero de frutas: ${#fruits[@]}"

Adicionando e Removendo Elementos

#!/bin/bash

colors=("red" "green" "blue")
echo "Array inicial: ${colors[@]}"

colors+=("yellow")
echo "Apos adicao: ${colors[@]}"

unset 'colors[1]'  # remover "green" (sem aspas pode ser expandido como nome de arquivo)
echo "Apos exclusao: ${colors[@]}"

echo "Indices: ${!colors[@]}"
Array inicial: red green blue
Apos adicao: red green blue yellow
Apos exclusao: red blue yellow
Indices: 0 2 3

Depois do unset, os índices ficam esparsos: o 1 desaparece. O ${#colors[@]} vale 3, mas o ${colors[1]} está vazio. Percorrer por número pula o vão, então itere com "${colors[@]}" ou "${!colors[@]}".

Arrays Associativos (Bash 4.0+)

#!/bin/bash

declare -A person

person["name"]="John Smith"
person["age"]="30"
person["city"]="New York"

echo "Nome: ${person["name"]}"
echo "Idade: ${person["age"]}"
echo "Todas as chaves: ${!person[@]}"
Nome: John Smith
Idade: 30
Todas as chaves: city age name

A ordem das chaves de um array associativo não é garantida e não tem relação com a ordem de definição. Quando a ordem importa, mantenha um array separado de chaves ou passe por sort.

Uso Prático de Arrays

#!/bin/bash

log_patterns=("/var/log/*.log" "/tmp/*.log" "$HOME/*.log")

for pattern in "${log_patterns[@]}"; do
    echo "Padrao: $pattern"
    files=($pattern)

    if [ ${#files[@]} -gt 0 ] && [ -f "${files[0]}" ]; then
        for file in "${files[@]}"; do
            if [ -f "$file" ]; then
                size=$(wc -c < "$file")
                echo "  - $file ($size bytes)"
            fi
        done
    else
        echo "  - Nenhum arquivo correspondente"
    fi
done

Operações com Arquivos

Conclusão: IFS= read -r + redirecionamento, não pipe -- variáveis do loop sobrevivem fora do loop.

Lendo e Escrevendo Arquivos

Vários Métodos de Leitura de Arquivo

#!/bin/bash

filename="data.txt"

# Metodo 1: usando while read
while IFS= read -r line || [ -n "$line" ]; do
    echo "Linha: $line"
done < "$filename"

# Metodo 2: ler em array
mapfile -t lines < "$filename"
for i in "${!lines[@]}"; do
    echo "Linha $((i+1)): ${lines[i]}"
done

Escrevendo em Arquivos

#!/bin/bash

output_file="output.txt"

echo "Novo conteudo do arquivo" > "$output_file"
echo "Linha adicional 1" >> "$output_file"

cat << EOF >> "$output_file"
Texto multi-linha
Linha 2
Linha 3
EOF

cat "$output_file"

Processando Arquivos CSV

#!/bin/bash

csv_file="employees.csv"

cat << EOF > "$csv_file"
Nome,Idade,Departamento
Alice,30,Engenharia
Bob,25,Vendas
Carol,35,Gerencia
EOF

tail -n +2 "$csv_file" | while IFS=',' read -r name age dept; do
    echo "Funcionario: $name (idade $age) - $dept"
done
Funcionario: Alice (idade 30) - Engenharia
Funcionario: Bob (idade 25) - Vendas
Funcionario: Carol (idade 35) - Gerencia

Este exemplo não altera variáveis do lado direito do pipe, então o problema da subshell não se aplica. Se precisar levar um total para fora do laco, troque por redirecionamento.

Exemplo Avançado de Operação com Arquivos

#!/bin/bash

source_dir="/path/to/source"
backup_dir="/path/to/backup"

backup_files() {
    local src="$1"
    local dest="$2"

    if [ ! -d "$src" ]; then
        echo "Erro: diretorio de origem nao existe: $src"
        return 1
    fi

    mkdir -p "$dest"
    rsync -av --delete "$src/" "$dest/"
    echo "Backup completo: $src -> $dest"
}

log_file="/tmp/backup.log"
{
    echo "Backup iniciado: $(date)"
    backup_files "$source_dir" "$backup_dir"
    echo "Backup finalizado: $(date)"
} >> "$log_file" 2>&1

Tratamento de Erros

Conclusão: Inicie scripts de produção com set -euo pipefail e trap em ERR para falhar rápido.

Melhores Práticas de Tratamento de Erros

Tratamento Estrito de Erros com Opções set

O set -euo pipefail ativa três opções de uma vez. Todas existem para impedir que o script siga adiante depois de uma falha que ninguém percebeu.

#!/bin/bash

set -euo pipefail
# set -e: sair imediatamente quando um comando falha
# set -u: erro em variaveis indefinidas
# set -o pipefail: erro se qualquer comando em um pipeline falhar

trap 'echo "Erro ocorrido: linha $LINENO" >&2' ERR

echo "Processamento normal 1"

Verificação Manual de Erros

#!/bin/bash

process_file() {
    local filename="$1"

    if [ ! -f "$filename" ]; then
        echo "Erro: arquivo '$filename' nao encontrado" >&2
        return 1
    fi

    if [ ! -r "$filename" ]; then
        echo "Erro: sem permissao de leitura para '$filename'" >&2
        return 1
    fi

    local line_count
    if ! line_count=$(wc -l < "$filename" 2>/dev/null); then
        echo "Erro: falha ao contar linhas" >&2
        return 1
    fi

    echo "Contagem de linhas de '$filename': $line_count"
    return 0
}

if process_file "test.txt"; then
    echo "Processamento concluido com sucesso"
else
    echo "Processamento falhou"
    exit 1
fi

Tratamento de Erros com Logging

#!/bin/bash

LOG_FILE="/tmp/script.log"

log() {
    local level="$1"
    shift
    local message="$*"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] [$level] $message" | tee -a "$LOG_FILE"
}

handle_error() {
    local exit_code=$?
    local line_no=$1
    log "ERROR" "Script encerrou com erro (codigo de saida: $exit_code, linha: $line_no)"
    exit $exit_code
}

trap 'handle_error $LINENO' ERR

log "INFO" "Script iniciado"
log "INFO" "Script finalizado"

Exemplos de Scripts do Mundo Real

Conclusão: Backup, monitor de log, organizador -- três scripts sobre funções, arrays e erros.

Exemplo 1: Script de Backup do Sistema

#!/bin/bash

set -euo pipefail

BACKUP_ROOT="/backup"
LOG_FILE="/var/log/backup.log"
RETENTION_DAYS=7
DATE=$(date +%Y%m%d_%H%M%S)

BACKUP_DIRS=(
    "/etc"
    "/home"
    "/var/www"
    "/usr/local/bin"
)

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

cleanup() {
    log "Removendo backups antigos"
    find "$BACKUP_ROOT" -type f -name "backup_*.tar.gz" -mtime +$RETENTION_DAYS -delete
    log "Backups antigos removidos"
}

main_backup() {
    local backup_file="$BACKUP_ROOT/backup_$DATE.tar.gz"
    log "Iniciando backup: $backup_file"
    mkdir -p "$BACKUP_ROOT"

    if tar -czf "$backup_file" "${BACKUP_DIRS[@]}" 2>/dev/null; then
        local size=$(du -h "$backup_file" | cut -f1)
        log "Backup bem-sucedido: $backup_file (tamanho: $size)"
    else
        log "Erro: falha na criacao do backup"
        exit 1
    fi
}

if [ "$(id -u)" -ne 0 ]; then
    echo "Este script deve ser executado como root"
    exit 1
fi

log "Backup do sistema iniciado"
main_backup
cleanup
log "Backup do sistema concluido"

Exemplo 2: Script de Monitoramento de Logs

#!/bin/bash

set -euo pipefail

LOG_FILE="/var/log/syslog"
ALERT_PATTERNS=("ERROR" "CRITICAL" "FAILED")
CHECK_INTERVAL=10
LAST_CHECK_FILE="$HOME/.log_monitor_last_check"  # diretorio home e mais seguro que caminho previsivel em /tmp

send_alert() {
    local message="$1"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] ALERTA: $message" >> "/var/log/alerts.log"
    logger "LOG_MONITOR_ALERT: $message"
}

monitor_logs() {
    local last_position=0

    if [ -f "$LAST_CHECK_FILE" ]; then
        last_position=$(cat "$LAST_CHECK_FILE")
    fi

    local current_size=$(wc -c < "$LOG_FILE")

    if [ "$current_size" -gt "$last_position" ]; then
        local new_lines=$(tail -c +$((last_position + 1)) "$LOG_FILE")

        for pattern in "${ALERT_PATTERNS[@]}"; do
            if echo "$new_lines" | grep -q "$pattern"; then
                local matches=$(echo "$new_lines" | grep "$pattern")
                send_alert "Padrao detectado '$pattern': $matches"
            fi
        done

        echo "$current_size" > "$LAST_CHECK_FILE"
    fi
}

echo "Iniciando monitor de log: $LOG_FILE"
while true; do
    monitor_logs
    sleep "$CHECK_INTERVAL"
done

Exemplo 3: Script Organizador de Arquivos

#!/bin/bash

set -euo pipefail

SOURCE_DIR="$HOME/Downloads"
ORGANIZE_ROOT="$HOME/Organized"
LOG_FILE="/tmp/file_organizer.log"

declare -A FILE_TYPES=(
    ["pdf"]="Documents/PDF"
    ["doc,docx"]="Documents/Word"
    ["jpg,jpeg,png,gif"]="Images"
    ["mp4,avi,mov"]="Videos"
    ["zip,rar,7z,tar,gz"]="Archives"
)

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

get_file_type() {
    local filename="$1"
    local extension="${filename##*.}"
    extension=$(echo "$extension" | tr '[:upper:]' '[:lower:]')

    for types in "${!FILE_TYPES[@]}"; do
        if [[ ",$types," == *",$extension,"* ]]; then
            echo "${FILE_TYPES[$types]}"
            return 0
        fi
    done

    echo "Others"
}

organize_files() {
    log "Iniciando organizacao de arquivos: $SOURCE_DIR"

    if [ ! -d "$SOURCE_DIR" ]; then
        log "Erro: diretorio de origem nao existe: $SOURCE_DIR"
        exit 1
    fi

    local file_count=0

    while IFS= read -r -d '' file; do
        if [ -f "$file" ]; then
            local file_type=$(get_file_type "$(basename "$file")")
            local dest_dir="$ORGANIZE_ROOT/$file_type"
            mkdir -p "$dest_dir"

            if [ -e "$dest_dir/$(basename "$file")" ]; then
                log "Ignorado (ja existe arquivo com esse nome): $(basename "$file")"
                continue
            fi

            mv "$file" "$dest_dir/"
            log "Movido: $(basename "$file") -> $file_type/"
            file_count=$((file_count + 1))
        fi
    done < <(find "$SOURCE_DIR" -maxdepth 1 -type f -print0)

    log "Organizacao completa: $file_count arquivos processados"
}

organize_files

O mv sobrescreve um arquivo de mesmo nome sem avisar

Se já existir um arquivo com o mesmo nome no destino, o mv o sobrescreve em silencio. O script acima verifica com [ -e ... ] antes de mover, ignora o arquivo e registra isso no log.

O mv -n (--no-clobber) também evita a sobrescrita, mas tenha cuidado ao usá-lo em script: as versões recentes do GNU coreutils (9.x) retornam código de saída 1 ao ignorar, então com set -e uma única colisão de nome interrompe a execução inteira. Para manter as duas copias, remova o -n e use mv --backup=numbered (--backup e -n são mutuamente exclusivos).

Na primeira execução, troque mv por echo mv e leia para onde cada arquivo iria. Depois que os arquivos são reorganizados, devolvê-los ao lugar original é trabalhoso.

Erros Comuns e Armadilhas

Conclusão: Cinco armadilhas -- expansão, escopo, subshell, erros, segurança -- cada uma evitável.

Erro 1: Uso Incorreto de Arrays

NG (dividido por espaços)

files=("file1.txt" "file 2.txt" "file3.txt")
for file in $files; do    # dividido por espacos
    echo $file
done

OK (expansão correta)

files=("file1.txt" "file 2.txt" "file3.txt")
for file in "${files[@]}"; do    # expandir como array
    echo "$file"
done

Use "${array[@]}" para expandir o array completo com segurança.

Erro 2: Mal-entendido do Escopo de Funções

NG (variável global modificada sem intenção)

counter=0

increment() {
    counter=$((counter + 1))    # modifica variavel global
    local result=$counter
    echo $result
}

increment
echo "Contador global: $counter"  # mudanca nao intencional

OK (gerenciamento adequado de escopo)

global_counter=0

increment() {
    local local_counter=$1
    local_counter=$((local_counter + 1))
    echo $local_counter
}

result=$(increment $global_counter)
global_counter=$result

Erro 3: Armadilha de Modificação de Variável em Pipeline

NG (mudanças de variável não refletidas)

O lado direito de um pipe roda em uma subshell, um processo separado. As variáveis alteradas ali voltam ao valor anterior assim que o pipeline termina.

count=0

cat file.txt | while IFS= read -r line; do
    count=$((count + 1))
done

echo "Linhas: $count"    # permanece 0 (executa em subshell)

OK (usar redirecionamento)

count=0

while IFS= read -r line; do
    count=$((count + 1))
done < file.txt

echo "Linhas: $count"    # contado corretamente

# ou
count=$(wc -l < file.txt)

Erro 4: Tratamento de Erros Ausente

NG (erros em cascata)

cp source.txt backup.txt
rm source.txt               # deleta mesmo se a copia falhou

curl -o data.json http://api.example.com/data
process_data data.json      # continua mesmo se o download falhou

OK (tratamento robusto de erros)

set -euo pipefail

if cp source.txt backup.txt; then
    echo "Backup bem-sucedido"
    rm source.txt
else
    echo "Erro: backup falhou" >&2
    exit 1
fi

Erro 5: Implementação Sem Consciência de Segurança

NG (problemas de segurança)

O eval executa como comando qualquer texto que receba. Se o usuário digitar rm -rf ~, é exatamente isso que roda. Um arquivo temporário de nome previsível deixa espaço para outra pessoa criá-lo antes (ataque por link simbólico). Uma senha escrita na linha de comando aparece na saída do ps e no histórico do shell.

read -p "Digite o comando: " user_command
eval $user_command                    # execucao arbitraria de comando (perigoso)

temp_file="/tmp/script_data.txt"      # nome de arquivo previsivel
echo "dados sensiveis" > $temp_file

mysql -u user -p'password123' -e "SELECT * FROM users"  # visivel na saida do ps e no historico do shell

OK (implementação segura)

# validar entrada
read -p "Digite o nome do arquivo: " filename
if [[ "$filename" =~ ^[a-zA-Z0-9._-]+$ ]]; then
    echo "Processando: $filename"
else
    echo "Erro: nome de arquivo invalido" >&2
    exit 1
fi

# criacao segura de arquivo temporario
temp_file=$(mktemp)
trap 'rm -f "$temp_file"' EXIT

# mantenha as credenciais em um arquivo de configuracao, fora da linha de comando
# ~/.my.cnf (proteja com chmod 600)
#   [client]
#   user=appuser
#   password=...
mysql --defaults-extra-file="$HOME/.my.cnf" -e "SELECT * FROM users"

Erro 6: Implementação Sem Consciência de Desempenho

NG (processamento ineficiente)

for file in /path/to/large/directory/*; do
    wc -l "$file"           # cria um novo processo por arquivo
done

for i in {1..1000}; do
    current_time=$(date +%s)    # executa o comando date em cada iteracao
    echo "Processando $i em $current_time"
done

OK (implementação eficiente)

# processamento em lote para eficiencia
find /path/to/large/directory -name "*" -type f -exec wc -l {} +

# buscar uma vez, reutilizar
start_time=$(date +%s)
for i in {1..1000}; do
    current_time=$((start_time + i))
    echo "Processando $i em $current_time"
done

Melhores Práticas

Conclusão: Bash em produção: nomes claros, entrada validada, mktemp, set -x e ShellCheck.

Padrões de Codificação

  • Use nomes de variáveis significativos
  • Mantenha funções focadas em uma única responsabilidade
  • Comente para esclarecer intenção, não mecânica
  • Use indentação consistente (2 espaços recomendado)

Segurança

  • Sempre valide a entrada do usuário
  • Use mktemp para arquivos temporários: o nome não pode ser previsto nem ocupado de antemão
  • Defina permissões mínimas necessárias
  • Nunca escreva senhas ou tokens diretamente no script

Depuração

  • O set -x imprime cada comando conforme ele é executado
  • Implemente logging apropriado
  • Desenvolva e teste incrementalmente
  • Use ferramentas de analise estática como o ShellCheck. Elas apontam construções propensas a acidente, como aspas faltando, antes de qualquer execução

Resumo

Dominar técnicas práticas de shell scripting permite automação eficiente e confiável. Em qualquer script que destrua algo, confirme os alvos com --dry-run ou -print antes da execução real.

  • Funções melhoram a reutilização e manutenção do código
  • Arrays simplificam o processamento complexo de dados
  • Tratamento adequado de erros cria scripts robustos
  • Exemplos do mundo real fornecem padrões que você pode adaptar para produção

Próximas Leituras