Y a-t-il une déclaration «goto» dans bash?

Y a-t-il une instruction "goto" dans bash? Je sais que c'est considéré comme une mauvaise pratique, mais j'ai besoin spécifiquement de "goto".

Non, il n'y en a pas; voir §3.2.4 « Commandes composées » dans le Bash Manuel de référence pour obtenir des informations sur les structures de contrôle qui font exist. En particulier, notez la mention de breaket continue, qui ne sont pas aussi flexibles que goto, mais sont plus flexibles dans Bash que dans certaines langues, et peuvent vous aider à réaliser ce que vous voulez. (Quoi que vous vouliez ...)

Si vous l'utilisez pour ignorer une partie d'un grand script de débogage (voir le commentaire de Karl Nicoll), alors si false pourrait être une bonne option (je ne sais pas si "false" est toujours disponible, pour moi, c'est dans / bin / false) :

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

if false; then

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

fi

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

La difficulté vient quand il est temps d'extraire votre code de débogage. La construction "si faux" est assez simple et mémorable, mais comment trouvez-vous le fi correspondant? Si votre éditeur vous permet de bloquer le retrait, vous pouvez mettre en retrait le bloc ignoré (alors vous voudrez le remettre lorsque vous avez terminé). Ou un commentaire sur la ligne fi, mais il faudrait que vous vous en souveniez, ce qui, je le soupçonne, dépendra beaucoup du programmeur.

Il peut en effet être utile pour certains besoins de débogage ou de démonstration.

J'ai trouvé que la solution de Bob Copeland http://bobcopeland.com/blog/2012/10/goto-in-bash/ élégant:

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

résulte en:

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

Vous pouvez utiliser casedans bash pour simuler un goto:

#!/bin/bash

case bar in
  foo)
    echo foo
    ;&

  bar)
    echo bar
    ;&

  *)
    echo star
    ;;
esac

produit:

bar
star

Si vous testez / déboguez un script bash et que vous souhaitez simplement sauter une ou plusieurs sections de code, voici un moyen très simple de le faire qui est également très facile à trouver et à supprimer plus tard (contrairement à la plupart des méthodes décrit ci-dessus).

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

Pour remettre votre script à la normale, supprimez simplement les lignes contenant GOTO .

On peut aussi embellir cette solution, en ajoutant une gotocommande comme 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"

Les alias ne fonctionnent généralement pas dans les scripts bash, nous avons donc besoin du shopt commande pour résoudre ce problème.

Si vous voulez pouvoir activer / désactiver le vôtre goto, nous avons besoin d'un peu plus:

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

Ensuite, vous pouvez faire export DEBUG=TRUE avant d'exécuter le script.

Les étiquettes sont des commentaires, donc ne causeront pas d'erreurs de syntaxe si nous désactivons les nôtres goto(en définissant gotole :no-op), mais cela signifie que nous devons les citer dans notregoto déclarations.

Chaque fois que vous utilisez un type de gotosolution, vous devez faire attention à ce que le code sur lequel vous sautez ne définisse aucune variable sur laquelle vous vous appuyerez plus tard - vous devrez peut-être déplacer ces définitions en haut de votre script, ou juste au-dessus d'une de vos gotodéclarations.

Bien que d'autres aient déjà précisé qu'il n'y a pas d' gotoéquivalent direct dans bash (et fourni les alternatives les plus proches telles que les fonctions, les boucles et les ruptures), je voudrais illustrer comment l'utilisation d'une boucle plus breakpeut simuler un type spécifique de l'instruction goto.

La situation où je trouve cela le plus utile est lorsque je dois revenir au début d'une section de code si certaines conditions ne sont pas remplies. Dans l'exemple ci-dessous, la boucle while s'exécutera indéfiniment jusqu'à ce que le ping arrête de déposer des paquets vers une adresse IP de test.

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

Cette solution présentait les problèmes suivants:

• Supprime sans discrimination toutes les lignes de code se terminant par un :
• Traite label:n'importe où sur une ligne comme une étiquette

Voici une version fixe ( shell-checkpropre):

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

Il y a une capacité supplémentaire pour obtenir les résultats souhaités: la commande trap. Il peut être utilisé à des fins de nettoyage par exemple.

Il n'y a pas gotode bash.

Voici une solution de contournement sale trapqui ne saute qu'en arrière :)

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

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

Production:

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

Cela ne devrait pas être utilisé de cette façon, mais uniquement à des fins éducatives. Voici pourquoi cela fonctionne:

traputilise la gestion des exceptions pour effectuer le changement de flux de code. Dans ce cas, le trapcapture tout ce qui provoque la sortie du script. La commande goton'existe pas et génère donc une erreur, qui quitterait normalement le script. Cette erreur est détectée trapet 2>/dev/nullmasque le message d'erreur qui devrait normalement s'afficher.

Cette implémentation de goto n'est évidemment pas fiable, car toute commande inexistante (ou toute autre erreur, de cette manière), exécuterait la même commande trap. En particulier, vous ne pouvez pas choisir l'étiquette à utiliser.

Fondamentalement, dans le scénario réel, vous n'avez pas besoin d'instructions goto, elles sont redondantes car les appels aléatoires à différents endroits ne font que rendre votre code difficile à comprendre.

Si votre code est invoqué plusieurs fois, pensez à utiliser la boucle et à modifier son flux de travail pour utiliser continueet break.

Si votre code se répète, pensez à écrire la fonction et à l'appeler autant de fois que vous le souhaitez.

Si votre code doit sauter dans une section spécifique en fonction de la valeur de la variable, envisagez d'utiliser l' caseinstruction.

Si vous pouvez séparer votre code long en morceaux plus petits, envisagez de le déplacer dans des fichiers séparés et appelez-les depuis le script parent.

Il s'agit d'une petite correction du script Judy Schmidt mis en place par Hubbbitus.

La mise en place d'étiquettes non échappées dans le script a posé problème sur la machine et l'a fait planter. Cela a été assez facile à résoudre en ajoutant # pour échapper aux étiquettes. Merci à Alexej Magura et access_granted pour leurs suggestions.

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

Un simple goto consultable pour l'utilisation de commenter les blocs de code lors du débogage.

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

Le résultat est-> GOTO done

J'ai trouvé un moyen de le faire en utilisant des fonctions.

Disons, par exemple, vous avez 3 choix: A, Bet C. Aet Bexécutez une commande, mais Cvous donne plus d'informations et vous ramène à l'invite d'origine. Cela peut être fait en utilisant des fonctions.

Notez que puisque la ligne contenant ne function demoFunctionfait que configurer la fonction, vous devez appeler demoFunctionaprès ce script pour que la fonction s'exécute réellement.

Vous pouvez facilement l'adapter en écrivant plusieurs autres fonctions et en les appelant si vous avez besoin " GOTO" d'un autre emplacement dans votre script 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