Aula 13 — Funções em Shell Script

🎯 O que são Funções?

Uma função é um bloco de código reutilizável que executa uma tarefa específica. Você a define uma vez e pode chamá-la quantas vezes precisar, passando diferentes valores (parâmetros) a cada chamada.

❌ Sem função — código duplicado

echo "Backup iniciando..." cp -r /dados /backup echo "Backup concluído!" # 50 linhas depois... igual! echo "Backup iniciando..." cp -r /dados /backup echo "Backup concluído!"

✅ Com função — escreva uma vez

fazer_backup() { echo "Backup iniciando..." cp -r /dados /backup echo "Backup concluído!" } fazer_backup # usa quando quiser! fazer_backup # e de novo!

Evita repetir código — escreva uma vez, use muitas
Scripts menores e mais fáceis de manter
Cada função tem uma responsabilidade clara
Facilita testes e depuração

📝 Sintaxe Básica

No Bash existem duas formas equivalentes de declarar uma função. Ambas funcionam da mesma maneira; a primeira é a mais comum em scripts modernos.

Forma 1 — mais comum

sintaxe

nome_funcao() { comando1 comando2 }

Forma 2 — palavra-chave explícita

sintaxe alternativa

function nome_funcao() { comando1 comando2 }

Primeiro exemplo completo

saudacao.sh

#!/bin/bash # 1. Definir a função saudacao() { echo "Olá, bem-vindo!" echo "Hoje é $(date +%d/%m)" } # 2. Chamar a função saudacao Olá, bem-vindo! Hoje é 25/02

⚠️ Regra importante: sempre defina a função antes de chamá-la! O Shell lê o script de cima para baixo — chamar uma função antes de defini-la causa erro.

📥 Parâmetros de Funções

Funções podem receber valores de entrada chamados parâmetros. Eles são acessados pelas variáveis especiais $1, $2, etc., da mesma forma que argumentos de script.

Variável	Significado
`$1`	Primeiro parâmetro
`$2`	Segundo parâmetro
`$3`	Terceiro parâmetro
`$@`	Todos os parâmetros
`$#`	Quantidade de parâmetros recebidos

Função com um parâmetro

saudar.sh

saudar() { echo "Olá, $1!" } saudar "Maria" saudar "João" saudar "Ana" Olá, Maria! Olá, João! Olá, Ana!

Função com múltiplos parâmetros

apresentar.sh

apresentar() { echo "Nome: $1" echo "Idade: $2 anos" echo "Cidade: $3" } apresentar "Pedro" "25" "São Paulo" Nome: Pedro Idade: 25 anos Cidade: São Paulo

🧮 Funções com Cálculos

Funções podem realizar operações aritméticas com $(( )) e retornar o resultado via echo. Para capturar o valor impresso por uma função, use a substituição de comando $(funcao).

Função soma

soma.sh

soma() { RESULTADO=$(($1 + $2)) echo "$1 + $2 = $RESULTADO" } soma 10 5 soma 100 200 10 + 5 = 15 100 + 200 = 300

Calculadora completa com captura de resultado

calculadora.sh

somar() { echo $(($1 + $2)); } subtrair() { echo $(($1 - $2)); } multiplicar() { echo $(($1 * $2)); } dividir() { echo $(($1 / $2)); } echo "Soma: $(somar 10 5)" echo "Subtração: $(subtrair 10 5)" echo "Multiplicação: $(multiplicar 10 5)" echo "Divisão: $(dividir 10 5)"

💡 $(funcao arg1 arg2) executa a função e captura o que ela imprime com echo. Use este padrão para armazenar resultados: TOTAL=$(somar 10 5).

💬 Funções Interativas

Funções podem usar read internamente para coletar dados do usuário, encapsulando toda a lógica de interação em um bloco reutilizável.

Soma interativa

soma-interativa.sh

soma_interativa() { read -p "Número 1: " N1 read -p "Número 2: " N2 echo "Resultado: $(($N1 + $N2))" } soma_interativa

Validação de senha

verificar-senha.sh

