Um Guia Simples para a Programação de Scripts de Shell no Linux com Bash

Já se encontrou querendo aprender mais sobre a scriptação de shell do Linux, mas não sabia por onde começar? É relativamente novo no mundo dos sistemas operacionais baseados em Unix e deseja ampliar suas habilidades para fazer programação de shell básica? Este tutorial para iniciantes abordará os conceitos básicos da scriptação de shell do Linux com o Bash, incluindo a criação e execução de um script, bem como o trabalho com strings e loops.

A scriptação de shell é usada para automatizar tarefas administrativas comuns

Independentemente do sistema operacional, os scripts de shell são usados para automatizar tarefas administrativas repetitivas. Por exemplo, no Windows, você pode renomear arquivos usando o Explorador de Arquivos. Mas se precisar renomear muitos arquivos, seria uma tarefa demorada usar o shell gráfico. O PowerShell permite que você automatize a tarefa e a repita de forma confiável.

Nos sistemas operacionais baseados em Linux, o Bash e outros shells são usados para automatizar tarefas como trabalhar com arquivos, modificar a configuração do sistema e muitas outras tarefas que, de outra forma, poderiam ser realizadas digitando comandos individuais.

O que você precisa para aprender a scriptação de shell do Bash

Para escrever e executar um script Bash, você só precisa de três coisas:

• Qualquer editor de texto simples, como o Notepad, Text Editor, TextEdit, vi, emacs ou Visual Studio Code.
• A terminal emulator, an application that comes preinstalled with most operating systems and is often called Terminal, Console, or Command Prompt.
• O próprio Bash.

O emulador de terminal é onde você digitará comandos e os executará pressionando Enter. Quanto ao Bash, se ele estiver pré-instalado ou não dependerá da sua plataforma:

• No macOS, o Bash é pré-instalado. Em versões mais recentes, o shell Z (zsh) é o shell padrão, o que é aceitável. Contanto que o Bash esteja instalado, você também pode executar scripts Bash a partir do zsh.
• Distribuições Linux geralmente têm o Bash instalado. (Você pode verificar procurando se o seu sistema inclui o arquivo /bin/bash.) O Android é um caso especial que não vem com o Bash. Existem procedimentos para obter o Bash no Android, os quais este artigo não abordará.
• O Windows não vem com o Bash incluído. O PowerShell é o shell de linha de comando padrão no Windows. Você precisará instalar uma distribuição Linux no Windows Subsystem for Linux (WSL) para executar o Bash.

Para encontrar a versão do seu Bash, execute o comando bash –version. Mesmo versões mais antigas do Bash proporcionam muita potência, porém o Bash 3 e 4 introduzem boas abreviações para certos comandos básicos. Se um comando requer uma destas versões do Bash, será mencionado abaixo.

O que é um shell?

No mundo da computação, um shell é um programa que serve como interface para o sistema operacional subjacente. Um shell pode ser uma interface gráfica do usuário (GUI), como o shell do Windows.

Linguagens de script de shell

No entanto, as pessoas geralmente usam o termo para se referir especificamente a uma interface de linha de comando (CLI) – uma interface consistindo de linhas de texto com as quais você interage usando apenas o teclado. Aqui estão alguns exemplos de linguagens de script de shell para sistemas operacionais *nix:

• o shell Bash (abreviação de “Bourne Again Shell”)
• o shell C
• o shell Korn

Aqui, vamos nos concentrar no shell Bash. É um popular shell Unix gratuito pré-instalado na maioria das distribuições Linux e no macOS.

O que é um script de shell?

Os shells têm sua própria linguagem de programação. Você usa essa linguagem para enviar comandos para o shell, que então os executa. Você pode digitar esses comandos diretamente no shell, ou pode salvá-los em um arquivo – um script – e então executar esse arquivo a partir do shell. A sintaxe para escrever comandos é a mesma em ambos os casos.

Este artigo abordará os conceitos básicos de script de shell para criar este arquivo.

Scripting de shell básico

Vamos começar com alguns conceitos básicos de scripting de shell. Para escrever um script simples, vamos aprender alguns comandos simples de script de shell no Linux:

