Gibt es eine "goto" -Anweisung in bash?

Gibt es eine "goto" -Anweisung in bash? Ich weiß, dass es als schlechte Praxis angesehen wird, aber ich brauche speziell "goto".

Nein, da ist kein; siehe §3.2.4 „Compound - Befehle“ in dem Bash - Referenzhandbuch für Informationen über die Kontrollstrukturen , die tun exist. Beachten Sie insbesondere die Erwähnung von breakund continue, die nicht so flexibel sind wie goto, aber in Bash flexibler sind als in einigen Sprachen, und Ihnen möglicherweise dabei helfen, das zu erreichen, was Sie wollen. (Was auch immer du willst ...)

Wenn Sie damit einen Teil eines großen Skripts zum Debuggen überspringen (siehe Karl Nicolls Kommentar), könnte false eine gute Option sein (nicht sicher, ob "false" immer verfügbar ist, für mich in / bin / false) ::

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

if false; then

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

fi

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

Die Schwierigkeit tritt auf, wenn es Zeit ist, Ihren Debugging-Code herauszureißen. Das "wenn falsch" -Konstrukt ist ziemlich einfach und einprägsam, aber wie finden Sie die passende Fi? Wenn Ihr Editor das Blockieren des Einrückens zulässt, können Sie den übersprungenen Block einrücken (dann möchten Sie ihn zurücksetzen, wenn Sie fertig sind). Oder ein Kommentar zur Fi-Zeile, aber es müsste etwas sein, an das Sie sich erinnern werden, von dem ich vermute, dass es sehr programmiererabhängig sein wird.

Es kann in der Tat für einige Debug- oder Demonstrationsanforderungen nützlich sein.

Ich fand die Bob Copeland-Lösung 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

Ergebnisse in:

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

Sie können casein bash verwenden, um ein goto zu simulieren:

#!/bin/bash

case bar in
  foo)
    echo foo
    ;&

  bar)
    echo bar
    ;&

  *)
    echo star
    ;;
esac

produziert:

bar
star

Wenn Sie ein Bash-Skript testen / debuggen und einfach einen oder mehrere Codeabschnitte überspringen möchten, ist dies eine sehr einfache Methode, die auch später leicht zu finden und zu entfernen ist (im Gegensatz zu den meisten Methoden) oben beschrieben).

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

Um Ihr Skript wieder normal zu machen, löschen Sie einfach alle Zeilen mit GOTO.

Wir können diese Lösung auch verschönern, indem wir einen gotoBefehl als Alias hinzufügen :

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

Aliase funktionieren normalerweise nicht in Bash-Skripten, daher benötigen wir den shoptBefehl, um dies zu beheben.

Wenn Sie Ihre aktivieren / deaktivieren möchten goto, benötigen wir ein bisschen mehr:

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

Dann können Sie dies tun, export DEBUG=TRUEbevor Sie das Skript ausführen.

Die Beschriftungen sind Kommentare und verursachen daher keine Syntaxfehler, wenn Sie unsere goto's deaktivieren (indem Sie gotodas' :'no-op' setzen). Dies bedeutet jedoch, dass wir sie in unseren gotoAnweisungen zitieren müssen .

Wenn gotoSie eine Lösung verwenden, müssen Sie darauf achten, dass der Code, an dem Sie vorbeigehen, keine Variablen festlegt, auf die Sie sich später verlassen. Möglicherweise müssen Sie diese Definitionen an den Anfang Ihres Skripts oder direkt über eine verschieben Ihrer gotoAussagen.

Obwohl andere bereits klargestellt haben, dass es gotoin bash kein direktes Äquivalent gibt (und die nächstgelegenen Alternativen wie Funktionen, Schleifen und break bereitgestellt haben), möchte ich veranschaulichen, wie die Verwendung eines loop plus breakeine bestimmte Art von goto-Anweisung simulieren kann.

