Esta postagem 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 que você torne seu código mais estrutural, e as variáveis locais ajudam na segurança e evitam erros de codificação. Mergulhe!
Quais são Funções Bash?
Da mesma forma que outras linguagens de codificação, O Bash permite que você crie funções a partir do seu código ou script. Uma função pode ser definida para realizar uma tarefa específica, ou um conjunto de tarefas, y se puede llamar fácil y rápidamente desde su código principal simplemente usando el nombre dado a la función.
Además puede anidar llamadas a funciones (llamar a una función desde dentro de otra función), utilizar variables locales dentro de la función e inclusive pasar variables de un lado a otro con funciones, o a través de el uso de variables globales. Vamos a explorar.
Función de golpe simple
Definimos un test.sh con nuestro editor de texto, na próxima maneira:
#!/bin/bash welcome(){ eco "welcome" } welcome
Subseqüentemente, hacemos que ese archivo sea ejecutable agregando la ejecución (x) propiedad y ejecute el script:
chmod +x test.sh
./test.sh
Podemos ver cómo el script establece primero un welcome() función usando los modismos de Bash function_name(), e {…} envoltorios de funciones. Em conclusão, llamamos bienvenida a la función simplemente usando su nombre, welcome.
Cuando se ejecuta el script, lo que sucede en segundo plano es que se anota la definición de la función, pero se omite (Em outras palavras, no se ejecuta), hasta que un poco más baja la llamada a la función. welcome es golpeado, y en qué punto el intérprete de Bash ejecuta el welcome function y regresa a la línea de forma directa después de la llamada a la función, que para este caso es el final de nuestro script.
Pasando variables a funciones Bash
Definimos un test2.sh con nuestro editor de texto favorito (nós;), na próxima maneira:
#!/bin/bash if [ -Com "${1}" ]; then echo "One option required!" saída 1 fi func1(){ eco "${1}" } func2(){ eco "${2} ${1}" } func1 "${1}" func2 "uma" "b"
Nuevamente hacemos que nuestro script sea ejecutable usando chmod +x test2.sh y ejecutar lo mismo.
O resultado resultante pode parecer interessante ou até mesmo confuso no início.. Apesar disto, é lógico e fácil de seguir. A primeira opção passada para o script será, globalmente, disponível a partir de código como ${1}, exceto funções internas, Onde ${1} torna-se o primeiro parâmetro passado para a função, ${2} o segundo, etc.
Em outras palavras, o global ${1} variável (a primeira opção passada para o script a partir da linha de comando) não habilitado nas funções, onde o significado do ${1} A variável muda para a primeira opção passada para a função. Pense sobre a hierarquia ou como uma função poderia apresentar um pequeno script por conta própria e isso logo fará sentido.
Como uma nota rodapé, também poderia ser usado $1 ao invés de ${1}, mas eu recomendo altamente programadores de bash aspirantes a sempre cercar nomes de variáveis com { e }.
A razão é que às vezes, ao usar variáveis em uma string, como um exemplo, o executor de bash não pode Assistir onde uma variável termina e parte do texto anexado pode ser considerada como parte do nome da variável onde não é, que gera uma saída inesperada. Também é mais limpo e claro qual é a intenção, especialmente quando se trata de arrays e sinalizadores alternativos especiais.
Por tanto, começamos nosso programa com o ${1} variável definida para "first". Se você olhar para a vocação de func1, você verá que passamos essa variável para a função, então o ${1} dentro da função torna-se o que estava no ${1} do programa, Em outras palavras "first", e é por isso que a primeira linha de saída é, na verdade, first.
Então ligamos func2 e passamos dois tópicos "a" e "b" para a função. Mais tarde, estes se tornam o ${1} e ${2} automaticamente dentro do func2 Função. Função interna, nós os imprimimos de cabeça para baixo, e nossa saída combina muito bem com b a como a segunda linha de partida.
Em conclusão, também fazemos uma verificação no topo do nosso script para garantir que uma opção seja realmente passada para o test2.sh script verificando se "${1}" está vazio ou não usa o -z teste dentro if comando. Saímos do script com um código de saída diferente de zero (exit 1) para indicar aos programas de chamada que algo deu errado.
Variables locales y valores de retorno
Para nosso exemplo final, definimos un script test3.sh de la próxima manera:
#!/bin/bash func3(){ local REVERSE="$(eco "${1}" | rev)" eco "${REVERSE}" } INPUT="abc" REVERSE="$(func3 "${ENTRADA}")" eco "${REVERSE}"
De nuevo lo hacemos ejecutable y ejecutamos el script. La salida es cba como se puede esperar escaneando el código y anotando los nombres de las variables, etc.
Apesar disto, el código es complejo y lleva un poco acostumbrarse. Vamos a explorar.
Primeiro, definimos una función func3 en el que creamos una variable local llamada REVERSE. Atribuímos um valor a ele chamando uma subcamada ($()), e de dentro desta subcamada nós ecoamos o que foi passado para a função (${1}) e canalizar esta saída para rev comando.
a rev O comando imprime a entrada recebida do tubo (de outro modo) ao contrário. Também é interessante notar aqui que o ${1} A variável permanece dentro do subshell! É passado integralmente.
A seguir, ainda de dentro func3 Função, nós imprimimos a saída. Apesar disto, esta saída não será enviada para a tela, em vez disso, será capturado por nossa chamada de função e, por isso, armazenado dentro do 'global’ REVERSE variável.
Estabelecemos nossa entrada em "abc", Ligar para func3 trabalhe novamente de dentro de uma subcamada, passando o INPUT variável, e atribuir a saída para REVERSE variável. Observe que não há absolutamente nenhuma conexão entre o 'global’ REVERSE variável e local REVERSE variável dentro del script.
Considerando que qualquer variável global, incluindo qualquer REVERTER será passado para a função, assim que uma variável local com o mesmo nome for definida, a variável local será usada. Também podemos tentar ver este outro pequeno script test4.sh:
#!/bin/bash func3(){ local REVERSE="$(eco "${1}" | rev)" eco "${REVERSE}" } INPUT="abc" REVERSE="teste" func3 "${ENTRADA}" eco "${REVERSE}"
Quando você corre, a saída é cba e test. a cba este tempo é gerado pelo mesmo echo "${REVERSE}" Dentro de func3 Função, mas desta vez é emitido diretamente em vez de capturado no código abaixo, como o func3 "${INPUT}" A função não é chamada de dentro de uma subcamada.
Este script destaca dois pontos de aprendizagem que abordamos anteriormente: em primeiro lugar, naquela, mesmo quando estabelecemos o REVERSE variável a "test" dentro do script antes de chamar o func3 Função – que o local variável REVERSE Assuma o controle e use-o em seu lugar 'global’ 1.
Em segundo lugar, do que o nosso 'global’ REVERSE a variável retém seu valor, embora houvesse um local variável com o mesmo nome usado na função chamada func3.
Final
Como você pode ver, as funções bash, passando 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 oportunidade de estabelecer um código bem estruturado.
Além disso, é digno de nota aqui que, enquanto melhora a legibilidade do código e facilidade de uso, usar variáveis locais fornece segurança adicional, uma vez que as variáveis não estarão acessíveis fora do contexto de uma função, etc. Desfrute de variáveis e funções locais enquanto codifica no Bash!!
Se você estiver interessado em aprender mais sobre o Bash, consulte Como analisar nomes de arquivo corretamente no Bash e Usando xargs em combinação com bash -c para criar comandos complexos.