1. Crie um novo arquivo de texto vazio em um editor de texto.
2. Escreva #!/bin/bash como a primeira linha.
3. Insira seus comandos abaixo disso.
4. Salve o arquivo, de preferência com a extensão “.sh” ou sem extensão alguma.

A linha #!/bin/bash é chamada de “shebang”. Ela informa ao seu shell que esse script deve ser executado em Bash e deve ser a primeira linha do seu script. Se você mudar para um shell diferente, seu script ainda será executado em Bash.

Para experimentar esse processo por conta própria, crie um arquivo chamado ‘hello_world’ no seu diretório pessoal:

#!/bin/bash
echo "hello world"

E é isso — você criou um script Bash!

Antes de executá-lo, provavelmente será necessário alterar as permissões do arquivo.

Definindo permissões para executar um script shell usando chmod

Para modificar as permissões no nosso arquivo ‘hello_world’, você executaria este comando específico em seu emulador de terminal. Isso dá ao usuário que é dono do arquivo permissão para executá-lo.:

chmod u+x 'hello_world'

Se você só quer executar o seu script de shell, pode pular para a próxima seção. Para aqueles curiosos sobre o comando chmod, chmod é abreviação de “change mod e”, e serve para mudar “modos” de arquivos (ou permissões) no Unix. Em sistemas operacionais semelhantes ao Unix, você pode definir permissões de arquivo para 3 classes de usuários:

• O usuário que é dono do arquivo (representado por u no chmod).
• O grupo que é dono do arquivo (g).
• Outros (o).

Com o comando chmod, você também pode usar a para se referir a todos eles.

Cada arquivo tem 3 tipos de permissões (ou “modos”):

• Leitura (r)
• Escrita (w)
• Execução (x)

E você também pode adicionar (+) ou remover (-) permissões.

O primeiro parâmetro em chmod é uma combinação destes três — usuário primeiro, ação segundo e modo terceiro. Aqui estão alguns exemplos de comando:

• chmod gu+rw 'hello_world' adicionaria permissões de leitura e escrita para o proprietário e o grupo proprietário.
• chmod a-x 'hello_world' removeria permissões de execução para todos.
• chmod u+rwx 'hello_world' 'hello_world_2' daria ao proprietário a permissão para ler, escrever e executar os arquivos “hello_world” e “hello_world_2”.

Nós apenas cobrimos o básico do comando chmod aqui. Existe uma maneira mais complicada, mas menos verbosa de definir esses modos (a “notação numérica”), bem como um comando diferente que você pode usar para ver as permissões de seus arquivos (ls -l). Não vamos entrar nesses tópicos aqui.

Executando um script shell

Hora de executar nosso primeiro script. Em geral, para executar um script, basta digitar seu caminho no emulador de terminal e pressionar enter.

./hello_world

Você pode usar o caminho relativo ou o caminho absoluto. Ao usar o caminho relativo, sempre use ./ no início do seu comando: Isso indica ao terminal para procurar na pasta atual (representada por '.'), em vez dos diretórios definidos na variável de ambiente PATH.

Usando comentários para anotar seu script

Tudo após um # em uma única linha em um script Bash é considerado um comentário. Eles podem ser úteis para explicar o que uma linha complexa faz ou para dar uma visão geral do que partes maiores do seu script fazem.

Por exemplo:

#!/bin/bash

#
# This shell script prints "hello world".
#

echo "hello world" # This line prints "hello world".

Uma introdução às variáveis

Ao escrever scripts, pode ser útil definir variáveis. No Bash, você faz isso digitando o nome da variável e o valor, separados por um sinal de igual: NOMEDA_VARIAVEL='VALOR'.

Você não deve colocar espaços ao lado do sinal de igual — o Bash pensaria que você quer executar um processo em vez disso.

Use aspas simples para cercar o valor e evitar que o Bash o interprete como algo diferente. No Bash, as variáveis não têm tipos — tudo é basicamente uma string. Cabe aos programas Bash analisar a string como um tipo diferente, como um número.

