Um Guia Simples para Scripting de Shell Linux Com Bash

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

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

Independentemente do sistema operacional, 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 configurações do sistema, e muitas outras tarefas que poderiam ser executadas por meio de simples comandos.

O que você precisa para aprender a criar scripts de shell em Bash

Para escrever e executar um script em 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.
• Bash mesmo.

O emulador de terminal é onde você digitará comandos e executará apertando Enter ou Return. Quanto ao Bash, se você o tiver pré-instalado depende da sua plataforma:

• No macOS, o Bash está pré-instalado. Nas versões mais recentes, a Shell Z (zsh) é a shell padrão, e é bom assim. desde que o Bash esteja instalado, você pode executar scripts Bash a partir de zsh também.
• Linux distribuições geralmente têm o Bash instalado. (Você pode verificar se o seu sistema inclui o arquivo /bin/bash.) O Android é um caso especial que não vem com o Bash. Existem passos para obter o Bash no Android, o que este artigo não abordará.
• Windows não vem com o Bash incluído. 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 oferecem muita potência, mas o Bash 3 e 4 ambos introduzem notações abreviadas 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 de usuário gráfica (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 composta por 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 shell Unix livre e popular pré-instalado na maioria das distribuições Linux e no macOS.

O que é um script de shell?

Shells têm sua própria linguagem de programação. Você usa essa linguagem para enviar comandos ao 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 irá abordar o básico da criação de scripts de shell para criar este arquivo.

Scripting básico do shell

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

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

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

Para testar esse processo, crie um arquivo chamado ‘hello_world’ no diretório de sua home:

#!/bin/bash
echo "hello world"

É isso — você criou um script Bash!

Antes de executá-lo, provavelmente você precisará alterar as permissões do arquivo.

Definindo permissões para executar um shell script usando chmod

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

chmod u+x 'hello_world'

Se você deseja apenas executar seu script de shell, pode pular para a próxima seção. Para aqueles curiosos sobre o comando chmod, chmod é a abreviação de “change mode”, e serve para alterar os “modos” de arquivo (ou permissões) no Unix. Nos sistemas operacionais semelhantes ao Unix, você pode definir permissões de arquivos 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 possui 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 no chmod é uma combinação desses 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' dará ao proprietário 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. Também existe uma forma mais complicada, porém menos verbosa, de definir esses modos (a “notação numérica”), assim como um comando diferente que você pode usar para ver quais permissões seus arquivos possuem (ls -l). Não vamos entrar nesses tópicos aqui.

Executando um script de shell

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

./hello_world

Você pode usar o caminho relativo ou absoluto. Ao usar o caminho relativo, sempre utilize ./ no início do comando: Isso indica ao terminal para procurar na pasta atual (representada por '.'), ao invés 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 de Bash é considerado um comentário. Isso pode ser útil para comunicar o que uma linha complexa faz ou dar uma descrição 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: VARIABLENAME='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 envolver 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 interpretar 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 sinal de dólar: $VARIABLENAME.

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

#!/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 isso:

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

Agora, execute esse script com esses parâmetros:

./hello_world bash script

A saída deve ser hello bash world, com o primeiro parâmetro utilizado e o segundo ignorado.

Se você desejar que bash script seja considerado como um único parâmetro, você precisará colocá-lo entre aspas: 

./hello_world 'bash script'

Usando o comando if para executar código condicionalmente

Uma das coisas essenciais que os programadores desejam fazer dentro de um script é executar um trecho de código apenas se uma determinada condição for atendida. O Bash possui o comando 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 fazem parte de um script maior e omitem o #!/bin/bash no início. No entanto, não se esqueça de incluí-lo como a primeira linha do seu script!

Você também pode usar else dentro de um comandoif para especificar o que fazer se uma condição não for atendida, ou um elif (abreviação de “else if“) para especificar outra condição se a primeira condição não foi 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 o comando if.

Dica: Se você não tem certeza de como escrever a condição em si, pesquise sobre a notação do teste, colchetes simples ([]) e parênteses duplos ((())).

Repetindo uma série de comandos usando um loop for

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

O for loop é perfeito para essa tarefa — especialmente sua “sintaxe de três expressões”. A ideia por trás disso é atribuir uma variável específica do loop e alterá-la gradativamente até que uma certa condição seja atendida. Aqui está 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 for loop 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.

Navegando 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 for loop. Essa sintaxe alternativa é usada para iterar através de 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 $() é utilizada para substituição de comando em geral — executa um comando e sua saída é usada como entrada para o comando pai que o envolve.

Se estiver iterando por números inteiros, é melhor usar a sintaxe de intervalo embutida no 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ê pode iterar por strings também: 

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

Usando glob 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 por arquivos individuais.

Para lidar com isso, precisamos abordar os chamados “expansões de glob” primeiro. Essa é uma funcionalidade no Bash que permite especificar nomes de arquivos usando correspondência de padrões. Existem caracteres especiais chamados wildcards que você usa para definir esses padrões.

Antes de aprofundar nisso, 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 de quatro letras no seu diretório atual.

Os wildcards que usamos foram * e ? aqui. Existe mais um wildcard que não usamos. 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 habilitado executando shopt -s globstar.
• 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 encontraria arquivos com nomes como 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 glob.

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 desses 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, bem como em seus subdiretórios, verifique se você está executando o Bash 4.0 ou superior, executando o comando bash --version, e então você pode executar o seguinte comando:

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

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

Estas 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 é executado enquanto uma condição específica é verdadeira.

A sintaxe é semelhante à sintaxe do loop for:

while CONDITION
do
    COMMANDS
done

Para um exemplo prático, é assim que você poderia ler um arquivo linha por linha (exceto espaços em branco iniciais ou finais) até atingir o 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, ele pode ser bastante útil, especialmente quando combinado com a declaração break.

Interrompendo 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 por todas as combinações de palavras de quatro letras até encontrar 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 pulamos todas as palavras com Es em nossa lista de palavras de quatro letras encurtada:

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 poderíamos 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 entrada do usuário em um script de shell

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

Para obter a entrada do usuário e salvá-la em uma variável chamada NAME, 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, no entanto, você desejará solicitar ao usuário para que ele saiba o que digitar. Você faz isso com o argumento -p, após o qual você escreve 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á vários caracteres no Bash que você precisa ter cuidado ao usar. Por exemplo, espaços dentro de nomes de arquivos, aspas dentro de strings ou barras invertidas em praticamente qualquer lugar.

Para dizer ao Bash para ignorar o significado especial desses caracteres 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 como apenas 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 dessa maneira: 

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

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

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

Se você é novo no Bash, pode ser um incômodo lembrar quais caracteres têm significado especial. Como tal, em muitas situações, pode ser mais fácil usar uma citação literal: Basta envolver o texto contendo 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 se poupar o problema e cercar tudo exceto aquele caractere especial com aspas literais.

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

'img \ 01 *'*' DRAFT*'

Se o que você precisa escrever contém uma única aspa – 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 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 embutidas 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

O 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. Simplesmente envolva o 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 desta 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 shell

Para um script mais complexo, é comum tê-lo retornando 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 usados, 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: Estados de erro que o shell utiliza. Se um processo é interrompido 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 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 usar o comando exit em seu script ou usar o comando sem especificar um código, o status de saída do último comando executado em seu script será retornado.

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

Como chamar uma função

Ao escrever um script mais longo ou um com pedaços repetidos de código, você pode querer separar parte do 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 entre 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 na frente do nome da função:

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

As funções devem ser declaradas antes de serem chamadas no seu script. Você chama uma função de forma semelhante a 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 aceitar argumentos. Para enviar informações para uma função, você precisa usar variáveis globais no 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

A diferença de outras linguagens, as variáveis que você define dentro de sua função são globais e visíveis para o código fora do script. Para definir uma variável com escopo local apenas para a sua função (significando inacessível para todo o código fora dela), use a palavra-chavelocal: por exemplo,local i=0.

Se você quiser retornar valores de uma função, você também precisa usar variáveis globais. No Bash, as funções só podem retornar códigos de saída, usando a palavra-chavereturn. Vamos olhar para 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

Summary

A scripting Bash permite que você faça muito com o sistema operacional baseado em UNIX. Este artigo tocou em alguns dos fundamentos de scripting Bash, incluindo a criação e execução de scripts, trabalhando com strings e usando laços em seu código. Esperamos que isso serve como um bom início para sua jornada no escritor de poderosos scripts Bash que atendam a seus necessidades.

Há muito mais para aprender sobre Bash, porém, incluindo algumas das ferramentas mais úteis, navegação no sistema de arquivos e mais. Conte comentários em que tópicos devemos abordar em seguida.

Artigo Relacionado:

• Como usar Chmod Recursivo para Alterar Permissões de Arquivo no Linux e macOS