C'è una dichiarazione "goto" in bash?

C'è una dichiarazione "goto" in bash? So che è considerata una cattiva pratica, ma ho bisogno di "goto".

No non c'è; vedi §3.2.4 "comandi composti" in Bash Manuale di riferimento per informazioni sulle strutture di controllo che fanno esistere. In particolare, nota la menzione di breake continue, che non sono così flessibili come goto, ma sono più flessibili in Bash che in alcune lingue e possono aiutarti a ottenere ciò che desideri. (Qualunque cosa tu voglia ...)

Se lo stai usando per saltare parte di uno script di grandi dimensioni per il debug (vedi il commento di Karl Nicoll), allora se falso potrebbe essere una buona opzione (non sono sicuro che "falso" sia sempre disponibile, per me è in / bin / false) :

# ... Code I want to run here ...

if false; then

# ... Code I want to skip here ...

fi

# ... I want to resume here ...

La difficoltà si presenta quando è il momento di estrarre il codice di debug. Il costrutto "if false" è piuttosto semplice e memorabile, ma come trovi il fi corrispondente? Se il tuo editor ti consente di bloccare il rientro, puoi rientrare nel blocco saltato (quindi ti consigliamo di rimetterlo al termine). O un commento sulla linea di fi, ma dovrebbe essere qualcosa che ricorderete, che sospetto sarà molto dipendente dal programmatore.

In effetti, può essere utile per alcune esigenze di debug o dimostrative.

Ho scoperto che la soluzione Bob Copeland http://bobcopeland.com/blog/2012/10/goto-in-bash/ elegant:

#!/bin/bash
# include this boilerplate
function jumpto
{
    label=$1
    cmd=$(sed -n "/$label:/{:a;n;p;ba};" $0 | grep -v ':$')
    eval "$cmd"
    exit
}

start=${1:-"start"}

jumpto $start

start:
# your script goes here...
x=100
jumpto foo

mid:
x=101
echo "This is not printed!"

foo:
x=${x:-10}
echo x is $x

risulta in:

$ ./test.sh
x is 100
$ ./test.sh foo
x is 10
$ ./test.sh mid
This is not printed!
x is 101

Puoi usare casein bash per simulare un goto:

#!/bin/bash

case bar in
  foo)
    echo foo
    ;&

  bar)
    echo bar
    ;&

  *)
    echo star
    ;;
esac

produce:

bar
star

Se stai testando / eseguendo il debug di uno script bash e vuoi semplicemente saltare avanti una o più sezioni di codice, ecco un modo molto semplice per farlo che è anche molto facile da trovare e rimuovere in seguito (a differenza della maggior parte dei metodi descritto sopra).

#!/bin/bash

echo "Run this"

cat >/dev/null <<GOTO_1

echo "Don't run this"

GOTO_1

echo "Also run this"

cat >/dev/null <<GOTO_2

echo "Don't run this either"

GOTO_2

echo "Yet more code I want to run"

Per riportare lo script alla normalità, basta eliminare tutte le righe con GOTO.

Possiamo anche prettificare questa soluzione, aggiungendo un gotocomando come alias:

#!/bin/bash

shopt -s expand_aliases
alias goto="cat >/dev/null <<"

goto GOTO_1

echo "Don't run this"

GOTO_1

echo "Run this"

goto GOTO_2

echo "Don't run this either"

GOTO_2

echo "All done"

Gli alias di solito non funzionano negli script bash, quindi abbiamo bisogno del shoptcomando per risolverlo.

Se vuoi essere in grado di abilitare / disabilitare i tuoi goto, abbiamo bisogno di un po 'di più:

#!/bin/bash

shopt -s expand_aliases
if [ -n "$DEBUG" ] ; then
  alias goto="cat >/dev/null <<"
else
  alias goto=":"
fi

goto '#GOTO_1'

echo "Don't run this"

#GOTO1

echo "Run this"

goto '#GOTO_2'

echo "Don't run this either"

#GOTO_2

echo "All done"

Quindi puoi farlo export DEBUG=TRUEprima di eseguire lo script.

Le etichette sono commenti, quindi non causeranno errori di sintassi se disabilitiamo i nostri goto(impostando gotosu ' :' no-op), ma questo significa che dobbiamo citarli nei nostrigoto dichiarazioni.

Ogni volta che usi qualsiasi tipo di gotosoluzione, devi fare attenzione che il codice che stai saltando non imposta alcuna variabile su cui fai affidamento in seguito - potresti dover spostare quelle definizioni nella parte superiore dello script, o appena sopra una delle tue gotodichiarazioni.

Sebbene altri abbiano già chiarito che non esiste un gotoequivalente diretto in bash (e fornito le alternative più vicine come funzioni, loop e break), vorrei illustrare come l'uso di un loop plus breakpossa simulare un tipo specifico di istruzione goto.

La situazione in cui trovo questo il più utile è quando devo tornare all'inizio di una sezione di codice se non sono soddisfatte determinate condizioni. Nell'esempio seguente, il ciclo while verrà eseguito per sempre fino a quando il ping non interrompe il rilascio dei pacchetti a un IP di prova.

#!/bin/bash

TestIP="8.8.8.8"

