Plus profondément dans les complexités de fonction avec les scripts de coquille - Partie VII

Mon article précédent sur les «fonctions de compréhension et d'écriture dans les scripts shell» pourrait vous avoir donné une idée de base sur la façon d'écrire des fonctions sous les scripts shell. Il est maintenant temps de approfondir les fonctionnalités fonctionnelles comme l'utilisation des variables locales et la récursivité.

Variables locales

Ce qui rend une variable locale? Cela dépend de ce bloc particulier où la variable est déclarée. Une variable déclarée comme local sera accessible à partir de ce bloc de code où il apparaît i.e. sa portée est locale. Afin d'expliquer cette chose, examinons un exemple ci-dessous.

#!/ bin / bash func () local i = 10 j = 20 echo "i from func = $ i" echo "j from func = $ j" echo "i extérieur func = $ i" echo "j extérieur func = $ j "func echo" i en dehors de func = $ i "echo" j extérieur func = $ j "exit 0

Lors de l'exécution du script ci-dessus, la sortie sera.

i extérieur func = j extérieur func = i de func = 10 j de func = 20 i extérieur func = j extérieur func = 20

C'est parce que la fonction func n'a pas encore appelé pendant que le Premier 2 Les déclarations d'écho ont été exécutées. Après avoir appelé la fonction func le même 2 déclarations d'écho produire un résultat différent. Maintenant la variable J, qui a été déclaré à l'intérieur func et non local, peut être accessible après.

Ainsi la valeur pour J devient 20. Qu'en est-il de la variable locale je? Puisque sa portée était à l'intérieur de la fonction func, valeur dix ne pouvait pas être accessible de l'extérieur. Notez que la variable J normalement déclaré à l'intérieur func est global par défaut.

Vous connaissez maintenant les variables locales et comment les utiliser à l'intérieur des blocs de fonction. Passons à la section la plus intéressante sous fonctions, la récursivité.

Qu'est-ce que la récursivité?

Une fonction s'appelant est généralement appelée procédure de récursivité. Ou il peut être défini comme exprimant un algorithme en utilisant une version plus simple de ce même algorithme. Considérez l'exemple de la recherche factorielle d'un nombre. Nous savons que n! = 1 x 2 x 3 x… x (n-1) x n. Ainsi, nous pouvons écrire une relation de récidive comme:

n! = (n-1)! x n

Il est donc facile pour nous d'appeler récursivement la même fonction et d'utiliser la valeur de retour de chaque appel pour multiplier avec le résultat précédent, je.e.

5! = 4! x 5 4! = 3! x 4 3! = 2! x 3 2! = 1! x 2 1! = 0! x 1

Récursion en utilisant des variables locales

Ici, nous essayons d'écrire un script pour trouver un nombre factoriel en utilisant des variables locales et une récursivité.

#!/ bin / bash fact () num local = 1 1 si [$ num -eq 0]; alors ret = 1 else temp = $ ((num-1)) fait $ temp?)) fi return $ ret fait 5 echo "factoriel de 5 = $?"Exit 0

nobs est une variable locale utilisée pour stocker chaque n-1 valeur sur chaque appel. Ici, la condition de base vérifie si le nombre est égal à zéro ou non (puisque 0! = 1 et la factorielle n'est pas définie pour les nombres négatifs). En arrivant cette condition de base, il renvoie la valeur 1 à son appelant. Maintenant num = 1 et ret = 1 x 1.

À cet instant, il revient 1 à son appelant. Maintenant num = 2 et ret = 2 x 1 et ainsi de suite. Enfin quand num = 5 La valeur de retour sera 24 et le résultat final est ret = 5 x 24. Le résultat final 120 est transmis à l'instruction initiale de l'appelant et s'affiche.

Il y a un problème dans le script ci-dessus. Comme je l'ai expliqué dans l'article précédent, les fonctions ne peuvent pas retourner de grands entiers. Il est donc laissé aux utilisateurs pour trouver une solution pour le problème ci-dessus.

Q. Pouvons-nous effectuer une récursivité sans utiliser de variables locales? La réponse est Oui.

Récursion sans variables locales

Regardez l'exemple suivant pour afficher le Série Fibonacci Utilisation de la récursivité. La relation de récidive de base est:

fib (0) = 0 fib (1) = 1 else fib (n) = fib (n-1) + fib (n-2) série fibonacci en utilisant la récursivité #!/ bin / bash fib () a = 1 1 si [$ a -lt 2]; puis écho $ a else ((--a)) b = $ (fib $ a) ((--a)) c = $ (fib $ a) echo $ ((b + c)) fi pour i dans $ (SEQ 0 15) Do Out = $ (fib $ i) Echo $ out Tire Exit 0

Aucune variable locale n'est utilisée dans le script ci-dessus. J'espère que vous pouvez comprendre le flux de script pendant l'exécution.

Ici la valeur 15 représente le nombre de termes dans le Série Fibonacci à afficher. Avez-vous remarqué quelque chose de spécial concernant l'exécution du script ci-dessus. Ça prend un moment, n'est-ce pas? La récursivité dans un script est plus lente qu'une récursivité dans les langages de programmation comme C.

Avec cet article, je prévois de conclure la partie des fonctions dans les scripts shell. Restez à jour avec Tecmint Pour avoir les prochains articles sur tableaux et beaucoup plus…