verificar_senha() { read -sp "Senha: " SENHA echo # nova linha após input oculto if [ "$SENHA" = "1234" ]; then echo "Acesso permitido!" else echo "Senha incorreta!" fi } verificar_senha

💡 read -s oculta o texto digitado — essencial para senhas. read -sp "texto" combina prompt e modo silencioso em uma só opção.

↩️ Retorno de Funções

No Bash, funções podem “retornar” de duas formas distintas dependendo do objetivo: return para códigos de status e echo para valores de texto.

`return` — código de saída (0–255)

verificar-arquivo.sh

verificar_arquivo() { if [ -f "$1" ]; then return 0 # sucesso else return 1 # erro fi } if verificar_arquivo "dados.txt"; then echo "Arquivo existe!" else echo "Arquivo não encontrado!" fi

`echo` — retornar valores de texto

dobrar.sh

dobrar() { echo $(($1 * 2)) } RESULTADO=$(dobrar 5) echo "O dobro de 5 é: $RESULTADO" O dobro de 5 é: 10

📌 Quando usar cada um: return para indicar sucesso/falha (use em if funcao); echo para devolver valores — capture com VAR=$(funcao).

🔒 Variáveis Locais com `local`

Por padrão, variáveis criadas dentro de uma função são globais e podem interferir no restante do script. A palavra-chave local restringe a variável ao escopo da função.

❌ Sem `local` — altera o global

NOME="Ana" mudar_nome() { NOME="Pedro" # altera global! } echo "Antes: $NOME" mudar_nome echo "Depois: $NOME" Antes: Ana Depois: Pedro # Ops!

✅ Com `local` — preserva o global

NOME="Ana" mudar_nome() { local NOME="Pedro" echo "Dentro: $NOME" } echo "Antes: $NOME" mudar_nome echo "Depois: $NOME" Antes: Ana Dentro: Pedro Depois: Ana # Preservada!

💡 Use local em todas as variáveis internas de funções. Isso evita efeitos colaterais imprevisíveis e torna o script mais previsível e fácil de depurar.

📥 Importando Funções com `source`

É possível organizar funções em arquivos separados e importá-las em qualquer script com source ou o atalho . (ponto). Isso cria uma biblioteca de funções reutilizável.

Arquivo de biblioteca: `funcoes.sh`

funcoes.sh

#!/bin/bash # Biblioteca de funções compartilhadas saudacao() { echo "Olá, $1!" } despedida() { echo "Tchau, $1!" }

Script principal: `main.sh`

main.sh

#!/bin/bash # Importar funções (duas formas equivalentes) source funcoes.sh # ou: . funcoes.sh # Agora pode usar as funções importadas saudacao "Maria" despedida "Maria" Olá, Maria! Tchau, Maria!

📌 source e . (ponto) fazem exatamente a mesma coisa. Os arquivos devem estar no mesmo diretório ou use o caminho completo: source /opt/scripts/funcoes.sh.

🚀 Projeto: Menu com Funções

Combinação de while true + case + funções: cada opção do menu chama uma função específica, tornando o código organizado e fácil de expandir.

sistema.sh

#!/bin/bash # Sistema de informações com menu e funções mostrar_menu() { echo "╔═══════════════════════╗" echo "║ SISTEMA DE INFOS ║" echo "╠═══════════════════════╣" echo "║ 1) Ver data/hora ║" echo "║ 2) Ver usuário ║" echo "║ 3) Ver diretório ║" echo "║ 0) Sair ║" echo "╚═══════════════════════╝" } ver_data() { date "+%d/%m/%Y %H:%M"; } ver_usuario() { whoami; } ver_diretorio() { pwd; } while true; do mostrar_menu read -p "Opção: " OPC case "$OPC" in 1) ver_data ;; 2) ver_usuario ;; 3) ver_diretorio ;; 0) echo "Tchau!"; break ;; *) echo "Opção inválida!" ;; esac read -p "Enter para continuar..." done

💡 Boas Práticas

✅ Faça isso

# Nomes descritivos calcular_media() verificar_arquivo() # Use local para variáveis internas local RESULTADO=0 # Documente parâmetros # Função: calcula média # Parâmetros: $1=nota1, $2=nota2 calcular_media() { ... }

❌ Evite isso

# Nomes genéricos func1() fazcoisa() # Funções enormes # (divida em funções menores) # Chamar antes de definir minha_funcao # ERRO! minha_funcao() { ... }

📋 Checklist: nomes descritivos • use local para variáveis internas • defina sempre antes de chamar • uma tarefa por função • documente parâmetros nos comentários.

📋 Resumo dos Comandos

nome() { } Criar Define a função

nome Chamar Executa a função

$1 $2 $3 Parâmetros Valores de entrada

$@ Todos Todos os parâmetros

$# Quantidade Núm. de parâmetros

local VAR Local Só existe na função

return N Status 0=sucesso, 1+=erro

source arq Importar Carrega outro arquivo

$(funcao) Capturar Usa o echo da função

🎯 Exercício — Arraste e Conecte

Relacione cada elemento de funções à sua descrição.

Descrição

Primeiro parâmetro recebido pela função

Define variável que só existe dentro da função

Importa funções de outro arquivo

Retorna código de saída (0=sucesso, 1=erro)

Quantidade de parâmetros recebidos

Captura o que uma função imprime com echo

Elemento

$1

local

source

return

$#

$(funcao)

🛠️ Atividade Prática — Criando Funções

⏱ ~35 min 💻 Terminal Bash 📸 Tirar screenshot da saída

1

Funções básicas com parâmetros

Escreva calculadora.sh com quatro funções aritméticas. Cada uma recebe $1 e $2 e exibe o resultado:

~/scripts/calculadora.sh

#!/bin/bash somar() { echo "$1 + $2 = $(( $1 + $2 ))"; } subtrair() { echo "$1 - $2 = $(( $1 - $2 ))"; } multiplicar() { echo "$1 × $2 = $(( $1 * $2 ))"; } dividir() { echo "$1 ÷ $2 = $(( $1 / $2 ))"; } somar 10 3 subtrair 10 3 multiplicar 10 3 dividir 10 3

bash — saída

usuario@servidor:~/scripts$ ./calculadora.sh 10 + 3 = 13 10 - 3 = 7 10 × 3 = 30 10 ÷ 3 = 3

2

Função com local e return

Escreva validar.sh com verificar_numero usando variável local e return como código de saída para uso em if:

~/scripts/validar.sh

#!/bin/bash verificar_numero() { local NUM="$1" [ "$NUM" -gt 0 ] && return 0 return 1 } read -p "Digite um número: " VALOR if verificar_numero "$VALOR"; then echo "✅ Número positivo" else echo "❌ Zero ou negativo" fi

bash — testar

usuario@servidor:~/scripts$ ./validar.sh Digite um número: 7 ✅ Número positivo usuario@servidor:~/scripts$ ./validar.sh Digite um número: -3 ❌ Zero ou negativo

3

Biblioteca de funções

Crie lib.sh com funções utilitárias e importe-a em main.sh com source:

~/scripts/lib.sh

#!/bin/bash linha_separadora() { printf '%.0s-' {1..40}; echo; } cabecalho() { linha_separadora; echo " $1"; linha_separadora; } log() { echo "[$(date '+%H:%M:%S')] $1"; }

~/scripts/main.sh

#!/bin/bash source ./lib.sh cabecalho "Relatório do Sistema" log "Iniciando verificações..." log "Usuário: $(whoami)" linha_separadora

bash — executar

usuario@servidor:~/scripts$ ./main.sh ---------------------------------------- Relatório do Sistema ---------------------------------------- [10:30:01] Iniciando verificações... [10:30:01] Usuário: usuario ----------------------------------------

4

Menu completo com funções

Escreva sistema.sh onde cada opção do menu é uma função dedicada, mantendo o código organizado e legível:

~/scripts/sistema.sh

#!/bin/bash info_sistema() { uname -a; uptime; } usuarios() { who; } espaco_disco() { df -h; } exibir_menu() { echo "1) Info sistema 2) Usuários 3) Disco 4) Sair" } while true; do exibir_menu read -p "Opção: " OP case "$OP" in 1) info_sistema ;; 2) usuarios ;; 3) espaco_disco ;; 4) break ;; esac done

bash — sessão de uso

usuario@servidor:~/scripts$ ./sistema.sh 1) Info sistema 2) Usuários 3) Disco 4) Sair Opção: 1 Linux servidor 5.15.0-91-generic #101-Ubuntu x86_64 10:30:05 up 2:14, 1 user, load average: 0.01 1) Info sistema 2) Usuários 3) Disco 4) Sair Opção: 4

