Noções básicas de funções do Shell

Introdução

Ao escrever scripts, muitas vezes você precisará repetir o mesmo bloco de código várias vezes. Em vez de reescrever ou copiar e colar esse código, você pode usar funções.

Uma função é um bloco de código nomeado que executa uma tarefa específica. Você a define uma vez e pode chamá-la sempre que precisar. Isso torna seus scripts:

Modulares: mais fáceis de ler e gerenciar.
Reutilizáveis: escreva uma vez e use várias vezes.
Fáceis de manter: se precisar alterar a lógica, você a atualiza em um único lugar.

As funções são importantes porque scripts maiores se tornam difíceis de entender quando tudo fica em um único bloco longo, executado de cima para baixo. Dividir um script em funções é um dos primeiros passos para transformar um “hack rápido de Shell” em uma “automação fácil de manter”.

Neste laboratório, você aprenderá os fundamentos da reescrita de um script usando funções. Você vai:

Criar um script básico.
Definir uma função chamada greet_user.
Chamar a função para executá-la.
Aprimorar a função para aceitar parâmetros (argumentos).

Criar o arquivo de script

Vamos começar preparando nosso espaço de trabalho. Criaremos um arquivo chamado functions.sh para armazenar nosso código.

Nesta etapa, o arquivo de script ainda é apenas um contêiner. A mudança mais importante neste laboratório não é o arquivo em si, mas a ideia de que um script pode ser organizado em partes nomeadas, em vez de consistir em uma única sequência longa executada de cima para baixo.

Primeiro, navegue até o diretório do projeto e crie o arquivo:

cd ~/project
touch functions.sh

Em seguida, abra o arquivo no editor de texto para adicionar o cabeçalho Shebang padrão:

nano functions.sh

Adicione a linha a seguir no início do arquivo:

#!/bin/bash

Salve o arquivo (Ctrl+O, Enter) e saia (Ctrl+X).

Por fim, torne o script executável para que possamos executá-lo mais tarde:

chmod +x functions.sh

Agora você está pronto para começar a escrever o código.

Definir uma função

Agora vamos definir uma função chamada greet_user.

No Bash, você define uma função escrevendo o nome dela seguido de parênteses () e, depois, delimitando o bloco de código com chaves {}.

Uma função dá um nome reutilizável a um bloco de comandos. É assim que os scripts do Shell se tornam mais legíveis: em vez de ver comandos brutos por toda parte, você começa a ver ações com nomes significativos, como backup_files, check_disk ou greet_user.

A sintaxe é esta:

function_name() {
  ## Commands to execute
}

Abra o script novamente:

nano functions.sh

Adicione a definição da função a seguir abaixo da linha Shebang:

#!/bin/bash

greet_user() {
  echo "Hello"
}

Importante: neste momento, nós apenas definimos a função. Ainda não informamos ao script que ela deve ser executada. Se você executasse o script agora, nada aconteceria. Esse é um ponto de confusão comum para iniciantes: definir uma função não a executa automaticamente.

Essa distinção é importante porque um script do Shell é lido e executado em ordem. A definição de uma função ensina ao Bash o que ela significa, mas o corpo da função só é executado quando o nome dela é chamado posteriormente.

Salve e saia por enquanto.

Chamar a função

Para executar o código dentro de uma função, você precisa “chamá-la”. No Bash, basta escrever o nome da função em uma nova linha. Você não precisa usar parênteses ao chamá-la.

Isso pode parecer incomum para iniciantes, porque muitas linguagens de programação usam parênteses nas chamadas de função. No Bash, greet_user sozinho é tratado como um comando. Se existir uma função com esse nome, o Bash executará o corpo dela.

Abra o script:

nano functions.sh

Adicione a chamada da função no final do arquivo:

#!/bin/bash

greet_user() {
  echo "Hello"
}

## The Main Logic starts here
greet_user

Salve e saia.

Agora, execute o script:

./functions.sh

Quando o script é executado, o Shell encontra o comando greet_user, localiza a definição da função, executa echo "Hello" e continua.

Nesse sentido, uma função se comporta como um comando personalizado que existe apenas dentro do script atual ou da sessão atual do Shell. É por isso que as funções são tão úteis para criar ações de nível mais alto a partir de comandos menores do Shell.

Você deverá ver a saída:

Hello

Passar argumentos para a função

Uma função que sempre faz exatamente a mesma coisa, como imprimir "Hello", é limitada. Para torná-la mais útil, podemos passar dados para ela. Esses dados são chamados de argumentos.

Dentro de uma função, você pode acessar os argumentos usando variáveis especiais como $1, $2 etc., assim como faz com os argumentos do script.

$1 faz referência ao primeiro argumento passado para a função.
$2 faz referência ao segundo argumento, e assim por diante.

Esses argumentos são separados dos próprios parâmetros posicionais do script no momento em que a função é executada. Em outras palavras, as funções podem ter sua própria pequena interface de entrada, o que facilita sua reutilização com valores diferentes.

Vamos modificar nossa função para cumprimentar uma pessoa específica.

Etapa 1: atualizar a definição da função

Abra o arquivo:

nano functions.sh

Altere a função greet_user para usar $1 em vez de uma string fixa:

greet_user() {
  echo "Hello $1"
}

Etapa 2: atualizar a chamada da função

Agora que a função espera um argumento, precisamos fornecê-lo ao chamá-la.

Altere a chamada de greet_user para greet_user "LabEx".

Seu arquivo deverá ficar assim:

#!/bin/bash

greet_user() {
  echo "Hello $1"
}

greet_user "LabEx"

Salve e saia.

Etapa 3: testar o script

Execute o script novamente:

./functions.sh

A saída agora deverá ser:

Hello LabEx

Você criou essencialmente um comando personalizado que recebe uma entrada e a processa. Mais adiante no script, você poderia chamar greet_user "Alice" ou greet_user "Bob", e a função se adaptaria de acordo com o valor fornecido.

Resumo

Neste laboratório, você aprendeu os conceitos básicos das funções do Bash:

Definição: criação de um bloco de código nomeado usando name() { ... }.
Chamada: execução da função simplesmente digitando o nome dela.
Argumentos: passagem de dados para a função e acesso a eles por meio de $1, $2 etc.

As funções são os blocos de construção de scripts complexos. Elas permitem organizar sua lógica, reduzir repetições e tornar o código mais fácil de ler e manter.