Existe uma declaração "goto" no bash?

Existe uma declaração "goto" no bash? Eu sei que é considerado uma má prática, mas eu preciso especificamente "ir".

Não, não há; ver §3.2.4 "Comandos compostos" na Bash Manual de Referência para obter informações sobre as estruturas de controle que fazer existir. Em particular, observe a menção de breake continue, que não é tão flexível quanto goto, mas é mais flexível no Bash do que em alguns idiomas, e pode ajudá-lo a alcançar o que deseja. (O que você quiser.)

Se você o estiver usando para pular parte de um script grande para depuração (consulte o comentário de Karl Nicoll), se false puder ser uma boa opção (não tenho certeza se "false" está sempre disponível, para mim está em / bin / false) :

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

if false; then

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

fi

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

A dificuldade surge quando é hora de extrair seu código de depuração. A construção "se falsa" é bem direta e memorável, mas como você encontra o fi correspondente? Se o seu editor permitir bloquear o recuo, você poderá recuar o bloco ignorado (será necessário recuperá-lo quando terminar). Ou um comentário sobre a linha fi, mas teria que ser algo que você se lembraria, que eu suspeito que seja muito dependente do programador.

Na verdade, pode ser útil para algumas necessidades de depuração ou demonstração.

Descobri que a solução Bob Copeland http://bobcopeland.com/blog/2012/10/goto-in-bash/ elegante:

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

resulta em:

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

Você pode usar caseno bash para simular um goto:

#!/bin/bash

case bar in
  foo)
    echo foo
    ;&

  bar)
    echo bar
    ;&

  *)
    echo star
    ;;
esac

produz:

bar
star

Se você estiver testando / depurando um script bash e simplesmente quiser pular adiante uma ou mais seções de código, aqui está uma maneira muito simples de fazer isso, que também é muito fácil de encontrar e remover mais tarde (diferente da maioria dos métodos descrito acima).

#!/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 colocar seu script de volta ao normal, exclua todas as linhas com GOTO.

Também podemos prettificar esta solução, adicionando um gotocomando como um 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"

Os aliases geralmente não funcionam em scripts bash, por isso precisamos do shoptcomando para corrigir isso.

Se você deseja ativar / desativar os seus goto, precisamos de um pouco mais:

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

Então você pode fazer export DEBUG=TRUEantes de executar o script.

Os rótulos são comentários, portanto, não causam erros de sintaxe se desativarmos os nossos goto(definindo gotocomo ' :' não-op ' '), mas isso significa que precisamos citá-los em nossogoto declarações.

Sempre que usar qualquer tipo de gotosolução, você deve tomar cuidado para que o código que você está passando não defina nenhuma variável em que você confia mais tarde - talvez seja necessário mover essas definições para a parte superior do seu script, ou logo acima de uma de suas gotodeclarações.

Embora outros já tenham esclarecido que não há gotoequivalente direto no bash (e tenham fornecido as alternativas mais próximas, como funções, loops e interrupção), gostaria de ilustrar como o uso de um loop plus breakpode simular um tipo específico de instrução goto.

A situação em que acho isso mais útil é quando preciso retornar ao início de uma seção de código se determinadas condições não forem atendidas. No exemplo abaixo, o loop while será executado para sempre até o ping parar de soltar pacotes para um IP de teste.

#!/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 solução teve os seguintes problemas:

• Remove indiscriminadamente todas as linhas de código que terminam em um :
• Trata em label:qualquer lugar da linha como um rótulo

Aqui está uma shell-checkversão fixa ( limpa):

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

Há mais uma capacidade de obter os resultados desejados: comando trap. Pode ser usado para fins de limpeza, por exemplo.

Não há gotono bash.

Aqui está uma solução alternativa suja usando trapqual pula apenas para trás :)

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

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

Resultado:

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

Isso não deve ser usado dessa maneira, mas apenas para fins educacionais. Aqui está o porquê disso funcionar:

trapestá usando o tratamento de exceções para obter a alteração no fluxo de código. Nesse caso, trapestá capturando qualquer coisa que faça com que o script EXIT. O comando gotonão existe e, portanto, gera um erro, que normalmente sai do script. Este erro está sendo detectado trape 2>/dev/nulloculta a mensagem de erro que normalmente seria exibida.

Obviamente, essa implementação do goto não é confiável, pois qualquer comando inexistente (ou qualquer outro erro, dessa maneira) executaria o mesmo comando trap. Em particular, você não pode escolher para qual rótulo ir.

Basicamente, no cenário real, você não precisa de nenhuma instrução goto, elas são redundantes, pois chamadas aleatórias para lugares diferentes dificultam a compreensão do seu código.

Se seu código for chamado várias vezes, considere usar loop e altere seu fluxo de trabalho para usar continuee break.

Se o seu código se repetir, considere escrever a função e chamá-la quantas vezes quiser.

Se seu código precisar pular para uma seção específica com base no valor da variável, considere usar a caseinstrução

Se você pode separar seu código longo em partes menores, considere movê-lo para arquivos separados e chame-os a partir do script pai.

Esta é uma pequena correção do script de Judy Schmidt apresentado por Hubbbitus.

Colocar rótulos não escapados no script foi problemático na máquina e causou uma falha. Isso foi fácil de resolver, adicionando # para escapar dos rótulos. Obrigado a Alexej Magura e access_granted por suas sugestões.

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

Um simples ir pesquisável para o uso de comentar blocos de código durante a depuração.

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

O resultado é-> GOTO concluído

Eu descobri uma maneira de fazer isso usando funções.

Digamos, por exemplo, você tem 3 opções: A, B, e C. Ae Bexecute um comando, mas Cfornece mais informações e o leva ao prompt original novamente. Isso pode ser feito usando funções.

Observe que, como a linha que contém function demoFunctionestá apenas configurando a função, é necessário chamar demoFunctionapós esse script para que a função realmente seja executada.

Você pode adaptar isso facilmente escrevendo várias outras funções e chamando-as se " GOTO" precisar de outro lugar no seu 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