Fonctions Bash et variables locales –

Cet article montre comment les fonctions de variables locales sont utilisées et créées dans Bash. La création de fonctions Bash vous permet de rendre votre code plus structurel, et les variables locales contribuent à la sécurité et évitent les erreurs de codage. Plonger!

Que sont Fonctions Bash?

Comme d’autres langages de codage, Bash vous permet de créer des fonctions à partir de votre code ou script. Une fonction peut être définie pour effectuer une tâche spécifique, ou un ensemble de tâches, et peut être appelée facilement et facilement à partir de votre code principal en utilisant simplement le nom donné à la fonction.

Vous pouvez également imbriquer des appels de fonction (appeler une fonction à partir d’une autre fonction), utiliser des variables locales dans la fonction et même passer des variables dans les deux sens avec des fonctions, ou via l’utilisation de variables globales. Explorons.

Fonction Bash simple

Nous définissons un test.sh avec notre éditeur de texte, comme suit:

#!/bin/bash

welcome(){
echo "welcome"
}

welcome

Par la suite, nous rendons ce fichier exécutable en ajoutant la commande execute (x) et exécutez le script:

chmod +x test.sh
./test.sh

Nous pouvons voir comment le script définit d’abord un welcome() fonction utilisant les idiomes Bash function_name(), et {…} wrappers de fonction. Enfin, nous appelons la fonction welcome en utilisant simplement son nom, welcome.

Lorsque le script est exécuté, ce qui se passe en arrière-plan, c’est que la définition de la fonction est notée, mais ignorée (c’est-à-dire non exécutée), jusqu’à ce qu’un peu plus bas l’appel de la fonction welcome est atteint, et à quel point l’interpréteur Bash exécute le welcome et retourne à la ligne directement après les appels de fonction par la suite, ce qui dans ce cas est la fin de notre script.

Passer des variables aux fonctions Bash

Nous définissons un test2.sh avec notre éditeur de texte préféré (vi;), comme suit:

#!/bin/bash

if [ -z "${1}" ]; then 
  echo "One option required!"
  exit 1
fi

func1(){
  echo "${1}"
}

func2(){
  echo "${2} ${1}"
}

func1 "${1}"
func2 "a" "b"

Nous rendons à nouveau notre script exécutable en utilisant chmod +x test2.sh et exécutez la même chose.

La sortie résultante peut sembler intéressante, voire déroutante au début. Cependant, c’est logique et facile à suivre. La première option passée au script sera, globalement, disponible à partir du code comme ${1}, sauf les fonctions internes, où ${1} devient le premier paramètre passé à la fonction, ${2} le second etc.

En d’autres termes, le global ${1} variable (la première option transmise au script à partir de la ligne de commande) n’est pas disponible à partir des fonctions, où la signification du ${1} variable passe à la première option transmise à la fonction. Pensez à la hiérarchie, ou pensez à la façon dont une fonction pourrait présenter un petit script par elle-même et cela aura bientôt du sens.

En guise de remarque, on pourrait également utiliser $1 au lieu de ${1}, mais j’encourage fortement les futurs codeurs Bash à toujours entourer les noms de variables avec { et }.

La raison en est que parfois, lors de l’utilisation de variables dans une chaîne par exemple, l’interpréteur Bash n’est pas en mesure de voir où une variable se termine et une partie du texte adjacent peut être considérée comme faisant partie du nom de la variable là où elle n’est pas, conduisant à une sortie inattendue. L’intention est également plus claire et plus claire, en particulier en ce qui concerne les tableaux et les indicateurs d’options spéciales.

Nous commençons ainsi notre programme avec le global ${1} variable définie sur "first". Si vous regardez l’appel de func1, vous verrez que nous passons cette variable sur la fonction, donc le ${1} à l’intérieur de la fonction devient ce qui était dans le ${1} du programme, c’est-à-dire "first", et c’est pourquoi la première ligne de sortie est en effet first.

Nous appelons alors func2 et on passe deux cordes "a" et "b" à la fonction. Ceux-ci deviennent alors le ${1} et ${2} automatiquement à l’intérieur du func2 fonction. À l’intérieur de la fonction, nous les imprimons à l’envers, et notre sortie correspond bien avec b a comme deuxième ligne de sortie.

