Fonctions bash

Une fonction Bash est essentiellement un ensemble de commandes qui peuvent être appelées plusieurs fois. Le but d'une fonction est de vous aider à rendre vos scripts bash plus lisibles et d'éviter d'écrire le même code à plusieurs reprises. Comparées à la plupart des langages de programmation, les fonctions de Bash sont quelque peu limitées.

Dans ce didacticiel, nous couvrirons les bases des fonctions Bash et vous montrerons comment les utiliser dans vos scripts shell.

Définir les fonctions Bash #

La syntaxe pour déclarer une fonction bash est simple. Les fonctions peuvent être déclarées dans deux formats différents :

Le premier format commence par le nom de la fonction, suivi de parenthèses. C'est le format préféré et le plus utilisé.
```
function_name () {
  commands
}
```
Version sur une seule ligne :
```
function_name () { commands; }
```
Le deuxième format commence par le mot réservé function , suivi du nom de la fonction.
```
function function_name {
  commands
}
```
Version sur une seule ligne :
```
function function_name { commands; }
```

Quelques points à noter :

Les commandes entre les accolades ({} ) sont appelés le corps de la fonction. Les accolades doivent être séparées du corps par des espaces ou des retours à la ligne.
Définir une fonction ne l'exécute pas. Pour invoquer une fonction bash, utilisez simplement le nom de la fonction. Les commandes entre les accolades sont exécutées chaque fois que la fonction est appelée dans le script shell.
La définition de la fonction doit être placée avant tout appel à la fonction.
Lors de l'utilisation de fonctions "compactées" sur une seule ligne, un point-virgule ; doit suivre la dernière commande de la fonction.
Essayez toujours de garder vos noms de fonction descriptifs.

Pour mieux comprendre cela, jetez un oeil à l'exemple suivant :

~/hello_world.sh

#!/bin/bash

hello_world () {
   echo 'hello, world'
}

hello_world

Analysons le code ligne par ligne :

À la ligne 3, nous définissons la fonction en lui donnant un nom. L'accolade { marque le début du corps de la fonction.
Ligne 4 est le corps de la fonction. Le corps de la fonction peut contenir plusieurs commandes, instructions et déclarations de variables.
Ligne 5 , l'accolade fermante } , définit la fin du hello_world fonction.
En ligne 7 nous exécutons la fonction. Vous pouvez exécuter la fonction autant de fois que nécessaire.

Si vous exécutez le script, il affichera hello, world .

Portée des variables #

Les variables globales sont des variables accessibles depuis n'importe où dans le script, quelle que soit la portée. Dans Bash, toutes les variables par défaut sont définies comme globales, même si elles sont déclarées dans la fonction.

Les variables locales peuvent être déclarées dans le corps de la fonction avec le local mot-clé et ne peut être utilisé qu'à l'intérieur de cette fonction. Vous pouvez avoir des variables locales portant le même nom dans différentes fonctions.

Pour mieux illustrer le fonctionnement de la portée des variables dans Bash, considérons cet exemple :

~/variables_scope.sh

#!/bin/bash

var1='A'
var2='B'

my_function () {
  local var1='C'
  var2='D'
  echo "Inside function: var1: $var1, var2: $var2"
}

echo "Before executing function: var1: $var1, var2: $var2"

my_function

echo "After executing function: var1: $var1, var2: $var2"

Le script commence par définir deux variables globales var1 et var2 . Ensuite, il y a une fonction qui définit une variable locale var1 et modifie la variable globale var2 .

Si vous exécutez le script, vous devriez voir le résultat suivant :

Before executing function: var1: A, var2: B
Inside function: var1: C, var2: D
After executing function: var1: A, var2: D

D'après le résultat ci-dessus, nous pouvons conclure que :

Lorsqu'une variable locale est définie dans le corps de la fonction avec le même nom qu'une variable globale existante, elle aura priorité sur la variable globale.
Les variables globales peuvent être modifiées depuis la fonction.

Valeurs de retour #

Contrairement aux fonctions des "vrais" langages de programmation, les fonctions Bash ne vous permettent pas de renvoyer une valeur lorsqu'elles sont appelées. Lorsqu'une fonction bash se termine, sa valeur de retour est le statut de la dernière instruction exécutée dans la fonction, 0 en cas de succès et un nombre décimal différent de zéro dans la plage de 1 à 255 en cas d'échec.

Le statut de retour peut être spécifié en utilisant le return mot-clé, et il est affecté à la variable $? . Le return l'instruction termine la fonction. Vous pouvez le considérer comme le statut de sortie de la fonction.

~/return_values.sh

#!/bin/bash

my_function () {
  echo "some result"
  return 55
}

my_function
echo $?

some result
55

Pour réellement renvoyer une valeur arbitraire à partir d'une fonction, nous devons utiliser d'autres méthodes. L'option la plus simple est d'affecter le résultat de la fonction à une variable globale :

~/return_values.sh

#!/bin/bash

my_function () {
  func_result="some result"
}

my_function
echo $func_result

some result

Une autre meilleure option pour renvoyer une valeur à partir d'une fonction consiste à envoyer la valeur à stdout en utilisant echoou printf comme indiqué ci-dessous :

~/return_values.sh

#!/bin/bash

my_function () {
  local func_result="some result"
  echo "$func_result"
}

func_result="$(my_function)"
echo $func_result

some result

Au lieu de simplement exécuter la fonction qui imprimera le message sur stdout, nous attribuons la sortie de la fonction au func_result variable en utilisant le $() substitution de commande. La variable peut ensuite être utilisée selon les besoins.

Passer des arguments aux fonctions Bash #

Pour passer n'importe quel nombre d'arguments à la fonction bash, placez-les simplement après le nom de la fonction, séparés par un espace. Il est recommandé de mettre les arguments entre guillemets pour éviter la mauvaise analyse d'un argument contenant des espaces.

Les paramètres passés sont $1 , $2 , $3 … $n , correspondant à la position du paramètre après le nom de la fonction.
Le $0 variable est réservée au nom de la fonction.
Le $# variable contient le nombre de paramètres positionnels/arguments passés à la fonction.
Le $* et $@ les variables contiennent tous les paramètres/arguments positionnels passés à la fonction.
- Lorsqu'il est entre guillemets, "$*" se développe en une seule chaîne séparée par un espace (le premier caractère d'IFS) - "$1 $2 $n" .
- Lorsqu'il est entre guillemets, "$@" se développe pour séparer les chaînes - "$1" "$2" "$n" .
- Lorsqu'il n'y a pas de guillemets doubles, $* et $@ sont les mêmes.

Voici un exemple :

~/passing_arguments.sh

#!/bin/bash

greeting () {
  echo "Hello $1"
}

greeting "Joe"

Hello Joe

Conclusion #

Une fonction Bash est un bloc de code réutilisable conçu pour effectuer une opération particulière. Une fois définie, la fonction peut être appelée plusieurs fois dans un script.

Vous pouvez également lire comment utiliser une fonction Bash pour créer une commande de raccourci mémorable pour une commande plus longue.

Si vous avez des questions ou des commentaires, n'hésitez pas à laisser un commentaire.