Dans un script Bash, comment puis-je quitter l'intégralité du script si une certaine condition se produit?

J'écris un script dans Bash pour tester du code. Cependant, il semble idiot d'exécuter les tests si la compilation du code échoue en premier lieu, auquel cas je vais simplement abandonner les tests.

Existe-t-il un moyen de le faire sans encapsuler l'intégralité du script dans une boucle while et utiliser des pauses? Quelque chose comme un dun dun dun goto?

Essayez cette déclaration:

exit 1

Remplacez-le 1par des codes d'erreur appropriés. Voir aussi Codes de sortie avec des significations spéciales .

Utilisez set -e

#!/bin/bash

set -e

/bin/command-that-fails
/bin/command-that-fails2

Le script se terminera après la première ligne qui échoue (retourne un code de sortie différent de zéro). Dans ce cas, la commande qui échoue2 ne s'exécutera pas.

Si vous deviez vérifier l'état de retour de chaque commande, votre script ressemblerait à ceci:

#!/bin/bash

# I'm assuming you're using make

cd /project-dir
make
if [[ $? -ne 0 ]] ; then
    exit 1
fi

cd /project-dir2
make
if [[ $? -ne 0 ]] ; then
    exit 1
fi

Avec set -e, cela ressemblerait à:

#!/bin/bash

set -e

cd /project-dir
make

cd /project-dir2
make

Toute commande qui échoue entraînera l'échec de tout le script et renverra un état de sortie que vous pouvez vérifier avec $? . Si votre script est très long ou que vous construisez beaucoup de choses, cela deviendra assez moche si vous ajoutez des contrôles d'état de retour partout.

Un gars de SysOps m'a une fois appris la technique de la griffe à trois doigts:

yell() { echo "$0: $*" >&2; }
die() { yell "$*"; exit 111; }
try() { "$@" || die "cannot $*"; }

Ces fonctions sont * NIX OS et shell-robustes. Mettez-les au début de votre script (bash ou autre),try() votre déclaration et votre code.

Explication

(basé sur le commentaire d'un mouton volant ).

• yell: affiche le nom du script et tous les arguments dans stderr:
  • $0 est le chemin d'accès au script;
  • $* sont tous des arguments.
  • >&2signifie >rediriger stdout vers & pipe2 . la pipe1 serait stdoutelle-même.
• diefait la même chose que yell, mais quitte avec un état de sortie différent de 0 , ce qui signifie «échouer».
• tryutilise le ||(booléenOR ), qui n'évalue le côté droit que si celui de gauche a échoué.
  • $@est à nouveau tous les arguments, mais différents .

Si vous appelez le script avec source, vous pouvez utiliser return <x>où <x>sera l'état de sortie du script (utilisez une valeur non nulle pour erreur ou faux). Mais si vous invoquez un script exécutable (c'est-à-dire directement avec son nom de fichier), l'instruction return entraînera une réclamation (message d'erreur "return: ne peut" retourner "qu'à partir d'une fonction ou d'un script source").

Si exit <x>est utilisé à la place, lorsque le script est invoqué avec source, il entraînera la fermeture du shell qui a démarré le script, mais un script exécutable se terminera comme prévu.

Pour gérer l'un ou l'autre cas dans le même script, vous pouvez utiliser

return <x> 2> /dev/null || exit <x>

Cela gérera toute invocation appropriée. Cela suppose que vous utiliserez cette instruction au niveau supérieur du script. Je déconseille de quitter directement le script depuis une fonction.

Remarque: <x>est censé être juste un nombre.

J'inclus souvent une fonction appelée run () pour gérer les erreurs. Chaque appel que je veux faire est passé à cette fonction, donc le script entier se ferme lorsqu'un échec est rencontré. L'avantage de ceci par rapport à la solution set -e est que le script ne se ferme pas silencieusement lorsqu'une ligne échoue et peut vous dire quel est le problème. Dans l'exemple suivant, la 3ème ligne n'est pas exécutée car le script se ferme lors de l'appel à false.

function run() {
  cmd_output=$(eval $1)
  return_value=$?
  if [ $return_value != 0 ]; then
    echo "Command $1 failed"
    exit -1
  else
    echo "output: $cmd_output"
    echo "Command succeeded."
  fi
  return $return_value
}
run "date"
run "false"
run "date"

Au lieu de ifconstruire, vous pouvez tirer parti de l' évaluation de court-circuit :

#!/usr/bin/env bash

echo $[1+1]
echo $[2/0]              # division by 0 but execution of script proceeds
echo $[3+1]
(echo $[4/0]) || exit $? # script halted with code 1 returned from `echo`
echo $[5+1]

Notez la paire de parenthèses qui est nécessaire en raison de la priorité de l'opérateur d'alternance. $?est une variable spéciale définie pour quitter le code de la dernière commande appelée.

J'ai la même question mais je ne peux pas la poser car ce serait un doublon.

La réponse acceptée, en utilisant exit, ne fonctionne pas lorsque le script est un peu plus compliqué. Si vous utilisez un processus d'arrière-plan pour vérifier la condition, exit ne quitte que ce processus, car il s'exécute dans un sous-shell. Pour tuer le script, vous devez le tuer explicitement (du moins c'est la seule façon que je connaisse).

Voici un petit script sur la façon de le faire:

#!/bin/bash

boom() {
    while true; do sleep 1.2; echo boom; done
}

f() {
    echo Hello
    N=0
    while
        ((N++ <10))
    do
        sleep 1
        echo $N
        #        ((N > 5)) && exit 4 # does not work
        ((N > 5)) && { kill -9 $$; exit 5; } # works 
    done
}

boom &
f &

while true; do sleep 0.5; echo beep; done

C'est une meilleure réponse mais toujours incomplète. Je ne sais vraiment pas comment me débarrasser de la partie de la flèche .