Enfin, nous effectuons également une vérification en haut de notre script qui garantit qu’une option est effectivement passée au test2.sh script en vérifiant si "${1}" est vide ou n’utilise pas le -z tester à l’intérieur du if commander. Nous quittons le script avec un code de sortie non nul (exit 1) pour indiquer à tout programme appelant que quelque chose ne va pas.

Variables locales et valeurs renvoyées

Pour notre dernier exemple, nous définissons un script test3.sh comme suit:

#!/bin/bash

func3(){
  local REVERSE="$(echo "${1}" | rev)"
  echo "${REVERSE}"
}

INPUT="abc"
REVERSE="$(func3 "${INPUT}")"
echo "${REVERSE}"

Nous le rendons à nouveau exécutable et exécutons le script. La sortie est cba comme on peut s’y attendre en parcourant le code et en notant les noms de variables, etc.

Cependant, le code est complexe et prend un peu de temps pour s’y habituer. Explorons.

Tout d’abord, nous définissons une fonction func3 dans lequel nous créons une variable locale nommée REVERSE. Nous lui attribuons une valeur en appelant un sous-shell ($()), et à partir de ce sous-shell, nous faisons écho à tout ce qui a été passé à la fonction (${1}) et dirigez cette sortie vers le rev commander.

le rev La commande imprime l’entrée reçue du tube (ou autrement) à l’envers. Il est également intéressant de noter ici que le ${1} la variable reste à l’intérieur du sous-shell! C’est passé intégralement.

Ensuite, toujours de l’intérieur du func3 fonction, nous imprimons la sortie. Cependant, cette sortie ne sera pas envoyée à l’écran, elle sera plutôt capturée par notre appel de fonction lui-même et donc stockée dans le ‘global’ REVERSE variable.

Nous mettons notre contribution à "abc", appeler le func3 fonctionner à nouveau à partir d’un sous-shell, en passant le INPUT variable et affectez la sortie à la REVERSE variable. Notez qu’il n’y a absolument aucun lien entre le ‘global’ REVERSE variable et la local REVERSE variable à l’intérieur du script.

Alors que toute variable globale, y compris INVERSER sera passée à la fonction, dès qu’une variable locale est définie avec le même nom, la variable locale sera utilisée. Nous pouvons également prouver et voir cet autre petit script test4.sh:

#!/bin/bash

func3(){
  local REVERSE="$(echo "${1}" | rev)"
  echo "${REVERSE}"
}

INPUT="abc"
REVERSE="test"
func3 "${INPUT}"
echo "${REVERSE}"

Lorsqu’elle est exécutée, la sortie est cba et test. le cba est ce temps généré par le même echo "${REVERSE}" à l’intérieur de func3 fonction, mais cette heure est-elle sortie directement au lieu d’être capturée dans le code ci-dessous en tant que func3 "${INPUT}" La fonction n’est pas appelée à partir d’un sous-shell.

Ce script met en évidence deux points d’apprentissage que nous avons abordés précédemment: premièrement, que – même si nous définissons le REVERSE variable à "test" à l’intérieur du script avant d’appeler le func3 fonction – que le local variable REVERSE prend le relais et est utilisé à la place du ‘global’ une.

Deuxièmement, que notre ‘global’ REVERSE la variable conserve sa valeur même s’il y avait un local variable avec le même nom utilisé depuis la fonction appelée func3.

Emballer

Comme vous pouvez le voir, les fonctions Bash, le passage de variables, ainsi que l’utilisation de variables locales et semi-globales rendent le langage de script Bash polyvalent, facile à coder et vous donne la possibilité de définir du code bien structuré.

Il convient également de mentionner ici qu’en plus de la lisibilité améliorée du code et de la facilité d’utilisation, l’utilisation de variables locales offre une sécurité supplémentaire car les variables ne seront pas accessibles en dehors du contexte d’une fonction, etc. Profitez des fonctions et des variables locales lors du codage dans Bash!

Si vous souhaitez en savoir plus sur Bash, consultez nos Comment analyser correctement les noms de fichiers dans Bash et utiliser xargs en combinaison avec bash -c pour créer des commandes complexes.