Shell Scripting Parte V: Funções em Bash

Oi! Bem-vindo à série de tutoriais de shell scripting do HowToForge. Se você quiser ler as versões anteriores do tutorial, fique à vontade para clicar aqui para a parte1, parte2, parte3 e parte4 do tutorial. Nesta parte, você aprenderá como estruturar seus scripts de forma eficiente criando funções. Ao final deste tutorial, você saberá como criar funções no Shell Bash do Linux, passar parâmetros para suas funções e retornar alguns valores de uma função para seu código principal. Vamos começar!

Introdução

Uma função, também conhecida como sub-rotina em linguagens de programação, é um conjunto de instruções que executa uma tarefa específica para uma rotina principal [1]. Ela permite que os programadores dividam um código complicado e longo em pequenas seções que podem ser chamadas sempre que necessário. Cada função precisa ser chamada por uma rotina principal para ser executada, assim, ela é isolada de outras partes do seu código e isso cria uma maneira fácil de testar o código. Além disso, as funções podem ser chamadas a qualquer momento e repetidamente, permitindo que você reutilize, otimize e minimize seu código. Como na maioria das linguagens de programação, o shell bash também suporta funções.

Sintaxe Geral:

1. Sintaxe 1: function function_name { ##### conjunto de comandos }
2. Sintaxe 2: function_name() { #### conjunto de comandos }

Criando Funções

O bash suporta duas estruturas para funções. Ao usar a primeira sintaxe, você deve usar a palavra-chave function, seguida pelo nome da sua função e parênteses abertos e fechados e chaves para separar o conteúdo de suas funções da sua rotina principal. Você achará essa sintaxe familiar se tiver um histórico em PHP, pois as funções em PHP são declaradas da mesma forma. A outra sintaxe consiste apenas em um nome de função, parênteses abertos e fechados e chaves.

#!/bin/bash  
myfunction(){  
    echo "Minha função funciona!"  
}  
myfunction

Eu usei a segunda sintaxe em nosso exemplo. Após criar a função myfunction, ela foi invocada chamando seu nome de função para nossa rotina principal. A rotina principal será qualquer lugar em nosso script que não foi definido como parte de nossa função.

Agora vamos reorganizar nosso código para testar se as funções podem ser declaradas em qualquer lugar em nosso script. Considere o código abaixo:

#!/bin/bash  
echo "testando minha função"  
myfunction  
  
myfunction(){  
    echo "Minha função funciona!"  
}

A linha 3 do código acima retorna um erro de comando não encontrado. Isso significa apenas que:

A função só funciona se for declarada antes de sua rotina principal. O interpretador retornará um erro se você declarar sua função após sua rotina principal.

Reestruturando códigos usando funções

Uma das melhores características das funções é a capacidade de reutilizar códigos. Quando um procedimento requer a execução repetida de comandos, mas não pode ser estruturado usando declarações de loop, então uma função pode ser uma solução.

Por exemplo, considere o código abaixo:

#!/bin/bash  
while(true)  
do  
    clear  
    printf "Escolha entre as seguintes operações: \n"  
    printf "[a]ddição\n[b]Subtração\n[c]Multiplicação\n[d]Divisão\n"  
    printf "################################\n"  
    read -p "Sua escolha: " choice  
    case $choice in  
    [aA])  
        read -p "Digite o primeiro inteiro: " int1  
        read -p "Digite o segundo inteiro: " int2  
        res=$((int1+int2))  
   
    ;;  
    [bB])  
        read -p "Digite o primeiro inteiro: " int1  
        read -p "Digite o segundo inteiro: " int2  
    res=$((int1-int2))  
   
    ;;  
    [cC])  
        read -p "Digite o primeiro inteiro: " int1  
        read -p "Digite o segundo inteiro: " int2  
        res=$((int1*int2))  
   
    ;;  
    [dD])  
        read -p "Digite o primeiro inteiro: " int1  
        read -p "Digite o segundo inteiro: " int2  
        res=$((int1/int2))  
   
    ;;  
    *)  
        res=0  
        echo "escolha errada!"  
    esac  
  
    echo "O resultado é: " $res  
    read -p "Você deseja continuar? [s]im ou [n]ão: " ans  
    if [ $ans == 'n' ]  
        then  
         echo "Saindo do script. Tenha um bom dia!"  
        break  
    else  
        continue  
    fi  
  
done

O script está funcionando bem, no entanto, note que as linhas para aceitar entradas estão repetidamente feitas em cada padrão em nossa declaração switch.

#!/bin/bash  
inputs(){  
     read -p "Digite o primeiro inteiro: " int1  
    read -p "Digite o segundo inteiro: " int2  
}  
  
exitPrompt(){  
    read -p "Você deseja continuar? [s]im ou [n]ão: " ans  
    if [ $ans == 'n' ]  
    then  
        echo "Saindo do script. Tenha um bom dia!"  
        break  
    else  
        continue  
    fi  
}  
  
while(true)  
    do  
    clear  
    printf "Escolha entre as seguintes operações: \n"  
    printf "[a]Adição\n[b]Subtração\n[c]Multiplicação\n[d]Divisão\n"  
    printf "################################\n"  
    read -p "Sua escolha: " choice  
  
    case $choice in  
    [aA])  
        inputs  
        res=$((int1+int2))  
    ;;  
  
    [bB])  
        inputs  
        res=$((int1-int2))  
    ;;  
  
    [cC])  
        inputs  
        res=$((int1*int2))  
    ;;  
  
    [dD])  
        inputs  
        res=$((int1/int2))  
    ;;  
  
    *)  
        res=0  
        echo "escolha errada!"  
    esac  
  
    echo "O resultado é: " $res  
    exitPrompt  
