Em um script Bash, como posso sair do script inteiro se ocorrer uma determinada condição?

Estou escrevendo um script no Bash para testar algum código. No entanto, parece tolo executar os testes se a compilação do código falhar em primeiro lugar; nesse caso, eu simplesmente abortarei os testes.

Existe uma maneira de fazer isso sem envolver o script inteiro dentro de um loop while e usar quebras? Algo como um dun dun dun goto?

Tente esta afirmação:

exit 1

Substitua 1pelos códigos de erro apropriados. Consulte também Códigos de saída com significados especiais .

Use set -e

#!/bin/bash

set -e

/bin/command-that-fails
/bin/command-that-fails2

O script será encerrado após a primeira linha que falhar (retorna código de saída diferente de zero). Nesse caso, o comando that-fail2 não será executado.

Se você verificar o status de retorno de cada comando, seu script terá a seguinte aparência:

#!/bin/bash

# I'm assuming you're using make

cd /project-dir
make
if [[ $? -ne 0 ]] ; then
    exit 1
fi

cd /project-dir2
make
if [[ $? -ne 0 ]] ; then
    exit 1
fi

Com set -e , seria semelhante a:

#!/bin/bash

set -e

cd /project-dir
make

cd /project-dir2
make

Qualquer comando que falhar fará com que o script inteiro falhe e retorne um status de saída que você pode verificar com $? . Se o seu script for muito longo ou você estiver criando muitas coisas, ficará muito feio se você adicionar verificações de status de retorno em todos os lugares.

Um cara do SysOps me ensinou uma vez a técnica da garra com três dedos:

yell() { echo "$0: $*" >&2; }
die() { yell "$*"; exit 111; }
try() { "$@" || die "cannot $*"; }

Essas funções são * NIX OS e shell-robustas. Coloque-os no início do seu script (bash ou não),try() sua declaração e código.

Explicação

(com base no comentário de ovelhas voadoras ).

• yell: imprima o nome do script e todos os argumentos para stderr:
  • $0 é o caminho para o script;
  • $* são todos argumentos.
  • >&2significa >redirecionar stdout para o & pipe2 . tubo1 seria em stdoutsi.
• diefaz o mesmo que yell, mas sai com um status de saída diferente de 0 , o que significa "falha".
• tryusa o ||(booleano OR), que avalia apenas o lado direito se o esquerdo falhar.
  • $@é todos os argumentos novamente, mas diferentes .

Se você chamar o script source, poderá usar return <x>where<x> estará o status de saída do script (use um valor diferente de zero para erro ou falso). Mas se você chamar um script executável (ou seja, diretamente com seu nome de arquivo), a declaração de retorno resultará em uma reclamação (mensagem de erro "return: pode apenas 'retornar' de uma função ou script de origem").

Se exit <x>for usado, quando o script for chamado source, resultará na saída do shell que iniciou o script, mas um script executável será encerrado, conforme o esperado.

Para lidar com ambos os casos no mesmo script, você pode usar

return <x> 2> /dev/null || exit <x>

Isso manipulará qualquer chamada que seja adequada. Isso pressupõe que você usará essa declaração no nível superior do script. Eu desaconselharia a saída direta do script de dentro de uma função.

Nota: <x>é suposto ser apenas um número.

Costumo incluir uma função chamada run () para lidar com erros. Cada chamada que eu quero fazer é passada para essa função, para que o script inteiro saia quando uma falha for atingida. A vantagem disso sobre a solução set -e é que o script não sai silenciosamente quando uma linha falha e pode lhe dizer qual é o problema. No exemplo a seguir, a terceira linha não é executada porque o script sai na chamada para false.

function run() {
  cmd_output=$(eval $1)
  return_value=$?
  if [ $return_value != 0 ]; then
    echo "Command $1 failed"
    exit -1
  else
    echo "output: $cmd_output"
    echo "Command succeeded."
  fi
  return $return_value
}
run "date"
run "false"
run "date"

Em vez de ifconstruir, você pode aproveitar a avaliação de curto-circuito :

#!/usr/bin/env bash

echo $[1+1]
echo $[2/0]              # division by 0 but execution of script proceeds
echo $[3+1]
(echo $[4/0]) || exit $? # script halted with code 1 returned from `echo`
echo $[5+1]

Observe o par de parênteses necessário devido à prioridade do operador de alternância. $?é uma variável especial configurada para sair do código do comando chamado mais recentemente.

Eu tenho a mesma pergunta, mas não posso perguntar, porque seria uma duplicata.

A resposta aceita, usando exit, não funciona quando o script é um pouco mais complicado. Se você usar um processo em segundo plano para verificar a condição, a saída sai apenas desse processo, pois ele é executado em um subcasca. Para matar o script, você deve explicitamente matá-lo (pelo menos é o único jeito que eu sei).

Aqui está um pequeno script sobre como fazê-lo:

#!/bin/bash

boom() {
    while true; do sleep 1.2; echo boom; done
}

f() {
    echo Hello
    N=0
    while
        ((N++ <10))
    do
        sleep 1
        echo $N
        #        ((N > 5)) && exit 4 # does not work
        ((N > 5)) && { kill -9 $$; exit 5; } # works 
    done
}

boom &
f &

while true; do sleep 0.5; echo beep; done

Esta é uma resposta melhor, mas ainda incompleta. Realmente não sei como me livrar da parte do boom .