Para se referir ao valor de uma variável, use o nome da variável precedido pelo cifrão: $NOMEDA_VARIAVEL.

Para tentar isso na prática, você pode alterar seu script para o seguinte:

#!/bin/bash
HELLO="hello variable world"
echo $HELLO # should print "hello variable world"

Recebendo argumentos

As palavras individuais que você escreve ao digitar um comando são chamadas de argumentos. Em nosso exemplo chmod u+x 'hello_world', chmod, u+x, e 'hello_world' são três argumentos diferentes. chmod é o nome do comando enquanto u+x e hello_world são chamados de parâmetros — argumentos que fornecem informações extras para o comando.

Em seu script, você pode acessar esses argumentos por meio de variáveis. Para evitar conflitos com variáveis locais, essas variáveis são nomeadas usando números — $0 se refere ao nome do comando, $1 é o próximo argumento que segue, $2 o seguinte, e assim por diante.

Vamos tentar isto:

#!/bin/bash
HELLO="hello $1 world"
echo $HELLO

Agora, execute este script com estes parâmetros:

./hello_world bash script

A saída deve ser olá mundo bash, com o primeiro parâmetro utilizado e o segundo ignorado.

Se você quisesse que script bash fosse visto como um parâmetro, você precisaria colocá-lo entre aspas: 

./hello_world 'bash script'

Usando a instrução if para executar código condicionalmente

Uma das coisas essenciais que os programadores querem fazer dentro de um script é executar um trecho de código apenas se uma determinada condição for atendida. O Bash possui a instrução if para isso:

NUM=$RANDOM
if (( $NUM % 2 )) # if CONDITION
then
    echo "$NUM is odd"
fi # this is how you end an if statement

Dica: Daqui em diante, assume-se que esses exemplos façam parte de um script maior e omitem o #!/bin/bash no início. No entanto, não se esqueça dele como primeira linha do seu script!

Você também pode usar else dentro de uma instrução if para especificar o que fazer se uma condição não for atendida, ou uma instrução elif (abreviação de “else if“) para especificar outra condição se a primeira não for atendida:

NUM=$RANDOM
if [ $NUM -eq 12 ]
then
    echo "$NUM is my favorite number"
elif (( $NUM % 2 ))
then
    echo "$NUM is odd"
else
    echo "$NUM is even"fi

‘fi‘ é usado para fechar a instrução if.

Dica: Se não souber como escrever a condição em si, consulte a notação teste, colchetes simples ([]) e duplos parênteses ((())).

Repetindo uma série de comandos usando um loop for

Agora que cobrimos a execução condicional do código, vamos ver como executar um código um certo número de vezes, desde que uma condição seja atendida.

O for loop é perfeito para essa tarefa — especificamente sua “sintaxe de três expressões”. A ideia por trás disso é atribuir uma variável específica do loop e gradualmente alterá-la até que uma certa condição seja atendida. Veja como é estruturado:

for (( ASSIGNMENT_EXPRESSION ; CONDITION_EXPRESSION ; UPDATE_EXPRESSION ))
do
    COMMANDS
done

Por exemplo, se você deseja que um loop seja executado 10 vezes com valores para “i” indo de 0 a 9, seu loop for pode se parecer com isso:

for (( i=0; i<10; i++ ))
do
    echo $i
done

Vamos analisar:

• i=0 is the assignment expression here. It’s run only once before the loop is executed, which is why it’s useful for initializing a variable.
• i<10 is our condition expression. This expression is evaluated before each iteration of a loop. If it is equal to zero (which means the same as “true” in Bash), the next iteration is not run.
• i++ is our update expression. It’s run after each iteration of a loop.

Passando por elementos em uma lista

Além da sintaxe de três expressões, você também pode usar a palavra-chave in para definir um loop for. Essa sintaxe alternativa é usada para iterar por uma série de itens.

O exemplo mais básico é simplesmente listar o conjunto de itens pelos quais deseja iterar após a palavra-chave in, separados por espaços. Por exemplo:

