Funções Bash e variáveis ​​locais

Shutterstock

Este artigo irá demonstrar como as funções de variáveis ​​locais são usadas e criadas no Bash. A criação de funções Bash permite tornar seu código mais estrutural, e as variáveis ​​locais ajudam com segurança e evitam erros de codificação. Mergulhe!

O que são funções Bash?

Assim como outras linguagens de codificação, o Bash permite que você crie funções a partir de seu código ou script. Uma função pode ser definida para realizar uma tarefa específica, ou conjunto de tarefas, e pode ser chamada fácil e prontamente de dentro de seu código principal simplesmente usando o nome dado à função.

Você também pode aninhar chamadas de função (chamar uma função de dentro de outra função), usar variáveis ​​locais dentro da função e até mesmo passar variáveis ​​para frente e para trás com funções ou por meio de variáveis ​​globais. Vamos explorar.

Função simples do Bash

Definimos um test. sh com nosso editor de texto, da seguinte maneira:

 #! / bin / bash bem-vindo () {echo "bem-vindo"} bem-vindo 

Posteriormente, tornamos esse arquivo executável adicionando a propriedade execute (x) e executamos o script:

 chmod + x test. sh ./test. sh 

Podemos ver como o script primeiro define uma função welcome () usando as expressões idiomáticas Bash function_name () e {…} wrappers de função. Por fim, chamamos a função welcome simplesmente usando seu nome, bem-vindo.

Quando o script é executado, o que acontece em segundo plano, é que a definição da função é observada, mas ignorada (ou seja, não executada), até que um pouco mais abaixo a chamada de função bem-vinda seja atingida, e em qual ponto o interpretador Bash executa o bem-vindo a função e retorna à linha diretamente após as chamadas de função, que neste caso é o fim do nosso script.

Passando variáveis ​​para funções Bash

Definimos test2. sh com nosso editor de texto favorito (vi;), como segue:

 #! / bin / bash if [-z "$"]; em seguida, echo "Uma opção necessária!" saída 1 fi func1 () {echo "$"} func2 () {echo "$"} func1 "$" func2 "a" "b" 

Tornamos nosso script executável novamente usando chmod + x test2. sh e executamos o mesmo.

A saída resultante pode parecer interessante ou até mesmo confusa no início. No entanto, é lógico e fácil de seguir. A primeira opção passada ao script estará, globalmente, disponível no código como $, exceto dentro das funções, onde $ se torna o primeiro parâmetro passado para a função, $ o segundo, etc.

Em outras palavras, a variável $ global (a primeira opção passada para o script na linha de comando) não está disponível nas funções, onde o significado da variável $ muda para a primeira opção passada para a função. Pense em hierarquia ou pense em como uma função poderia apresentar um pequeno script por si só e isso logo fará sentido.

Como nota lateral, também se pode usar $ 1 em vez de $, mas eu recomendo fortemente que os aspirantes a programadores Bash sempre cercem os nomes das variáveis ​​com {e}.

A razão é que às vezes, ao usar variáveis ​​em uma string, por exemplo, o interpretador Bash não é capaz de ver onde uma variável termina e parte do texto adjacente pode ser considerado parte do nome da variável, onde não é , levando a uma saída inesperada. Também é mais claro e claro qual é a intenção, especialmente quando se trata de arrays e sinalizadores de opção especial.

Assim, iniciamos nosso programa com a variável global $ definida como "primeiro". Se você olhar para a chamada de func1, verá que passamos essa variável para a função, portanto, o $ dentro da função se torna o que quer que estivesse no $ do programa, ou seja, "primeiro", e é por isso que a primeira linha de saída é realmente o primeiro.

Em seguida, chamamos func2 e passamos duas strings "a" e "b" para a função. Eles então se tornam $ e $ automaticamente dentro da função func2. Dentro da função, nós os imprimimos ao contrário, e nossa saída combina muito bem com b a como a segunda linha de saída.

Finalmente, também fazemos uma verificação no topo do nosso script que garante que uma opção seja realmente passada para o script test2. sh verificando se "$" está vazio ou não usando o teste -z dentro do comando if. Saímos do script com um código de saída diferente de zero (saída 1) para indicar a qualquer programa de chamada que algo deu errado.

Variáveis ​​locais e valores de retorno

Para nosso exemplo final, definimos um script test3. sh da seguinte maneira:

 #! / bin / bash func3 () {local REVERSE = "$ (echo" $ "| rev)" echo "$"} INPUT = "abc" REVERSE = "$ (func3" $ ") "echo" $ "

Tornamos novamente executável e executamos o script. A saída é cba como pode ser esperado, examinando o código e observando os nomes das variáveis, etc.

No entanto, o código é complexo e demora um pouco para se acostumar. Vamos explorar.

Primeiro, definimos uma função func3 na qual criamos uma variável local chamada REVERSE. Atribuímos um valor a ele chamando um subshell ($ ()), e de dentro deste subshell ecoamos tudo o que foi passado para a função ($) e canalizamos essa saída para o comando rev.

O comando rev imprime a entrada recebida do tubo (ou de outra forma) ao contrário. Também interessante notar aqui é que a variável $ permanece dentro do subshell! É passado integralmente.

A seguir, ainda de dentro da função func3, imprimimos a saída. No entanto, essa saída não será enviada para a tela, ela será capturada pela própria chamada de função e, portanto, armazenada na variável REVERSE & # 8216; global ’.

Definimos nossa entrada como "abc", chamamos a função func3 novamente de dentro de um subshell, passando a variável INPUT, e atribuímos a saída à variável REVERSE. Observe que não há absolutamente nenhuma conexão entre a variável REVERSE & # 8216; global &’ e a variável REVERSE local dentro do script.

Embora qualquer variável global, incluindo qualquer REVERSE, seja passada para a função, assim que uma variável local for definida com o mesmo nome, a variável local será usada. Também podemos provar e ver este outro pequeno script test4. sh:

 #! / bin / bash func3 () {local REVERSE = "$ (echo" $ "| rev)" echo "$"} INPUT = "abc" REVERSE = "teste" func3 "$" echo "$" 

Quando executado, a saída é cba e test. O cba é, desta vez, gerado pelo mesmo eco "$" dentro da função func3, mas este tempo é gerado diretamente em vez de capturado no código abaixo, pois a função func3 "$" não é chamada de dentro de um subshell.

Este script destaca dois pontos de aprendizagem que abordamos anteriormente: em primeiro lugar, que – mesmo que definamos a variável REVERSE para "testar" dentro do script antes de chamar a função func3 – que a variável local REVERSE assume e é usada em vez de & # 8216; global &’ um.

Em segundo lugar, que nossa variável REVERSE & # 8216; global &’ retém seu valor, embora houvesse uma variável local com o mesmo nome usada dentro da função chamada func3.

Concluindo

Como você pode ver, as funções do Bash, a passagem de variáveis, bem como o uso de variáveis ​​locais e semi-globais tornam a linguagem de script Bash versátil, fácil de codificar e oferece a possibilidade de definir um código bem estruturado.

Também vale a pena mencionar aqui que além da legibilidade do código melhorada e fácil de usar, o uso de variáveis ​​locais fornece segurança adicional, pois as variáveis ​​não serão acessíveis fora do contexto de uma função, etc. Desfrute de funções e variáveis ​​locais enquanto codifica em Bash!

Se você estiver interessado em aprender mais sobre o Bash, consulte Como analisar corretamente os nomes dos arquivos no Bash e como usar xargs em combinação com bash -c para criar comandos complexos .