Différence entre return et exit dans les fonctions Bash
Quelle est la différence entre les instructions return et exit dans les fonctions Bash par rapport aux codes de sortie?
De man bash sur return [n];
Fait en sorte qu'une fonction cesse de s'exécuter et renvoie la valeur spécifiée par n à l'appelant. Si n est omis, le statut de retour est celui de la dernière commande exécutée dans le corps de la fonction.
... sur exit [n]:
Force le shell à quitter avec le statut n. Si n est omis, le statut de sortie est celui de la dernière commande exécutée. Une interruption sur EXIT est exécutée avant la fin du shell.
EDIT:
Selon votre modification de la question concernant les codes de sortie, return n'a rien à voir avec les codes de sortie. Les codes de sortie sont destinés à applications/scripts, pas aux fonctions. Ainsi, à cet égard, le seul mot-clé qui définit le code de sortie du script (celui qui peut être capturé par le programme appelant à l'aide de la variable shell $? est) est exit.
EDIT 2:
Ma dernière déclaration faisant référence à exit provoque quelques commentaires. Il a été fait pour différencier return et exit pour la compréhension du PO, et en fait, à tout point donné un programme/script shell, exit est le seul moyen de terminer le script avec un code de sortie pour le processus appelant.
Chaque commande exécutée dans le shell produit un "code de sortie" local: elle définit la variable $? sur ce code et peut être utilisée avec if, && et d'autres opérateurs pour exécuter d'autres utilisateurs de manière conditionnelle. commandes.
Ces codes de sortie (et la valeur de la variable $? _) sont réinitialisés à chaque exécution de commande.
Incidemment, le code de sortie de la dernière commande exécutée par le script est utilisé comme code de sortie du script lui-même tel que vu par le processus appelant.
Enfin, les fonctions, lorsqu'elles sont appelées, agissent comme des commandes Shell en ce qui concerne les codes de sortie. Le code de sortie de la fonction ( dans la fonction) est défini à l'aide de return. Ainsi, lorsqu’une fonction return 0 est exécutée, l’exécution de la fonction se termine, ce qui donne un code de sortie de 0.
return entraînera la sortie de la fonction en cours, tandis que exit provoquera la fin du script à l'endroit où il a été appelé. Voici un exemple de programme pour aider à expliquer cela:
#!/bin/bash
retfunc()
{
echo "this is retfunc()"
return 1
}
exitfunc()
{
echo "this is exitfunc()"
exit 1
}
retfunc
echo "We are still here"
exitfunc
echo "We will never see this"
Sortie
$ ./test.sh
this is retfunc()
We are still here
this is exitfunc()
Je ne pense pas que quiconque ait vraiment bien répondu à la question car ils ne décrivent pas comment les deux sont utilisés. OK, je pense que nous savons que exit tue le script, où qu'il soit appelé et que vous puissiez lui attribuer un statut, tel que exit ou exit 0 ou exit 7 et ainsi de suite. Ceci peut être utilisé pour déterminer comment le script a été contraint de s'arrêter s'il a été appelé par un autre script, etc. Assez à la sortie.
return on call retournera la valeur spécifiée pour indiquer le comportement de la fonction, généralement un 1 ou un 0. Par exemple:
#!/bin/bash
isdirectory() {
if [ -d "$1" ]
then
return 0
else
return 1
fi
echo "you will not see anything after the return like this text"
}
vérifier comme ceci:
if isdirectory $1; then echo "is directory"; else echo "not a directory"; fi
ou comme ceci:
isdirectory || echo "not a directory"
Dans cet exemple, le test peut être utilisé pour indiquer si le répertoire a été trouvé. remarquez que rien après le retour ne sera exécuté dans la fonction. 0 est vrai mais faux est 1 dans le shell, différent des autres langages prog.
Pour plus d'informations sur les fonctions: http://www.linuxjournal.com/content/return-values-bash-functions
REMARQUE: La fonction isdirectory a uniquement un but pédagogique. Cela ne devrait pas être la façon dont vous exécutez une telle option dans un vrai script.
N'oubliez pas que les fonctions sont internes à un script et renvoient normalement d'où elles ont été appelées à l'aide de l'instruction return. L'appel d'un script externe est une autre affaire et les scripts se terminent généralement par une instruction exit.
La différence "entre les instructions return et exit dans les fonctions BASH en ce qui concerne les codes de sortie" est très faible. Les deux retournent un statut, pas valeurs en soi. Un statut égal à zéro indique un succès, tandis que tout autre statut (1 à 255) indique un échec. L'instruction return renvoie le script à partir de l'endroit où elle a été appelée, tandis que l'instruction exit termine le script dans son intégralité, où qu'elle se produise.
return 0 # returns to where the function was called. $? contains 0 (success).
return 1 # returns to where the function was called. $? contains 1 (failure).
exit 0 # exits the script completely. $? contains 0 (success).
exit 1 # exits the script completely. $? contains 1 (failure).
Si votre fonction se termine simplement par aucune instruction return, le statut de la dernière commande exécutée est renvoyé sous forme de code de statut (et sera placé dans $?).
Rappelez-vous, return et exit retournent un code d'état de 0 à 255, disponible dans $?. Vous ne pouvez rien insérer d’autre dans un code d’état (par exemple, return "cat"); ça ne marchera pas. Cependant, un script peut retransmettre 255 raisons différentes d'échec en utilisant des codes d'état.
Vous pouvez définir les variables contenues dans le script appelant ou obtenir des résultats d'écho dans la fonction et utiliser la substitution de commande dans le script appelant; mais le but de return et exit est de transmettre des codes d'état, et non des valeurs ou des résultats de calcul, comme on pourrait s'y attendre dans un langage de programmation comme C.
Parfois, vous exécutez un script avec . ou source.
. a.sh
Si vous incluez un exit dans le a.sh, il ne terminera pas simplement le script, mais mettra également fin à votre session Shell.
Si vous incluez un return dans le a.sh, le traitement du script est simplement arrêté.
En termes simples (principalement pour les débutants en codage), nous pouvons dire,
`return` : exits the function,
`exit()` : exits the program(called as process while running)
Aussi, si vous avez observé, c'est très basique mais ...,
`return` : is the keyword
`exit()` : is the function
exittermine le courant processus; avec ou sans code de sortie, considérez ceci comme un système plus qu’une fonction de programme. Notez que lors du sourcing,exitmettra fin au Shell, cependant, lorsqu’il sera exécuté, il ne fera queexitle script.returnd'une fonction, retourne à l'instruction après l'appel, avec ou sans code retour.returnest facultatif et implicite à la fin de la fonction.returnne peut être utilisé qu'à l'intérieur d'une fonction.
Je veux ajouter que lors de la recherche de sources, il n'est pas facile de exit le script depuis une fonction sans tuer le shell. Je pense qu'un exemple est préférable sur un script 'test'
#!/bin/bash
function die(){
echo ${1:=Something terrible wrong happen}
#... clean your trash
exit 1
}
[ -f /whatever/ ] || die "whatever is not available"
# now we can proceed
echo "continue"
faire ce qui suit:
user$ ./test
Whatever is not available
user$
test -et- le shell va se fermer.
user$ . ./test
Whatever is not available
seul test se terminera et l'invite s'affichera.
La solution consiste à inclure la procédure potentielle dans ( et )
#!/bin/bash
function die(){
echo $(1:=Something terrible wrong happen)
#... clean your trash
exit 1
}
( # added
[ -f /whatever/ ] || die "whatever is not available"
# now we can proceed
echo "continue"
) # added
maintenant, dans les deux cas, seule test quittera.
La question de l'OP: Quelle est la différence entre les instructions return et exit dans les fonctions BASH par rapport aux codes de sortie?
Premièrement, quelques précisions sont nécessaires:
- Une instruction (return | exit) n'est pas nécessaire pour terminer l'exécution d'une (fonction | Shell). Un (fonction | Shell) se termine lorsqu'il atteint la fin de sa liste de codes, même sans instruction (return | exit).
- Une instruction (return | exit) n'est pas nécessaire pour renvoyer une valeur d'une fonction terminée (Shell). Chaque processus a une variable intégrée $? qui a toujours une valeur numérique. C'est une variable spéciale qui ne peut pas être définie comme "? = 1", mais uniquement de manière spéciale (voir ci-dessous *). La valeur de $? après la dernière commande à exécuter dans le (fonction appelée | sous-shell) est la valeur qui est renvoyée au (appelant de fonction | parent-shell). Cela est vrai que la dernière commande exécutée soit ("return [n]" | "exit [n]") ou plain ("return") ou quelque chose d'autre qui s'avère être la dernière commande du code des fonctions appelées.
Dans la liste de puces ci-dessus, choisissez parmi "(x | y)" soit toujours le premier élément, soit toujours le deuxième élément, pour obtenir des instructions sur les fonctions & return ou les shells & exit.
Ce qui est clair, c’est qu’ils partagent l’utilisation commune de la variable spéciale $. pour passer des valeurs vers le haut après leur fin.
* Maintenant pour les manières spéciales que $? peut être mis en place:
- Quand une fonction appelée se termine et retourne à l'appelant, alors $? dans l'appelant sera égal à la valeur finale de $? dans la fonction terminée.
- Quand un Shell parent attend implicitement ou explicitement un seul sous-shell et est libéré par la résiliation de ce dernier, alors? dans le shell parent sera égal à la valeur finale de $? dans le sous-shell terminé.
- Certaines fonctions intégrées peuvent modifier $? en fonction de leur résultat. Mais certains ne le font pas.
- Les fonctions intégrées "return" et "exit", lorsqu'elles sont suivies d'un argument numérique, les deux $? avec argument et mettre fin à l'exécution.
Il est à noter que $? Une valeur peut être assignée en appelant exit dans un sous-shell, comme ceci:
# (exit 259)
# echo $?
3
Tout d'abord, return est un mot clé et exit mon ami est une fonction.
Cela dit, voici une explication simple.
return Il retourne une valeur d'une fonction.
exit Il se ferme ou abandonne le Shell actuel.