Die Situation, in der ich dies am nützlichsten finde, ist, wenn ich zum Anfang eines Codeabschnitts zurückkehren muss, wenn bestimmte Bedingungen nicht erfüllt sind. Im folgenden Beispiel wird die while-Schleife für immer ausgeführt, bis der Ping keine Pakete mehr an eine Test-IP sendet.

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

Diese Lösung hatte die folgenden Probleme:

• Entfernt wahllos alle Codezeilen, die mit a enden :
• Behandelt label:irgendwo in einer Zeile als Etikett

Hier ist eine feste ( shell-checksaubere) Version:

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

Es gibt noch eine weitere Möglichkeit, die gewünschten Ergebnisse zu erzielen: Befehl trap. Es kann zum Beispiel zu Reinigungszwecken verwendet werden.

Es gibt keine gotoin Bash.

Hier ist eine schmutzige Problemumgehung, mit trapder nur rückwärts gesprungen wird :)

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

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

Ausgabe:

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

Dies sollte nicht auf diese Weise verwendet werden, sondern nur zu Bildungszwecken. Hier ist, warum dies funktioniert:

trapverwendet die Ausnahmebehandlung, um die Änderung des Codeflusses zu erreichen. In diesem Fall trapfängt das alles ab, was dazu führt, dass das Skript beendet wird. Der Befehl gotoexistiert nicht und löst daher einen Fehler aus, der normalerweise das Skript beendet. Dieser Fehler wird abgefangen trapund 2>/dev/nullverbirgt die Fehlermeldung, die normalerweise angezeigt wird.

Diese Implementierung von goto ist offensichtlich nicht zuverlässig, da jeder nicht vorhandene Befehl (oder jeder andere Fehler auf diese Weise) denselben Trap-Befehl ausführen würde. Insbesondere können Sie nicht auswählen, zu welchem ​​Etikett Sie wechseln möchten.

Grundsätzlich benötigen Sie im realen Szenario keine goto-Anweisungen, sie sind redundant, da zufällige Aufrufe an verschiedene Stellen Ihren Code nur schwer verständlich machen.

Wenn Ihr Code mehrmals aufgerufen wird, sollten Sie die Schleife verwenden und den Workflow ändern, um continueund zu verwenden break.

Wenn sich Ihr Code selbst wiederholt, sollten Sie die Funktion schreiben und so oft aufrufen, wie Sie möchten.

Wenn Ihr Code basierend auf dem Variablenwert in einen bestimmten Abschnitt springen muss, sollten Sie die Verwendung einer caseAnweisung in Betracht ziehen .

Wenn Sie Ihren langen Code in kleinere Teile aufteilen können, sollten Sie ihn in separate Dateien verschieben und über das übergeordnete Skript aufrufen.

Dies ist eine kleine Korrektur des von Hubbbitus erstellten Judy Schmidt-Skripts.

Das Einfügen von nicht maskierten Etiketten in das Skript war auf dem Computer problematisch und führte zum Absturz. Dies war leicht zu lösen, indem # hinzugefügt wurde, um den Beschriftungen zu entkommen. Vielen Dank an Alexej Magura und access_granted für ihre Vorschläge.

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

Eine einfache Suche zum Auskommentieren von Codeblöcken beim Debuggen.

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

Ergebnis ist-> GOTO erledigt

Ich habe einen Weg gefunden, dies mithilfe von Funktionen zu tun.

Nehmen wir zum Beispiel, haben Sie 3 Möglichkeiten: A, B, und C. Aund Bführen Sie einen Befehl aus, erhalten CSie jedoch weitere Informationen und gelangen erneut zur ursprünglichen Eingabeaufforderung. Dies kann mit Funktionen erfolgen.

Beachten Sie, dass function demoFunctionSie demoFunctionnach diesem Skript aufrufen müssen , da die Zeile nur die Funktion einrichtet , damit die Funktion tatsächlich ausgeführt wird.

Sie können dies einfach anpassen, indem Sie mehrere andere Funktionen schreiben und aufrufen, wenn Sie eine GOTOandere Stelle in Ihrem Shell-Skript " " benötigen .

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