Différence entre return et exit dans les fonctions Bash

return entraînera la sortie de la fonction actuelle de la portée, tandis que exit entraînera la fin du script au point où il est appelé. Voici un exemple de programme pour vous aider à expliquer ceci:

#!/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 quelqu'un ait vraiment complètement répondu à la question parce qu'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 vous pouvez 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 est appelé par un autre script, etc. Assez à la sortie.

Return lorsqu'il est appelé retourne la valeur spécifiée pour indiquer le comportement de la fonction, habituellement, 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érifiez 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é. notez que quelque chose après le retour ne sera pas exécuté dans la fonction. 0 est vrai mais false est 1 dans le shell, différent des autres langs prog.

Pour plus d'informations sur les fonctions: http://www.linuxjournal.com/content/return-values-bash-functions

NOTE: Le 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 script réel.

Rappelez-vous 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 autre affaire entièrement, 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 valeurs en soi. Un statut de zéro indique le succès, tandis que tout autre statut (1 à 255) indique une défaillance. L'instruction return retournera au script d'où il a été appelé, tandis que l'instruction exit mettra fin au script entier d'où il est rencontré.

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

Remember, return et exit rendent un code d'état de 0 à 255, disponible dans $?. Vous ne pouvez rien ajouter d'autre dans un statut code (par exemple retourner "cat"); cela ne fonctionnera 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 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 passer 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 en utilisant . ou source.

. a.sh

Si vous incluez un exit dans le a.sh, cela ne terminera pas simplement le script, mais mettra fin à votre session shell.

Si vous incluez un return dans le a.sh, il arrête simplement de traiter le script.

En mots simples (principalement pour les débutants en codage), on peut 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

• exit terminez le 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, exit, mettra fin à la coque, cependant, lors de l'exécution sera juste exit le script.

• return à partir d'une fonction revenir à l'instruction après l'appel, avec ou sans code de retour. {[7] } est facultatif et implicite à la fin de la fonction. return ne peut être utilisé à l'intérieur d'un fonction.

Je veux ajouter que tout en étant sourcé, il n'est pas facile de exit le script à partir d'une fonction sans tuer le shell. Je pense qu'un exemple est meilleur 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 - la coquille se fermera.

user$ . ./test
Whatever is not available

Seulement test se terminera et l'invite s'affichera.

La solution consiste à inclure 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 test quittera.

Tout d'Abord, return est un mot-clé et exit mon ami est une fonction.

Cela dit, Voici une explication la plus simple.

return Elle renvoie une valeur à partir d'une fonction.

exit Il quitte ou abandonne le shell actuel.

La question du PO: 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 sont nécessaires:

• A (retour|quitter) déclaration n'est pas nécessaire pour terminer l'exécution d'une (fonction|shell). A (function / shell) se terminera quand il atteindra 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|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 être définie comme "?=1", mais n'est défini que de manière spéciale (voir ci-dessous *). La valeur de $? après la dernière commande à exécuter dans le (appelé fonction | sous shell) est la valeur qui est renvoyée au (Fonction appelant | shell parent). C'est vrai si la dernière commande exécutée est ("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 ou 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 les deux l'utilisation commune de la variable spéciale $? pour passer des valeurs vers le haut après leur fin.

* maintenant pour les moyens spéciaux que$? peut être réglé:

• Lorsqu'une fonction appelée se termine et retourne à c'est l'appelant alors $? en l'appelant sera égal à la valeur de $? dans la résiliation de la fonction.
• Lorsqu'un shell parent attend implicitement ou explicitement un sous-shell unique et est libéré par la fin de ce sous-shell, alors $? dans le shell parent sera égal à la valeur 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.
• fonctions intégrées "return" et "exit", suivies d'un argument numérique à la fois $? avec argument, et terminer l'exécution.

Il est intéressant de noter que$? on peut attribuer une valeur en appelant exit dans un sous-shell, comme ceci:

# (exit 259)
# echo $?
3