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 vrais langages de programmation, bash possède des fonctions qui sont utilisées avec une implémentation limitée.

Que sont les fonctions ?

En programmation, les fonctions sont appelées sections d'un programme qui exécute 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 de la fonction. Chaque fois qu'il y a du code répétitif ou lorsqu'une tâche se répète, envisagez plutôt d'utiliser une fonction.

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 la partie du code qui calcule la factorielle une fois dans un bloc et la réutiliser à plusieurs reprises.

Pourquoi écrivons-nous des fonctions ?

Cela nous aide à réutiliser le code.
Améliorer la lisibilité du programme.
Utilisation efficace des variables à l'intérieur du programme.
Permet de tester le programme partie par partie.
Affiche le programme sous la forme d'un ensemble de sous-étapes.

Fonctions dans les scripts shell

La syntaxe générale pour écrire des fonctions dans un 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 dans ces blocs fonctionnels comme nous le faisons normalement dans les scripts shell. Essayons maintenant d’écrire un script simple contenant une petite fonction.

#!/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 « déclarer la fonction » avant de l’appeler. Et nous pouvons toujours imbriquer des fonctions dans des fonctions.

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

Lorsque la même fonction est définie plusieurs fois, la version finale est celle qui est invoqué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 transmettre des arguments aux fonctions séparés 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 suivant : $1, $2, $3, etc. Regardez l'exemple de script suivant pour trouver le maximum de deux entiers en utilisant la fonction pour ajouter 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 l’on lit les lignes. Premières lignes if-else if imbriquées à 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 y affichons le résultat 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 dans la fonction. Le script 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 expliqués dans la précédente série de scripts shell en utilisant les fonctions suivantes.

Comprendre les conseils de base du langage de script Linux Shell – Partie I
5 scripts Shell pour les débutants Linux pour apprendre la programmation Shell – Partie II
Naviguer à travers le monde des scripts Linux BASH – Partie III
Aspect mathématique de la programmation Linux Shell – Partie IV
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 partie suivante. Restez à jour avec les commentaires.