In uno script Bash, come posso uscire da tutto lo script se si verifica una certa condizione?

Sto scrivendo una sceneggiatura in Bash per testare del codice. Tuttavia, sembra sciocco eseguire i test se la compilazione del codice non riesce in primo luogo, nel qual caso interromperò solo i test.

C'è un modo in cui posso farlo senza racchiudere l'intero script all'interno di un ciclo while e usare pause? Qualcosa come un dun dun dun goto?

Prova questa affermazione:

exit 1

Sostituire 1con codici di errore appropriati. Vedi anche Codici di uscita con significati speciali .

Usa set -e

#!/bin/bash

set -e

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

Lo script verrà terminato dopo la prima riga non riuscita (restituisce un codice di uscita diverso da zero). In questo caso, command-that-fail2 non verrà eseguito.

Se dovessi controllare lo stato di ritorno di ogni singolo comando, il tuo script sarebbe simile al seguente:

#!/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

Con set -e sembrerebbe:

#!/bin/bash

set -e

cd /project-dir
make

cd /project-dir2
make

Qualsiasi comando che fallisce farà fallire l'intero script e restituirà uno stato di uscita che puoi controllare con $? . Se il tuo script è molto lungo o stai costruendo un sacco di cose, diventerà piuttosto brutto se aggiungi controlli di stato del reso ovunque.

Un ragazzo di SysOps una volta mi ha insegnato la tecnica dell'artiglio a tre dita:

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

Queste funzioni sono * NIX OS e shell robusto. Inseriscili all'inizio del tuo script (bash o altro), try()dichiarazione e codice.

Spiegazione

(basato sul commento di una pecora volante ).

• yell: stampa il nome dello script e tutti gli argomenti su stderr:
  • $0 è il percorso della sceneggiatura;
  • $* sono tutti argomenti.
  • >&2significa >reindirizzare stdout a & pipe2 . la pipa1 sarebbe se stdoutstessa.
• diefa lo stesso di yell, ma esce con uno stato di uscita diverso da 0 , che significa "errore".
• tryusa il ||(booleano OR), che valuta il lato destro solo se quello sinistro fallisce.
  • $@sono di nuovo tutti gli argomenti, ma diversi .

Se si invocherà lo script con source, è possibile utilizzare return <x>dove <x>sarà lo stato di uscita dello script (utilizzare un valore diverso da zero per errore o falso). Ma se invochi uno script eseguibile (cioè, direttamente con il suo nome file), l'istruzione return restituirà un reclamo (messaggio di errore "return: può solo" restituire "da una funzione o uno script di provenienza").

Se exit <x>invece viene utilizzato, quando viene invocato lo script source, si verificherà l'uscita dalla shell che ha avviato lo script, ma uno script eseguibile termina semplicemente, come previsto.

Per gestire entrambi i casi nello stesso script, è possibile utilizzare

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

Questo gestirà qualunque invocazione possa essere adatta. Ciò presuppone che userete questa affermazione al livello più alto dello script. Vorrei sconsigliare di uscire direttamente dallo script all'interno di una funzione.

Nota: <x>dovrebbe essere solo un numero.

Includo spesso una funzione chiamata run () per gestire gli errori. Ogni chiamata che desidero effettuare viene passata a questa funzione, quindi l'intero script viene chiuso quando si verifica un errore. Il vantaggio di questo rispetto alla soluzione set -e è che lo script non si chiude silenziosamente quando una linea fallisce e può dirti qual è il problema. Nell'esempio seguente, la terza riga non viene eseguita perché lo script esce alla chiamata su 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"

Invece di ifcostruire, puoi sfruttare la valutazione del corto circuito :

#!/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]

Nota la coppia di parentesi che è necessaria a causa della priorità dell'operatore di alternanza. $?è una variabile speciale impostata per chiudere il codice dell'ultimo comando chiamato.

Ho la stessa domanda ma non posso farla perché sarebbe un duplicato.

La risposta accettata, usando exit, non funziona quando lo script è un po 'più complicato. Se si utilizza un processo in background per verificare la condizione, exit esce solo da quel processo, poiché viene eseguito in una sotto-shell. Per uccidere lo script, devi ucciderlo esplicitamente (almeno questo è l'unico modo che conosco).

Ecco un piccolo script su come farlo:

#!/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

Questa è una risposta migliore ma ancora incompleta e non so davvero come sbarazzarmi della parte del boom .