# Loop forever (until break is issued)
while true; do

    # Do a simple test for Internet connectivity
    PacketLoss=$(ping "$TestIP" -c 2 | grep -Eo "[0-9]+% packet loss" | grep -Eo "^[0-9]")

    # Exit the loop if ping is no longer dropping packets
    if [ "$PacketLoss" == 0 ]; then
        echo "Connection restored"
        break
    else
        echo "No connectivity"
    fi
done

Questa soluzione presentava i seguenti problemi:

• Rimuove indiscriminatamente tutte le righe di codice che terminano con a :
• Tratta label:ovunque su una linea come un'etichetta

Ecco una versione fissa ( shell-checkpulita):

#!/bin/bash

# GOTO for bash, based upon https://stackoverflow.com/a/31269848/5353461
function goto
{
 local label=$1
 cmd=$(sed -En "/^[[:space:]]*#[[:space:]]*$label:[[:space:]]*#/{:a;n;p;ba};" "$0")
 eval "$cmd"
 exit
}

start=${1:-start}
goto "$start"  # GOTO start: by default

#start:#  Comments can occur after labels
echo start
goto end

  # skip: #  Whitespace is allowed
echo this is usually skipped

# end: #
echo end

C'è ancora una possibilità per ottenere i risultati desiderati: comando trap. Ad esempio, può essere utilizzato per ripulire gli scopi.

Non c'è gotoin bash.

Ecco un po 'di soluzione sporca con trapcui si salta solo all'indietro :)

#!/bin/bash -e
trap '
echo I am
sleep 1
echo here now.
' EXIT

echo foo
goto trap 2> /dev/null
echo bar

Produzione:

$ ./test.sh 
foo
I am
here now.

Questo non dovrebbe essere usato in quel modo, ma solo per scopi educativi. Ecco perché funziona:

trapsta utilizzando la gestione delle eccezioni per ottenere la modifica del flusso di codice. In questo caso, trapsta rilevando tutto ciò che provoca la USCITA dello script. Il comando gotonon esiste e quindi genera un errore che normalmente uscirebbe dallo script. Questo errore viene rilevato trape 2>/dev/nullnasconde il messaggio di errore che verrebbe normalmente visualizzato.

Questa implementazione di goto non è ovviamente affidabile, poiché qualsiasi comando inesistente (o qualsiasi altro errore, in quel modo), eseguirà lo stesso comando trap. In particolare, non puoi scegliere quale etichetta scegliere.

Fondamentalmente in uno scenario reale non hai bisogno di alcuna dichiarazione goto, sono ridondanti poiché le chiamate casuali in luoghi diversi rendono solo difficile capire il tuo codice.

Se il tuo codice viene invocato molte volte, allora considera di usare il ciclo e cambiando il suo flusso di lavoro per usare continuee break.

Se il tuo codice si ripete da solo, considera di scrivere la funzione e chiamarla tutte le volte che vuoi.

Se il codice deve passare a una sezione specifica in base al valore della variabile, prendere in considerazione l'utilizzo casedell'istruzione.

Se riesci a separare il tuo codice lungo in pezzi più piccoli, considera di spostarlo in file separati e chiamali dallo script principale.

Questa è una piccola correzione della sceneggiatura di Judy Schmidt messa a punto da Hubbbitus.

Inserire etichette senza escape nello script era problematico sulla macchina e causava un arresto anomalo. Questo è stato abbastanza facile da risolvere aggiungendo # per sfuggire alle etichette. Grazie ad Alexej Magura e access_granted per i loro suggerimenti.

#!/bin/bash
# include this boilerplate
function goto {  
label=$1
cmd=$(sed -n "/$#label#:/{:a;n;p;ba};" $0 | grep -v ':$')
eval "$cmd"
exit
}

start=${1:-"start"}

goto $start

#start#
echo "start"
goto bing

#boom#
echo boom
goto eof

#bang#
echo bang
goto boom

#bing#
echo bing
goto bang

#eof#
echo "the end mother-hugger..."

Una semplice ricerca ricercabile per l'uso di commentare i blocchi di codice durante il debug.

GOTO=false
if ${GOTO}; then
    echo "GOTO failed"
    ...
fi # End of GOTO
echo "GOTO done"

Il risultato è-> GOTO fatto

Ho scoperto un modo per farlo usando le funzioni.

Diciamo, per esempio, si hanno 3 scelte: A, B, e C. Aed Besegui un comando, ma Cti dà più informazioni e ti riporta di nuovo al prompt originale. Questo può essere fatto usando le funzioni.

Si noti che poiché il conteggio delle righe function demoFunctionsta semplicemente impostando la funzione, è necessario chiamare demoFunctiondopo quello script in modo che la funzione venga effettivamente eseguita.

Puoi facilmente adattarlo scrivendo più altre funzioni e chiamandole se hai bisogno di " GOTO" un altro posto nello script della shell.

function demoFunction {
        read -n1 -p "Pick a letter to run a command [A, B, or C for more info] " runCommand

        case $runCommand in
            a|A) printf "\n\tpwd being executed...\n" && pwd;;
            b|B) printf "\n\tls being executed...\n" && ls;;
            c|C) printf "\n\toption A runs pwd, option B runs ls\n" && demoFunction;;
        esac
}

demoFunction