Comprendre et écrire des fonctions dans les scripts Shell - Partie VI

Les fonctions jouent un rôle important dans tout langage de programmation. Comme beaucoup de langages de programmation réels, bash a des fonctions qui sont utilisées avec une implémentation limitée.

Que sont les fonctions ?

En programmation, les fonctions sont des sections nommées d’un programme qui effectue une tâche spécifique. En ce sens, une fonction est un type de procédure ou de routine. Lorsqu’une fonction est appelée, le programme quitte la section de code actuelle et commence à exécuter la première ligne à l’intérieur de la fonction. Chaque fois qu’il y a du code répétitif ou lorsqu’une tâche se répète, envisagez d’utiliser une fonction à la place.

Par exemple, considérons le cas où nous devons trouver la factorielle d’un nombre à plusieurs étapes d’un programme particulier. Au lieu d’écrire tout le code (pour calculer la factorielle) à chaque fois, nous pouvons écrire cette partie du code qui calcule la factorielle une fois à l’intérieur d’un bloc et la réutiliser à plusieurs reprises.

Pourquoi écrivons-nous des fonctions ?

1. Cela nous aide à réutiliser le code.
2. Améliorer la lisibilité du programme.
3. Utilisation efficace des variables à l’intérieur du programme.
4. Nous permet de tester le programme pièce par pièce.
5. Affiche le programme sous la forme d’un tas de sous-étapes.

Fonctions dans les scripts shell

La syntaxe générale pour l’écriture de fonctions en script shell comprend les méthodes suivantes.

function func_name {
	. . .
	commands
	. . .
}

or

func_name ( ) {
	. . .
	commands
	. . .
}

Opening curly braces can also be used in the second line as well.

func_name ( )
{
	. . .
	commands
	. . .
}

Vous êtes toujours libre d’écrire des commandes valides à l’intérieur de ces blocs de fonction comme nous le faisons normalement dans les scripts shell. Essayons maintenant d’écrire un script simple avec une petite fonction à l’intérieur.

#!/bin/bash

call_echo ( ) {
	echo ‘This is inside function’
}

op=$1

if [ $# -ne 1 ]; then
	echo "Usage: $0 <1/0>"
else
	if [ $1 = 0 ] ; then
		echo ‘This is outside function’
	elif [ $1 = 1 ] ; then
		call_echo
	else
		echo ‘Invalid argument’
	fi
fi

exit 0

La définition de la fonction doit précéder le premier appel à celle-ci. Il n’y a rien de tel que de « déclarer la fonction » avant de l’appeler. Et nous pouvons toujours imbriquer des fonctions à l’intérieur de fonctions.

Remarque :- L’écriture de fonctions vides entraîne toujours des erreurs de syntaxe.

Lorsqu’une même fonction est définie plusieurs fois, c’est la version finale qui est appelée. Prenons un exemple.

#!/bin/bash

func_same ( ) {
	echo ‘First definition’
}

func_same ( ) {
	echo ‘Second definition’
}

func_same

exit 0

Fonctions prenant des paramètres et renvoyant des valeurs

Allons plus loin en considérant les fonctions prenant des paramètres et renvoyant des valeurs. Pour renvoyer une valeur à partir d’une fonction, nous utilisons le shell 'return' intégré. La syntaxe est la suivante.

func_name ( ) {
	. . .
	commands
	. . .
	return $ret_val
}

De même, nous pouvons passer des arguments aux fonctions séparées par des espaces comme indiqué ci-dessous.

func_name $arg_1 $arg_2 $arg_3

À l’intérieur de la fonction, nous pouvons accéder aux arguments dans l’ordre $1, $2, $3 et ainsi de suite. Regardez l’exemple de script suivant pour trouver le maximum de deux entiers à l’aide de la fonction pour plus de clarté.

#!/bin/bash

USG_ERR=7

max_two ( ) {
	if [ "$1" -eq "$2" ] ; then
		echo 'Equal'
		exit 0
	elif [ "$1" -gt "$2" ] ; then
		echo $1
	else
		echo $2
	fi
}

err_str ( ) {
	echo "Usage: $0 <number1>  <number2>"
	exit $USG_ERR
}

NUM_1=$1
NUM_2=$2
x
if [ $# -ne 2 ] ; then
	err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
	if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  
		max_two $NUM_1 $NUM_2
	else
		err_str
	fi
else
	err_str
fi

exit 0

Ce qui précède semble un peu complexe, mais c’est simple si nous lisons à travers les lignes. D’abord imbriquées des lignes if-else if à des fins de validation, c’est-à-dire pour vérifier le nombre et le type d’arguments à l’aide d’expressions régulières. Après cela, nous appelons la fonction avec deux arguments de ligne de commande et affichons le résultat là-bas lui-même. En effet, nous ne pouvons pas renvoyer de grands entiers à partir d’une fonction. Une autre façon de contourner ce problème consiste à utiliser des variables globales pour stocker le résultat à l’intérieur de la fonction. Le texte scriptaire ci-dessous explique cette méthode.

#!/bin/bash

USG_ERR=7
ret_val=

max_two ( ) {
	if [ "$1" -eq "$2" ] ; then
		echo 'Equal'
		exit 0
	elif [ "$1" -gt "$2" ] ; then
		ret_val=$1
	else
		ret_val=$2
	fi
}

err_str ( ) {
	echo "Usage: $0 <number1>  <number2>"
	exit $USG_ERR
}

NUM_1=$1
NUM_2=$2

if [ $# -ne 2 ] ; then
	err_str
elif [ `expr $NUM_1 : '[0-9]*'` -eq ${#NUM_1} ] ; then
	if [ `expr $NUM_2 : '[0-9]*'` -eq ${#NUM_2} ] ; then  
		max_two $NUM_1 $NUM_2
		echo $ret_val
	else
		err_str
	fi
else
	err_str
fi

exit 0

Essayez maintenant quelques problèmes passionnants qui ont été expliqués dans la série précédente de scripts shell en utilisant les fonctions suivantes.

1. Comprendre les conseils de base du langage de script Linux Shell - Partie I
2. 5 scripts Shell pour les débutants de Linux pour apprendre la programmation Shell - Partie II
3. Naviguer dans le monde des scripts BASH de Linux - Partie III
4. Aspect mathématique de la programmation shell Linux – Partie IV
5. Calcul d’expressions mathématiques dans le langage de script shell – Partie V

Je reviendrai avec plus d’informations sur les fonctionnalités fonctionnelles telles que l’utilisation de variables locales, la récursivité, etc. dans la prochaine partie. Restez à jour avec les commentaires.