for i in 0 1 2 3 4 5 6 7 8 9 # space-separated list items
do
    echo $i
done

Você também pode iterar pelos itens produzidos por um comando:

for i in $(seq 0 1 9)

A notação $() é usada para substituição de comando de forma geral — ela executa um comando e sua saída é utilizada como entrada para o comando pai que o envolve.

Se você estiver iterando por números inteiros, é melhor usar a sintaxe de intervalo incorporada ao Bash, que é mais eficiente do que o comando seq. No entanto, essa sintaxe está disponível apenas em versões mais recentes do Bash:

• for i in {0..9}, disponível no Bash 3.
• for i in {0..9..1}, disponível no Bash 4, onde o último número representa o incremento.

Da mesma forma, você também pode iterar por strings: 

for s in 'item1' 'item2' 'item3'

Usando globbing para obter arquivos que correspondem a um padrão

Um dos casos de uso mais comuns para os loops discutidos na seção anterior é iterar pelos arquivos individuais.

Para lidar com isso, precisamos primeiro abordar as chamadas “expansões de globo”. Isso é uma funcionalidade do Bash que permite especificar nomes de arquivo usando correspondência de padrões. Existem caracteres especiais chamados de wildcards que você utiliza para definir esses padrões.

Antes de entrar em detalhes sobre isso, vamos dar uma olhada em alguns exemplos específicos:

• echo *: Um comando que retorna os nomes de todos os arquivos no seu diretório atual, exceto os ocultos.
• echo *.txt: Um comando que retorna os nomes de todos os arquivos não ocultos com extensão txt no seu diretório atual.
• echo ????: Um comando que retorna todos os nomes de arquivos com quatro letras no seu diretório atual.

Os coringas que usamos foram * e ? aqui. Há também mais um coringa que não utilizamos. Aqui está uma visão geral:

• O asterisco (*) representa qualquer número de caracteres (incluindo 0) em um nome de arquivo ou diretório.
• O ponto de interrogação (?) representa um único caractere em um nome de arquivo ou diretório.
• O asterisco duplo (**) representa qualquer número de caracteres em um caminho completo de arquivo. É um recurso no Bash 4 e acima e precisa ser ativado executando shopt -s globstar.
• Os colchetes ([]) são usados para representar um caractere dentro de um conjunto de símbolos em um nome de arquivo ou diretório. Por exemplo [st]ake localizaria arquivos chamados sake ou take, mas não stake.

Observe que todos os arquivos ocultos (que são arquivos com nomes que começam com um ponto .) são ignorados ao usar a expansão de globo.

A notação de colchetes permite um pouco mais de complexidade, incluindo:

• Intervalos definidos pelo primeiro e último valor — por exemplo, [1-8]
• Eliminação de certos caracteres usando ! como o primeiro caractere dentro dos colchetes — por exemplo, [!3]

Para tratar um destes caracteres especiais como um caractere normal sem qualquer significado, basta colocar uma barra invertida antes dele — por exemplo, \?.

Iterando através de arquivos usando um loop for

Agora que cobrimos o básico da expansão de GLob, vamos dar uma olhada em como usá-la para iterar através de arquivos.

Podemos simplesmente usar os operadores de glob no próprio loop for. Aqui está um exemplo simples de um loop que imprime o nome de cada arquivo no diretório atual:

for f in *
do
    echo $f
done

Para imprimir os nomes de cada arquivo no diretório atual e seus subdiretórios, verifique se você está executando o Bash 4.0 ou acima ao executar bash --version e, em seguida, você pode executar o seguinte comando:

shopt -s globstar # enables using **
for f in **
do
    echo $f
done

Dica: Se você estiver utilizando uma versão mais antiga do Bash, não será capaz de usar a expansão de globo com um loop for para isso. Sua melhor opção seria o comando find, mas não abordaremos isso neste artigo.

Estes são, claro, apenas alguns dos loops mais simples que você pode executar, mas há muito mais que você pode fazer. Por exemplo, para renomear todos os arquivos JPG em uma pasta para dar a eles um nome de arquivo sequencial consistente, você poderia executar:

i=1
for f in *.jpg
do
    mv -i -- "$f" "image_$i.jpg"
    let i=i+1
done

Executando código enquanto uma condição é verdadeira

O loop for não é o único tipo de loop que podemos usar no Bash — também temos o while: Este tipo de loop roda enquanto uma condição específica for verdadeira.

A sintaxe é semelhante à sintaxe do loop for:

while CONDITION
do
    COMMANDS
done

Para um exemplo prático, desta forma você poderia ler um arquivo linha por linha (exceto espaços em branco no início ou no final) até chegar ao final do arquivo:

while read -r line
do
    echo "$line"
done < FILENAME # Replace FILENAME with the path to a text file you'd like to read

Você também pode substituir um loop for por um loop while, por exemplo, para iterar de 0 a 9:

i=0
while [ $i -lt 10 ]
do
    echo $i
    let i=i+1
done

E você também poderia teoricamente executar um loop para sempre. Aqui está um exemplo de comando:

while true
do
    echo "running forever"
done

Dica: Para encerrar o script, basta pressionar Ctrl+C.

Embora este loop infinito possa parecer inútil à primeira vista, na verdade pode ser bastante útil, especialmente quando combinado com a declaração break.

Saindo de um loop

A declaração break é usada para sair de um loop.

Isso permite que você execute um loop infinito e saia dele quando surgirem quaisquer condições de interrupção.

Para ver um exemplo simples, podemos replicar nosso loop de 0 a 9 com um loop infinito assim:

i=0while true
do
    if [ $i -eq 10 ]
    then
        break
    fi
    echo $i
    let i=i+1
done

Se você tiver vários loops while aninhados, você pode adicionar um número após a instrução break para mencionar de qual nível de loop deseja sair: break 1 é o mesmo que break e sairá do loop mais próximo, break 2 sairá do loop um nível acima, etc.

Vamos ver um exemplo rápido, desta vez com loops for, iterando através de todas as combinações de palavras de quatro letras até atingir a palavra “bash”:

for l4 in {a..z}
do
    for l3 in {a..z}
    do
        for l2 in {a..z}
        do
            for l1 in {a..z}
            do
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

A related keyword that’s also worth a mention is continue, which skips to the next iteration of the loop. Just like break, it also takes an optional numeric argument that corresponds to the loop level.

Aqui está um exemplo bobo onde ignoramos todas as palavras com Es em nossa lista de palavras de quatro letras abreviadas:

for l4 in {a..z}
do
    if [ $l4 = "e" ]
    then
        continue
    fi
    for l3 in {a..z}
    do
        if [ $l3 = "e" ]
        then
            continue
        fi
        for l2 in {a..z}
        do
            if [ $l2 = "e" ]
            then
                continue
            fi
            for l1 in {a..z}
            do
                if [ $l1 = "e" ]
                then
                    continue
                fi
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

Também podemos executar todas essas declarações continue no nível mais profundo do loop:

for l4 in {a..z}
do
    for l3 in {a..z}
    do
        for l2 in {a..z}
        do
            for l1 in {a..z}
            do
                if [ $l4 = "e" ]
                then
                    continue 4
                fi
                if [ $l3 = "e" ]
                then
                    continue 3
                fi
                if [ $l2 = "e" ]
                then
                    continue 2
                fi
                if [ $l1 = "e" ]
                then
                    continue
                fi
                echo "$l4$l3$l2$l1"
                if [ $l4 = "b" -a $l3 = "a" -a $l2 = "s" -a $l1 = "h" ]
                then
                    break 4
                fi
            done
        done
    done
done

Como obter a entrada do usuário em um script shell

Às vezes, você deseja que o usuário interaja diretamente com seu script em vez de apenas usar argumentos de script iniciais. É aí que entra o comando read.

Para obter a entrada do usuário e salvá-la em uma variável chamada NOME, você usaria este comando:

read NAME 

Esta é a forma mais simples do comando, consistindo apenas no nome do comando e na variável na qual deseja salvar a entrada.

