Script Shell Partie V : Fonctions en Bash

Salut ! Bienvenue dans la série de tutoriels sur le script shell de HowToForge. Si vous souhaitez lire les précédentes publications du tutoriel, n’hésitez pas à cliquer ici pour la partie1, partie2, partie3 et partie4 du tutoriel. Dans cette partie, vous apprendrez à structurer efficacement vos scripts en créant des fonctions. À la fin de ce tutoriel, vous saurez comment créer des fonctions dans le Shell Bash de Linux, passer des paramètres à vos fonctions et retourner des valeurs d’une fonction à votre code principal. Commençons !

Introduction

Une fonction, également connue sous le nom de sous-programme dans les langages de programmation, est un ensemble d’instructions qui effectue une tâche spécifique pour une routine principale [1]. Elle permet aux programmeurs de diviser un code compliqué et long en petites sections qui peuvent être appelées chaque fois que nécessaire. Chaque fonction doit être appelée par une routine principale pour s’exécuter, ainsi, elle est isolée des autres parties de votre code et cela crée un moyen facile de tester le code. De plus, les fonctions peuvent être appelées à tout moment et de manière répétée, ce qui vous permet de réutiliser, d’optimiser et de minimiser votre code. Comme la plupart des langages de programmation, le shell bash prend également en charge les fonctions.

Syntaxe Générale :

1. Syntaxe 1 : function function_name { ##### ensemble de commandes }
2. Syntaxe 2 : function_name() { #### ensemble de commandes }

Création de Fonctions

Le bash prend en charge deux structures pour les fonctions. En utilisant la première syntaxe, vous devez utiliser le mot-clé function, suivi du nom de votre fonction et des parenthèses ouvertes et fermées ainsi que des accolades pour séparer le contenu de vos fonctions de votre routine principale. Vous trouverez cette syntaxe familière si vous avez des antécédents en PHP car les fonctions en PHP sont déclarées de la même manière. L’autre syntaxe ne consiste qu’en un nom de fonction, des parenthèses ouvertes et fermées et des accolades.

#!/bin/bash  
myfunction(){  
    echo "Ma fonction fonctionne !"  
}  
myfunction

J’ai utilisé la deuxième syntaxe dans notre exemple. Après avoir créé la fonction myfunction, elle a ensuite été invoquée en appelant son nom de fonction dans notre routine principale. La routine principale sera n’importe où dans notre script qui n’a pas été définie comme faisant partie de notre fonction.

Maintenant, réorganisons notre code pour tester si les fonctions peuvent être déclarées n’importe où dans notre script. Considérez le code ci-dessous :

#!/bin/bash  
echo "test de ma fonction"  
myfunction  
  
myfunction(){  
    echo "Ma fonction fonctionne !"  
}

La ligne 3 dans le code ci-dessus renvoie une erreur de commande non trouvée. Cela signifie seulement que :

La fonction ne fonctionne que si elle est déclarée avant votre routine principale. L'interpréteur renverra une erreur si vous avez déclaré votre fonction après votre routine principale.

Restructuration des codes en utilisant des fonctions

Une des meilleures caractéristiques des fonctions est la possibilité de réutiliser le code. Lorsqu’une procédure nécessite d’exécuter des commandes de manière répétée mais ne peut pas être structurée à l’aide d’instructions de boucle, alors une fonction peut être une solution.

Par exemple, considérez le code ci-dessous :

#!/bin/bash  
while(true)  
do  
    clear  
    printf "Choisissez parmi les opérations suivantes : \n"  
    printf "[a]ddition\n[b]Soustraction\n[c]Multiplication\n[d]Division\n"  
    printf "################################\n"  
    read -p "Votre choix : " choice  
    case $choice in  
    [aA])  
        read -p "Entrez le premier entier : " int1  
        read -p "Entrez le deuxième entier : " int2  
        res=$((int1+int2))  
   
    ;;  
    [bB])  
        read -p "Entrez le premier entier : " int1  
        read -p "Entrez le deuxième entier : " int2  
    res=$((int1-int2))  
   
    ;;  
    [cC])  
        read -p "Entrez le premier entier : " int1  
        read -p "Entrez le deuxième entier : " int2  
        res=$((int1*int2))  
   
    ;;  
    [dD])  
        read -p "Entrez le premier entier : " int1  
        read -p "Entrez le deuxième entier : " int2  
        res=$((int1/int2))  
   
    ;;  
    *)  
        res=0  
        echo "mauvais choix !"  
    esac  
  
    echo "Le résultat est : " $res  
    read -p "Souhaitez-vous continuer ? [o]ui ou [n]on : " ans  
    if [ $ans == 'n' ]  
        then  
         echo "Sortie du script. Passez une bonne journée !"  
        break  
    else  
        continue  
    fi  
  
done

Le script fonctionne bien, cependant, remarquez que les lignes pour accepter les entrées sont répétées dans chaque motif de notre instruction switch.

#!/bin/bash  
inputs(){  
     read -p "Entrez le premier entier : " int1  
    read -p "Entrez le deuxième entier : " int2  
}  
  
exitPrompt(){  
    read -p "Souhaitez-vous continuer ? [o]ui ou [n]on : " ans  
    if [ $ans == 'n' ]  
    then  
        echo "Sortie du script. Passez une bonne journée !"  
        break  
    else  
        continue  
    fi  
}  
  
while(true)  
    do  
    clear  
    printf "Choisissez parmi les opérations suivantes : \n"  
    printf "[a]Addition\n[b]Soustraction\n[c]Multiplication\n[d]Division\n"  
    printf "################################\n"  
    read -p "Votre choix : " 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 "mauvais choix !"  
    esac  
  
    echo "Le résultat est : " $res  
    exitPrompt  
done