📌 Para refletir: funções transformam scripts longos e repetitivos em código modular e legível. Com funções, variáveis locais e source, você tem as ferramentas para construir sistemas Shell Script profissionais e de fácil manutenção.

❓ Verifique seu Conhecimento

Como declarar uma função em Bash?

Afunction nome() { comandos }

BAmbas: nome() { comandos; } e function nome { comandos; } são válidas

Cdef nome() { comandos }

Dfunc nome = { comandos }

✓ Bash aceita duas sintaxes: nome() { ... } e function nome { ... }. A primeira é mais portável entre shells.

Como acessar o primeiro argumento passado para uma função Bash?

A$arg[1]

B$param1

C$1

D${function.arg1}

✓ Dentro de uma função, $1, $2... são os argumentos da função (não do script). $# é a quantidade de argumentos recebidos.

O que faz local variavel=valor dentro de uma função?

ACria uma variável visível apenas dentro da função

BExporta a variável para outros scripts

CTorna a variável somente-leitura

DCria uma variável global acessível em todo o script

✓ local limita o escopo da variável à função — boa prática para evitar conflitos com variáveis globais de mesmo nome.

Como fazer uma função retornar um valor calculado para ser capturado em uma variável?

Areturn "valor"

Bexit "valor"

Cgive "valor"

Decho "valor" e capturar com resultado=$(funcao)

✓ return só retorna códigos de saída (0-255). Para retornar strings ou números calculados, use echo na função e capture com var=$(funcao).

🔧 Funções em Shell Script