¿Hay una declaración "goto" en bash?

¿Hay una declaración "goto" en bash? Sé que se considera una mala práctica, pero necesito específicamente "ir a".

No no hay; ver §3.2.4 "Comandos de compuestos" en la Referencia Bash manual para obtener información sobre las estructuras de control que hacen existir. En particular, tenga en cuenta la mención de breaky continue, que no son tan flexibles como goto, pero son más flexibles en Bash que en algunos idiomas, y pueden ayudarlo a lograr lo que desea. (Lo que sea que quieras ...)

Si lo está utilizando para omitir parte de un script grande para la depuración (vea el comentario de Karl Nicoll), entonces si false podría ser una buena opción (no estoy seguro si "false" siempre está disponible, para mí está en / bin / false) :

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

if false; then

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

fi

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

La dificultad viene cuando es hora de extraer su código de depuración. El constructo "si es falso" es bastante sencillo y memorable, pero ¿cómo encuentra la coincidencia? Si su editor le permite bloquear la sangría, puede sangrar el bloque omitido (entonces querrá volver a colocarlo cuando haya terminado). O un comentario en la línea fija, pero tendría que ser algo que recordará, que sospecho que dependerá mucho del programador.

De hecho, puede ser útil para algunas necesidades de depuración o demostración.

Encontré que la solución de 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

resultados en:

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

Puedes usar caseen bash para simular un goto:

#!/bin/bash

case bar in
  foo)
    echo foo
    ;&

  bar)
    echo bar
    ;&

  *)
    echo star
    ;;
esac

produce:

bar
star

Si está probando / depurando un script bash, y simplemente quiere saltarse una o más secciones de código, aquí hay una forma muy simple de hacerlo que también es muy fácil de encontrar y eliminar más tarde (a diferencia de la mayoría de los métodos descrito arriba).

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

Para que su script vuelva a la normalidad, simplemente elimine las líneas con GOTO.

También podemos embellecer esta solución, agregando un gotocomando como un 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"

Los alias no suelen funcionar en scripts de bash, por lo que necesitamos el shoptcomando para solucionarlo.

Si desea habilitar / deshabilitar gotolos suyos, necesitamos un poco más:

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

Entonces puedes hacerlo export DEBUG=TRUEantes de ejecutar el script.

Las etiquetas son comentarios, por lo que no causarán errores de sintaxis si deshabilita nuestro goto'(configurando gotoel' :'no-op), pero esto significa que necesitamos citarlos en nuestras gotodeclaraciones.

Siempre que use cualquier tipo de gotosolución, debe tener cuidado de que el código que está saltando no establezca ninguna variable en la que confíe más adelante; es posible que deba mover esas definiciones a la parte superior de su script, o justo por encima de una de sus gotodeclaraciones

Aunque otros ya han aclarado que no hay un gotoequivalente directo en bash (y han proporcionado las alternativas más cercanas, como funciones, bucles y pausa), me gustaría ilustrar cómo usar un bucle plus breakpuede simular un tipo específico de instrucción goto.

La situación en la que encuentro esto más útil es cuando necesito volver al comienzo de una sección de código si no se cumplen ciertas condiciones. En el siguiente ejemplo, el ciclo while se ejecutará para siempre hasta que el ping deje de soltar paquetes a una IP de prueba.

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

Esta solución tenía los siguientes problemas:

• Elimina indiscriminadamente todas las líneas de código que terminan en un :
• Trata en label:cualquier lugar de una línea como etiqueta

Aquí hay una shell-checkversión fija ( limpia):

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

Hay una habilidad más para lograr los resultados deseados: comando trap. Se puede utilizar para fines de limpieza, por ejemplo.

No hay gotoen bash.

Aquí hay algunas soluciones sucias trapque usan saltos solo hacia atrás :)

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

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

Salida:

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

Esto no debe usarse de esa manera, sino solo con fines educativos. Aquí es por qué esto funciona:

trapestá utilizando el manejo de excepciones para lograr el cambio en el flujo de código. En este caso, trapestá detectando cualquier cosa que provoque que el script salga. El comando gotono existe, y por lo tanto arroja un error, que normalmente saldría del script. Este error se está detectando trapy 2>/dev/nulloculta el mensaje de error que normalmente se mostraría.

Esta implementación de goto obviamente no es confiable, ya que cualquier comando inexistente (o cualquier otro error, de esa manera), ejecutaría el mismo comando trap. En particular, no puede elegir a qué etiqueta ir.

Básicamente, en un escenario real, no necesita ninguna instrucción goto, son redundantes ya que las llamadas aleatorias a diferentes lugares solo hacen que su código sea difícil de entender.

Si su código se invoca muchas veces, considere usar loop y cambiar su flujo de trabajo para usar continuey break.

Si su código se repite, considere escribir la función y llamarla tantas veces como desee.

Si su código necesita saltar a una sección específica basada en el valor de la variable, considere usar la caseinstrucción.

Si puede separar su código largo en partes más pequeñas, considere moverlo a archivos separados y llamarlos desde el script principal.

Esta es una pequeña corrección del guión Judy Schmidt presentado por Hubbbitus.

Poner etiquetas sin escape en el script fue problemático en la máquina y causó que se bloqueara. Esto fue bastante fácil de resolver agregando # para escapar de las etiquetas. Gracias a Alexej Magura y access_granted por sus sugerencias.

#!/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 de búsqueda para el uso de comentar bloques de código al depurar.

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

El resultado es-> GOTO hecho

Encontré una manera de hacer esto usando funciones.

Digamos, por ejemplo, usted tiene 3 opciones: A, B, y C. Ay Bejecuta un comando, pero Cte da más información y te lleva al indicador original nuevamente. Esto se puede hacer usando funciones.

Tenga en cuenta que dado que el contacto de la línea solo function demoFunctionestá configurando la función, debe llamar demoFunctiondespués de ese script para que la función realmente se ejecute.

Puede adaptar esto fácilmente escribiendo varias otras funciones y llamándolas si necesita " GOTO" otro lugar en su script de 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