done

Melhoramos nosso código criando subseções inputs e exitPrompt. Funciona exatamente da mesma forma que nosso código anterior, no entanto, nosso código atual é mais fácil de solucionar problemas porque está estruturado corretamente.

Passando parâmetros em funções

Como na maioria das linguagens de programação, você pode passar parâmetros e processar esses dados em funções no bash. O código abaixo mostra o procedimento sobre como passar valores em shell scripting:

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Olá" "Mundo"

Note em nosso exemplo, adicionamos os valores “Olá” e “Mundo” após chamarmos a myfunction. Esses valores são passados para a myfunction como parâmetros e armazenados em uma variável local. No entanto, ao contrário de outras linguagens, o interpretador armazena os valores passados em variáveis pré-definidas, que são nomeadas de acordo com a sequência de passagem dos parâmetros, 1 como o nome inicial até a ordem de passagem. Note que a palavra “Olá” é armazenada na variável 1 e o valor “Mundo” é armazenado na variável 2.

Nota: O 1 e 2 em nosso exemplo são variáveis locais e, portanto, não são acessíveis a outras partes do script, além da função onde os parâmetros estão sendo passados.

Por exemplo,

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Olá" "Mundo"  
echo $1  
echo $2

O echo $1 e echo $2 nas duas últimas linhas de nosso script não têm exibição, pois o interpretador não reconhece ambas as variáveis porque são locais à myfunction.

Retornando Valores de Funções

Além de criar funções e passar parâmetros para elas, funções bash podem passar os valores de uma variável local de uma função para a rotina principal usando a palavra-chave return. Os valores retornados são então armazenados na variável padrão $? Por exemplo, considere o seguinte código:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    return $sum  
}  
  
read -p "Digite um inteiro: " int1  
read -p "Digite um inteiro: " int2  
add $int1 $int2  
echo "O resultado é: " $?

No exemplo, passamos os parâmetros int1 e int2 para a função add. Em seguida, a função add processa isso através da linha sum=$(($1+$2)). Então o valor da variável sum é passado para a rotina principal através da linha return $sum. Por padrão, os valores de $sum serão armazenados na variável padrão $? Finalmente, a linha echo “O resultado é: “ $? imprime o resultado.

Nota: Scripts shell só podem retornar um único valor.

Ao contrário de outras linguagens de programação, scripts shell não podem retornar múltiplos valores de uma função. Vamos dar uma olhada neste exemplo:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    dif=$(($1-$2))  
    return $sum   
}  
  
read -p "Digite um inteiro: " int1  
read -p "Digite um inteiro: " int2  
add $int1 $int2  
echo "O resultado é: " $?  
echo "O resultado é: " $?

Para resumir

Vamos ter outro exemplo que usa funções, passa parâmetros para elas e retorna valores.

#!/bin/bash  
#####################  
#Autor: HowtoForge #  
#####################  
   
clear(){  
    clear  
}  
  
bin(){  
    bin1=$(echo "obase=2;$1"|bc)  
    echo $bin1  
}  
  
dec(){  
    dec1=$(echo "ibase=2;$1"|bc)  
    return $dec1  
}  
  
########Main#########  
    printf "Escolha entre as seguintes operações:\n[1]Conversão Decimal para Binário\n"  
    printf "[2]Conversão Binária para Decimal\n"  
    read -p "Sua escolha: " op  
    case $op in  
  
    1)  
        read -p "Digite um número inteiro: " int  
        bin $int  
    ;;  
  
    2)  
        read -p "Digite um número binário: " int  
        dec $int  
        echo "O equivalente decimal de $int é $?"  
    ;;  
  
    *)  
        echo "Escolha Errada!"  
    esac

O exemplo dado converte uma entrada dada em valor binário ou decimal usando o comando obase e ibase. A linha $(echo “obase=2;$1”|bc) converte um valor decimal dado em dígito binário e o armazena na variável bin1. Em seguida, exibimos o valor de $bin1 usando o comando echo.

Nota: É melhor usar echo diretamente ao converter de decimal para binário, porque quando você retorna um comando para passar um valor binário, o bash converte o valor binário em decimal antes de retorná-lo.

Além disso, também convertendo o valor binário em decimal usando o comando $(echo “ibase=2;$1”|bc).

Você também deve lembrar que o interpretador é capaz de aceitar apenas dígitos binários de 8 bits. Se você inserir um dígito que excede o limite de 8 bits, ele gerará um estouro e o bit mais significativo do dígito será descartado.

O dígito binário de 10 bits 1000001010 retorna 10, pois seguindo a regra de 8 bits, os 2 bits restantes no lado direito (bit mais significativo) serão omitidos, assim, 1000001010 se tornará igual a 00001010, que é igual a 10. Se você quiser uma operação que aceite dígitos binários que excedam 8 bits, então você terá que criar o código manualmente.

Conclusão

O Bash possui funcionalidades muito semelhantes às linguagens de programação para fornecer inúmeras ferramentas ao usuário e tornar os sistemas Linux mais poderosos. Nesta série, você aprimorou seu conhecimento em shell scripting através de funções. As funções em scripts shell proporcionam modularidade ao usuário, tornando os scripts mais fáceis de solucionar problemas e permitindo a reutilização de código.

Referência:

[1] American Heritage® Dictionary of the English Language, Fifth Edition. Copyright © 2011 by Houghton Mifflin Harcourt Publishing Company. Published by Houghton Mifflin Harcourt Publishing Company.