Salut! Bienvenue dans la série de didacticiels sur les scripts shell de HowToForge. Si vous souhaitez lire les versions précédentes du didacticiel, n'hésitez pas à cliquer ici pour la partie 1, la partie 2, la partie 3 et la partie 4 du didacticiel. Dans cette partie, vous apprendrez à structurer efficacement vos scripts en créant des fonctions. À la fin de ce didacticiel, vous saurez comment créer des fonctions dans Linux Bash Shell, transmettre des paramètres à vos fonctions et renvoyer certaines valeurs d'une fonction à votre code principal. Commençons !
Introduction
Une fonction, également appelée sous-routine dans les langages de programmation, est un ensemble d'instructions qui exécutent une tâche spécifique pour une routine principale [1]. Il permet aux programmeurs de décomposer un code long et compliqué 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, elle est donc isolée des autres parties de votre code, ce qui crée un moyen simple de tester le code. De plus, les fonctions peuvent être appelées à tout moment et à plusieurs reprises, ce qui vous permet de réutiliser, d'optimiser et de minimiser vos codes. Comme la plupart des langages de programmation, le shell bash prend également en charge les fonctions.
Syntaxe générale :
- Syntaxe 1 :
fonction nom_fonction
{
##### ensemble de commandes
} - Syntaxe 2 :
nom_fonction()
{
#### ensemble de commandes
}
Créer des 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 ouvrir et fermer des parenthèses et des accolades pour séparer le contenu de vos fonctions de votre routine principale. Vous trouverez cette syntaxe familière si vous avez une formation en PHP car les fonctions en PHP sont déclarées de la même manière. L'autre syntaxe consiste uniquement en un nom de fonction, des parenthèses ouvrantes et fermantes et des accolades.
#!/bin/bash
mafonction(){
echo "Ma fonction fonctionne !"
}
mafonction
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 à notre routine principale. La routine principale sera n'importe où dans notre script qui n'a pas été défini dans le cadre de notre fonction.
Réorganisons maintenant 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 "testing my function"
myfunction
myfunction(){
echo "Ma fonction fonctionne !"
}
La ligne 3 du code ci-dessus renvoie une erreur de commande introuvable. 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 à l'aide de fonctions
L'une des meilleures caractéristiques des fonctions est de pouvoir réutiliser les codes. Lorsqu'une procédure nécessite l'exécution répétée de commandes mais ne peut pas être structurée à l'aide d'instructions en boucle, 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 ]addition\n[b]Soustraction\n[c]Multiplication\n[d]Division\n"
printf "###################### ###########\n"
lire -p "Votre choix :" choix
cas $choix dans
[aA])
lire -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 ? [y]es or [n]o :" ans
if [ $ans =='n' ]
then
echo "Quitter le script. Bonne journée !"
pause
sinon
continuer
fi
terminé
Le script fonctionne bien, cependant, notez que les lignes d'acceptation des entrées sont répétées dans chaque modèle 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 ? [y]es or [n]o:" ans
if [ $ans =='n ' ]
puis
écho "Quitter le script. Bonne journée !"
pause
autrement
continuer
fi
}
while(true)
do
clear
printf "Choisissez parmi les opérations suivantes :\n"
printf "[a]Ajout\n[b] Soustraction\n[c]Multiplication\n[d]Division\n"
printf "############################# ####\n"
lire -p "Votre choix : " choix
cas $choix dans
[aA])
entrées
res =$((int1+int2))
;;
[bB])
entrées
res=$((int1-int2))
;;
[cC])
entrées
res=$((int1*int2))
;;
[dD] )
entrées
res=$((int1/int2))
;;
*)
res=0
écho "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 avec notre code précédent, cependant, notre code actuel est plus facile à dépanner car il est structuré correctement.
Passer des paramètres sur des fonctions
Comme la plupart des langages de programmation, vous pouvez transmettre des paramètres et traiter ces données dans des fonctions en bash. Le code ci-dessous montre la procédure de transmission des valeurs dans les scripts shell :
#!/bin/bash
myfunction(){
echo $1
echo $2
}
myfunction "Hello" "World"
Remarquez que dans notre exemple, nous avons ajouté les valeurs "Hello" et "World" après avoir appelé la fonction my. Ces valeurs sont transmises à la fonction myfunction en tant que paramètres et stockées dans une variable locale. Cependant, contrairement à d'autres langages, l'interpréteur stocke les valeurs transmises dans des variables prédéfinies, qui sont nommées en fonction de la séquence de transmission des paramètres, 1 comme nom de départ jusqu'à l'ordre de transmission. Notez que le mot "Hello" est stocké dans la variable 1 et la valeur "World" est stockée dans la variable 2.
Remarque :Les 1 et 2 dans notre exemple sont des variables locales et ne sont donc pas accessibles aux 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 "Hello" "World"
écho 1 $
écho 2 $
L'écho $1 et l'écho $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 les deux locales à la fonction myfunction.
Renvoyer des valeurs à partir de fonctions
En plus de créer des fonctions et de lui transmettre des paramètres, les fonctions bash peuvent transmettre les valeurs de la variable locale d'une fonction à la routine principale en utilisant le mot-clé return. Les valeurs renvoyé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 le traite via la ligne sum=$(($1+$2)). Ensuite, la valeur de la variable sum est transmise à la routine principale via 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.
Remarque :les scripts shell ne peuvent renvoyer qu'une seule valeur.Contrairement aux autres langages de programmation, les scripts shell ne peuvent pas renvoyer plusieurs valeurs à partir d'une fonction. Jetons un œil à cet exemple :
#!/bin/bash
add(){
sum=$(($1+$2))
dif=$(($1-$2))
retour $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, lui transmet des paramètres et renvoie une valeur.
#!/bin/bash
#####################
#Auteur :HowtoForge #
### ##################
clear(){
clear
}
bin( ){
bin1=$(echo "obase=2;$1"|bc)
echo $bin1
}
déc(){
déc1 =$(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écimal\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
déc $int
echo "L'équivalent décimal de $int est $ ?"
;;
*)
écho "Mauvais choix !"
esac
L'exemple donné convertit une entrée donnée en valeur binaire ou décimale à l'aide des commandes 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 avons affiché la valeur de $bin1 en utilisant la commande echo.
Remarque :Il est préférable d'utiliser echo directement lors de la conversion de décimal en binaire car lorsque vous renvoyez la commande pour transmettre une valeur binaire, le bash convertit la valeur binaire en décimal avant de la renvoyer.De plus, nous avons converti la valeur binaire en décimale à l'aide de 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. Vous entrerez un chiffre qui dépasse la limite de 8 bits, cela générera un débordement et le bit le plus significatif du chiffre sera ignoré.
Le chiffre binaire de 10 bits 1000001010 renvoie 10 car en suivant la règle des 8 bits, les 2 bits restants du côté droit (bit le plus significatif) seront omis, ainsi, 1000001010 deviendra égal à 00001010 qui est égal à 10. Si vous voulez une opération qui accepte les chiffres binaires dépassant 8 bits, vous devez créer le code manuellement.
Conclusion
Bash possède 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 scripts shell grâce aux fonctions. Fonctions dans les scripts shell pour fournir une modularité à l'utilisateur, facilitant le dépannage des scripts et permettant la réutilisation du code.
