Différence entre le retour et la sortie dans les fonctions Bash

Quelle est la différence entre l' instruction returnet exitdans les fonctions Bash en ce qui concerne les codes de sortie?

À partir man bashde return [n];

Force une fonction à arrêter son exécution et à renvoyer la valeur spécifiée par n à son appelant. Si n est omis, l'état de retour est celui de la dernière commande exécutée dans le corps de la fonction.

... le exit [n]:

Faire sortir le shell avec un état de n. Si n est omis, l'état 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.

ÉDITER:

Selon votre modification de la question, concernant les codes de sortie, returnn'a rien à voir avec les codes de sortie. Les codes de sortie sont destinés aux applications / scripts , pas aux fonctions. À cet égard, le seul mot-clé qui définit le code de sortie du script (celui qui peut être intercepté par le programme appelant à l'aide de la $?variable shell) est exit.

EDIT 2:

Ma dernière déclaration faisant référence exitsuscite quelques commentaires. Il a été fait pour différencier returnet exitpour la compréhension de l'OP, et en fait, à tout moment donné d'un programme / script shell, exitest 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 conditionnellement d'autres commandes.

Ces codes de sortie (et la valeur de la $?variable) sont réinitialisés à chaque exécution de commande.

Par ailleurs, 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 qu'il est vu par le processus appelant.

Enfin, les fonctions, lorsqu'elles sont appelées, agissent comme des commandes shell par rapport aux 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 0est exécutée, l'exécution de la fonction se termine, donnant un code de sortie de 0.

returnentraînera la sortie de la fonction en cours, tandis exitque le script se terminera au point où il est appelé. Voici un exemple de programme pour 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"

Production

$ ./test.sh
this is retfunc()
We are still here
this is exitfunc()

Je ne pense pas que quiconque ait vraiment répondu pleinement à la question, car il ne décrit pas comment les deux sont utilisés. OK, je pense que nous savons que exit tue le script, où qu'il soit appelé, et vous pouvez également lui attribuer un statut tel que exit ou exit 0 ou exit 7 et ainsi de suite. Cela peut être utilisé pour déterminer comment le script a été forcé de s'arrêter s'il était appelé par un autre script, etc. Assez à la sortie.

return lors de l'appel renvoie la valeur spécifiée pour indiquer le comportement de la fonction, généralement 1 ou 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 ça:

    if isdirectory $1; then echo "is directory"; else echo "not a directory"; fi

ou comme ça:

    isdirectory || echo "not a directory"

Dans cet exemple, le test peut être utilisé pour indiquer si le répertoire a été trouvé. notez 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 est uniquement à des fins pédagogiques. Cela ne devrait pas être la façon dont vous effectuez une telle option dans un vrai script.

N'oubliez pas que les fonctions sont internes à un script et reviennent normalement d'où elles ont été appelées en utilisant l'instruction return. L'appel d'un script externe est une tout autre affaire, et les scripts se terminent généralement par une instruction exit.

La différence "entre l'instruction return et exit dans les fonctions BASH par rapport aux codes de sortie" est très faible. Les deux renvoient un statut, pas des valeurs en soi. Un état de zéro indique la réussite, tandis que tout autre état (1 à 255) indique un échec. L'instruction return retournera au script d'où elle a été appelée, tandis que l'instruction exit terminera l'intégralité du script d'où qu'il se trouve.

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 sans instruction de retour, l'état de la dernière commande exécutée est renvoyé en tant que code d'état (et sera placé dans $?).

N'oubliez pas, retour et sortie donnent un code d'état de 0 à 255, disponible en $?. Vous ne pouvez pas insérer quoi que ce soit d'autre dans un code d'état (par exemple, renvoyer "cat"); ça ne marchera pas. Mais, un script peut renvoyer 255 raisons différentes d'échec en utilisant des codes d'état.

Vous pouvez définir des variables contenues dans le script appelant, ou faire écho aux résultats dans la fonction et utiliser la substitution de commandes dans le script appelant; mais le but du retour et de la sortie est de transmettre des codes d'état, pas 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 à l'aide de .ou source.

. a.sh

Si vous incluez un exitdans le a.sh, il ne mettra pas seulement fin au script, mais mettra fin à votre session shell.

Si vous incluez un returndans le a.sh, il arrête simplement le traitement du script.

En termes simples (principalement pour les débutants dans le 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

• exitmettre fin au processus en cours ; avec ou sans code de sortie, considérez ceci comme un système plus qu'une fonction de programme. Notez que lors de l'approvisionnement, exitle shell se terminera, cependant, lors de l'exécution ne sera que exitle script.

• returndepuis une fonction, revenir à 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 tout en étant sourcé, il n'est pas facile de faire exitle script à partir d'une fonction sans tuer le shell. Je pense qu'un exemple vaut mieux 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

seulement testse terminera et l'invite s'affichera.

La solution consiste à enfermer la procédure potentiellement 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, seul testquittera.

La question de l'OP: Quelle est la différence entre l'instruction return et exit dans les fonctions BASH par rapport aux codes de sortie?

Tout d'abord, quelques éclaircissements s'imposent:

• Une instruction (return | exit) n'est pas requise pour terminer l'exécution d'une (fonction | shell). Une (fonction | shell) se terminera lorsqu'elle atteindra la fin de sa liste de codes, même sans instruction (return | exit).
• Une instruction (return | exit) n'est pas requise pour renvoyer une valeur à partir d'une (fonction | shell) terminée. Chaque processus a une variable intégrée $? qui a toujours une valeur numérique. Il s'agit d'une variable spéciale qui ne peut pas être définie comme "? = 1", mais qui n'est définie que de manière spéciale (voir ci-dessous *). La valeur de $? après la dernière commande à exécuter dans la (appelée fonction | sous-shell) est la valeur qui est renvoyée à la (fonction appelant | shell parent). Cela est vrai que la dernière commande exécutée soit ("return [n]" | "exit [n]") ou plain ("return" ou autre chose qui se trouve être la dernière commande dans le code des fonctions appelées.

Dans la liste à 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 shells & exit respectivement.

Ce qui est clair, c'est qu'ils partagent tous deux une utilisation commune de la variable spéciale $? pour passer des valeurs vers le haut après leur fin.

* Maintenant, pour les façons spéciales que $? peut être mis en place:

• Lorsqu'une fonction appelée se termine et revient à son appelant, alors $? dans l'appelant sera égal à la valeur finale de $? dans la fonction terminée.
• Lorsqu'un shell parent attend implicitement ou explicitement un seul sous-shell et est libéré par la fin de ce sous-shell, 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 à la fois $? avec l'argument et terminer l'exécution.

Il vaut la peine de noter que $? peut être assigné une valeur en appelant exit dans un sous-shell, comme ceci:

# (exit 259)
# echo $?
3  

Tout d'abord, returnc'est un mot-clé et exitmon ami est une fonction.

Cela dit, voici une explication des plus simples.

return Il renvoie une valeur d'une fonction.

exit Il quitte ou abandonne le shell actuel.