Nous avons amélioré notre code en créant des sous-sections inputs et exitPrompt. Cela fonctionne exactement de la même manière que notre code précédent, cependant, notre code actuel est plus facile à dépanner car il est structuré correctement.

Passer des paramètres aux fonctions

Comme la plupart des langages de programmation, vous pouvez passer des paramètres et traiter ces données dans des fonctions en bash. Le code ci-dessous montre la procédure sur la façon de passer des valeurs dans le script shell :

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Bonjour" "Monde"

Remarquez dans notre exemple, nous avons ajouté les valeurs “Bonjour” et “Monde” après avoir appelé la myfunction. Ces valeurs sont passées à la myfunction comme paramètres et stockées dans une variable locale. Cependant, contrairement à d’autres langages, l’interpréteur stocke les valeurs passées dans des variables prédéfinies, qui sont nommées selon la séquence de passage des paramètres, 1 comme nom de départ jusqu’à l’ordre de passage. Remarquez que le mot “Bonjour” est stocké dans la variable 1 et la valeur “Monde” est stockée dans la variable 2.

Note : Les 1 et 2 dans notre exemple sont des variables locales et donc, ne sont pas accessibles à d’autres parties du script en dehors de la fonction où les paramètres sont passés.

Par exemple,

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Bonjour" "Monde"  
echo $1  
echo $2

Les echo $1 et echo $2 dans les deux dernières lignes de notre script n’ont pas d’affichage car l’interpréteur ne reconnaît pas les deux variables car elles sont toutes deux locales à la myfunction.

Retourner des valeurs des fonctions

En plus de créer des fonctions et de passer des paramètres à celles-ci, les fonctions bash peuvent passer les valeurs d’une variable locale d’une fonction à la routine principale en utilisant le mot-clé return. Les valeurs retournées sont ensuite stockées dans la variable par défaut $?. Par exemple, considérez le code suivant :

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    return $sum  
}  
  
read -p "Entrez un entier : " int1  
read -p "Entrez un entier : " int2  
add $int1 $int2  
echo "Le résultat est : " $?

Dans l’exemple, nous passons les paramètres int1 et int2 à la fonction add. Ensuite, la fonction add les traite à travers la ligne sum=$(($1+$2)). Ensuite, la valeur de la variable sum est passée à la routine principale à travers la ligne return $sum. Par défaut, les valeurs de $sum seront stockées dans la variable par défaut $?. Enfin, la ligne echo “Le résultat est : “ $? imprime le résultat.

Note : Les scripts shell ne peuvent retourner qu'une seule valeur.

Contrairement à d’autres langages de programmation, les scripts shell ne peuvent pas retourner plusieurs valeurs d’une fonction. Regardons cet exemple :

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    dif=$(($1-$2))  
    return $sum   
}  
  
read -p "Entrez un entier : " int1  
read -p "Entrez un entier : " int2  
add $int1 $int2  
echo "Le résultat est : " $?  
echo "Le résultat est : " $?

Pour résumer

Prenons un autre exemple qui utilise des fonctions, passe des paramètres à celles-ci et retourne une valeur.

#!/bin/bash  
#####################  
#Auteur : HowtoForge #  
#####################  
   
clear(){  
    clear  
}  
  
bin(){  
    bin1=$(echo "obase=2;$1"|bc)  
    echo $bin1  
}  
  
dec(){  
    dec1=$(echo "ibase=2;$1"|bc)  
    return $dec1  
}  
  
########Main#########  
    printf "Choisissez parmi les opérations suivantes :\n[1]Conversion Décimale en Binaire\n"  
    printf "[2]Conversion Binaire en Décimale\n"  
    read -p "Votre choix : " op  
    case $op in  
  
    1)  
        read -p "Entrez un nombre entier : " int  
        bin $int  
    ;;  
  
    2)  
        read -p "Entrez un nombre binaire : " int  
        dec $int  
        echo "L'équivalent décimal de $int est $?"  
    ;;  
  
    *)  
        echo "Mauvais Choix !"  
    esac

L’exemple donné convertit une entrée donnée en valeur binaire ou décimale en utilisant la commande obase et ibase. La ligne $(echo “obase=2;$1”|bc) convertit une valeur décimale donnée en chiffre binaire et la stocke dans la variable bin1. Ensuite, nous affichons la valeur de $bin1 en utilisant la commande echo.

Note : Il est préférable d'utiliser echo directement lors de la conversion de décimal à binaire car lorsque vous retournez une commande pour passer une valeur binaire, le bash convertit la valeur binaire en décimale avant de la retourner.

De plus, nous avons converti la valeur binaire en décimale en utilisant la commande $(echo “ibase=2;$1”|bc).

Vous devez également vous rappeler que l’interpréteur n’est capable d’accepter que des chiffres binaires de 8 bits. Si vous saisissez un chiffre qui dépasse la limite de 8 bits, cela générera un dépassement et le bit le plus significatif du chiffre sera rejeté.

Le chiffre binaire de 10 bits 1000001010 retourne 10 car suivant la règle des 8 bits, les 2 bits restants sur le côté droit (bit le plus significatif) seront omis, ainsi, 1000001010 deviendra égal à 00001010 qui est égal à 10. Si vous souhaitez une opération qui accepte des chiffres binaires dépassant 8 bits, alors vous devez créer le code manuellement.

Conclusion

Bash a des fonctionnalités très similaires aux langages de programmation pour fournir de nombreux outils à l’utilisateur et rendre les systèmes Linux plus puissants. Dans cette série, vous avez amélioré vos connaissances en script shell à travers les fonctions. Les fonctions dans les scripts shell fournissent de la modularité à l’utilisateur, rendant les scripts plus faciles à dépanner et permettant la réutilisation du code.

Référence :

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