Mais frequentemente, porém, você desejará solicitar ao usuário para que eles saibam o que digitar. Você faz isso com o argumento -p, após o qual escreve a sua prompt preferida.

Aqui está como você pode pedir um nome, atribuindo-o a uma variável chamada NOME:

read -p "Your name: " NAME
echo "Your name is $NAME." # this line is here just to show that the name has been saved to the NAME variable

Imprimindo caracteres especiais em uma string

Há uma série de caracteres no Bash sobre os quais você deve ter cuidado ao usar. Por exemplo, espaços dentro de nomes de arquivos, aspas dentro de strings ou barras invertidas praticamente em qualquer lugar.

Para dizer ao Bash para ignorar o significado especial deles em determinados lugares, você pode “escapá-los” ou envolvê-los em uma citação literal.

“Escapar” um caractere especial significa dizer ao Bash para tratá-lo apenas como um caractere sem nenhum significado especial. Para fazer isso, escreva uma barra invertida antes desse caractere.

Vamos dizer que temos um arquivo chamado img \ 01 *DRAFT*, por exemplo. No Bash, poderíamos nos referir a ele desta maneira: 

img\ \\\ 01\ \*DRAFT\*

Aqui está uma lista não exaustiva de caracteres especiais no Bash:

• Whitespace: espaço, tabulação, linha em branco
• Aspas: ”, “”
• Parênteses, chaves e colchetes: ( ), { }, [ ]
• Tubos e redirecionamentos: |, <, >
• Coringas: *, ?
• Diversos: !, #, ;, =, &, ~, `
• O próprio caractere de escape: \

Se você é novo no Bash, no entanto, pode ser chato lembrar quais caracteres têm significado especial. Assim, em muitas situações, pode ser mais fácil usar uma citação literal: Basta cercar o texto que contém quaisquer caracteres especiais com aspas simples, e todos os caracteres especiais dentro dessas aspas serão ignorados.

Aqui está como ficaria para o nosso exemplo:

'img \ 01 *DRAFT*'

E se você quiser usar um caractere especial, mas escapar os outros? Você poderia escapar cada outro caractere usando uma barra invertida, mas também pode poupar o trabalho e cercar tudo exceto esse caractere especial com aspas literais.

Por exemplo, digamos que você tenha vários arquivos nomeados img \ 01 *v1 DRAFT*, img \ 01 *v2 DRAFT*, img \ 01 *ROUGH DRAFT*, etc., e deseja usar uma expansão de globo para corresponder a todos esses nomes de arquivo. Aqui está o que você poderia escrever:

'img \ 01 *'*' DRAFT*'

Se o que você precisa escrever contém uma única aspas — por exemplo, img \ 01 *’FINAL’* — você pode usar uma estratégia semelhante, combinando strings literais e escapando:

'img \ 01 '\''FINAL'\'

Como concatenar strings no Bash

Digamos que você tenha duas ou mais variáveis de string — um nome e sobrenome, por exemplo:

FIRST_NAME="Johnny"LAST_NAME="Appleseed"

Para combinar essas variáveis em uma única string, talvez com um delimitador personalizado, simplesmente crie uma nova string consistindo dessas duas variáveis:

NAME="$LAST_NAME"', '"$FIRST_NAME"

Você também pode usar aspas duplas com variáveis em linha para isso, usando chaves para separar os nomes das variáveis do texto circundante:

NAME="${LAST_NAME}, ${FIRST_NAME}"

O Bash também permite o uso do operador += para anexar texto a uma string, assim:

NAME='Appleseed'NAME+=', 'NAME+='Johnny'

Executando comandos dentro de uma string

Bash também permite que você use a saída de um comando dentro de uma string, também conhecido como substituição de comando. Basta cercar seu comando com $(). Por exemplo, para imprimir um carimbo de data/hora atual, você pode executar:

echo "Current timestamp: $(date)"

Você também pode se lembrar dessa sintaxe de um exemplo anterior de loop for, quando iteramos por uma sequência de inteiros de 0 a 9:

for i in $(seq 0 1 9)
do
    echo $i
done

O comando substituído é executado em um subshell. Isso significa que, por exemplo, quaisquer variáveis criadas durante o comando não afetarão o ambiente no qual você está executando seu script.

Configurando e retornando códigos de saída em um script de shell

Para um script mais complexo, é costume fazê-lo retornar um código de saída – um número entre 0 e 255 que informa às pessoas se o script foi executado com sucesso ou encontrou um erro.

Quanto aos números a serem utilizados, o manual oficial do Bash especifica estes:

• 0: Programa executado com sucesso.
• 2: Programa usado incorretamente (por exemplo, devido a argumentos inválidos ou ausentes).
• 1 e 3-124: Erros definidos pelo usuário.
• 126: Comando não é executável.
• 127: Comando não encontrado.
• 125 e 128-255: Status de erro que o shell usa. Se um processo é encerrado por um sinal N, o status de saída é 128 + N.

Como você pode ver, todos os números, exceto 0, indicam algum tipo de erro. O código de saída 1 é comumente usado para erros gerais. Na maioria dos casos, você não precisará usar nenhum código de saída acima de 2.

Para retornar um código de saída a partir do seu script, basta usar o comando exit. Por exemplo, para sair com um código 2, você escreveria exit 2.

Se você não usa o comando exit no seu script ou usa o comando sem especificar um código, o status de saída do último comando executado no seu script será retornado.

Para obter o código de saída do último comando executado no seu shell, use a variável $?: echo $?.

Como chamar uma função

Ao escrever um script mais longo ou um com trechos de código repetidos, você pode querer separar algum código em funções. Existem dois formatos que você pode usar para definir funções: Em ambos os casos, todo o código da função é contido dentro de chaves e apenas a declaração da função difere.

O formato mais compacto usa parênteses que seguem o nome da função para declarar uma função:

function_name () {
    echo "This is where your function code goes"
}

O outro formato usa a palavra-chave function à frente de um nome de função:

function function_name {
    echo "This is where your function code goes"
}

Funções devem ser declaradas antes de serem chamadas em seu script. Você chama uma função assim como executa um comando regular, usando o nome da função como o comando:

function_name

Passando dados para uma função usando variáveis

No Bash, funções não podem receber argumentos. Para enviar informações a uma função, você precisa usar variáveis globais em seu script.

Por exemplo:

is_your_name_defined () {
    if [ -z "$YOUR_NAME" ]
    then
        echo "It doesn't seem like I have your name."
    else
        echo "Is this your name: ${YOUR_NAME}?"
    fi
}
read -p "Your name: " YOUR_NAME

is_your_name_defined

Ao contrário do que você pode estar acostumado em outras linguagens, as variáveis que você define dentro da sua função são globais e visíveis ao código fora do seu script. Para definir uma variável com escopo local apenas para sua função (significando inacessível a todo código fora dela), use a palavra-chave local: por exemplo, local i=0.

Se deseja retornar valores de uma função, você também precisa usar variáveis globais. No Bash, funções só podem retornar códigos de saída, usando a palavra-chave return. Vamos ver um exemplo:

is_your_name_defined () {
    if [ -z "$YOUR_NAME" ]
    then
        MESSAGE="It doesn't seem like I have your name."
    else
        MESSAGE="Is this your name: ${YOUR_NAME}?"
    fi
}
read -p "Your name: " YOUR_NAME

is_your_name_defined

echo $MESSAGE

Resumo

O scripting Bash permite fazer muitas coisas em um sistema operacional baseado em UNIX. Este artigo abordou alguns conceitos básicos do scripting Bash, incluindo a criação e execução de scripts, trabalhando com strings e usando loops no seu código. Esperamos que isso sirva como um bom começo para sua jornada na escrita de scripts poderosos em Bash que atendam às suas necessidades.

Há muito mais para aprender sobre o Bash, incluindo alguns dos comandos mais úteis, navegação no sistema de arquivos e mais. Deixe-nos saber nos comentários quais tópicos devemos abordar em seguida.

Artigo Relacionado:

• Como Usar Chmod de Forma Recursiva para Alterar Permissões de Arquivos no Linux e macOS