Prática recomendada para usar $? na festança?

Quando li esta resposta sobre $? outra pergunta vem à mente.

Existe alguma prática recomendada de como usar $? na festança?

Vamos dar um exemplo:

Temos um script linear e gostaríamos de saber que todo o comando foi executado ok. Você acha que é bom chamar uma função pequena (vamos chamá-la de "did_it_work"), para verificar o código de erro e interromper se não estiver.

#!/bin/bash 

function did_it_work {
    code=$1
    if [ "$code" -ne "0" ]
    then
        echo "Error failure: code $code "
        exit 1
    fi
}

dir=some/path

mkdir -p $dir
did_it_work $? 

cd $dir
did_it_work $? 

run_some_command
did_it_work $? 

É claro que essa abordagem significa que eu tenho que resolver manualmente o problema, se houver algum, e executar novamente o script.

Você acha que essa é uma boa idéia ou há outras práticas recomendadas para fazer isso?

/Obrigado

Uma maneira comum é:

die() {
    IFS=' ' # make sure "$*" is joined with spaces

    # output the arguments if any on stderr:
    [ "$#" -eq 0 ] || printf '%s\n' "$*" 1>&2
    exit 1
}

então você o usa assim:

mkdir -p some/path || die "mkdir failed with status $?"

Ou, se você quiser incluir o status de saída, poderá alterá-lo para:

die() {
    last_exit_status=$?
    IFS=' '
    printf '%s\n' "FATAL ERROR: $* (status $last_exit_status)" 1>&2
    exit 1
}

e depois usá-lo é um pouco mais fácil:

mkdir -p some/path || die "mkdir failed"

Quando falha, mkdirprovavelmente já emitiu uma mensagem de erro, para que a segunda seja vista como redundante, e você pode simplesmente:

mkdir -p some/path || exit   # with the same (failing) exit status as mkdir's
mkdir -p some/path || exit 1 # with exit status 1 always

(ou use a primeira variante dieacima sem argumento)

Caso você não tenha visto command1 || command2antes, ele será executado command1e, se command1falhar, será executado command2.

Então você pode ler como "criar o diretório ou morrer".

Seu exemplo seria semelhante a:

mkdir -p some/path || die "mkdir failed"
cd some/path || die "cd failed"
some_command || die "some_command failed"

Ou você pode alinhar diesmais à direita, para que o código principal seja mais óbvio.

mkdir -p some/path         || die "mkdir failed"
cd some/path               || die "cd failed"
some_command               || die "some_command failed"

Ou na linha a seguir, quando as linhas de comando forem longas:

mkdir -p some/path ||
  die "mkdir failed"

cd some/path ||
  die "cd failed"

some_command ||
  die "some_command failed"

Além disso, se você usar o nome some/pathvárias vezes, armazene-o em uma variável para não precisar digitá-lo e alterá-lo facilmente, se necessário. E ao passar argumentos variáveis ​​para comandos, certifique-se de usar o --delimitador de opções para que o argumento não seja considerado uma opção se começar com -.

dir=some/path
mkdir -p -- "$dir"         || die "Cannot make $dir"
cd -P -- "$dir"            || die "Cannot cd to $dir"
some_command               || die "Cannot run some_command"

Você pode reescrever seu código assim:

#!/bin/bash
function try {
    "$@"
    code=$?
    if [ $code -ne 0 ]
    then
        echo "$1 did not work: exit status $code"
        exit 1
    fi
}

try mkdir -p some/path
try cd some/path
try run_some_command

Se você realmente não precisa registrar o código de erro, mas apenas se o comando foi bem-sucedido ou não, você pode diminuir try()ainda mais:

function try {
    if ! "$@"
    then
        echo "$1 did not work"
        exit 1
    fi
}

Se você realmente deseja exitum erro e está usando o Bash, também deve considerar set -e. De help set:

-e Sai imediatamente se um comando sair com um status diferente de zero.

Obviamente, isso não oferece a flexibilidade de uma função did_it_work (), mas é uma maneira fácil de garantir que seu script bash pare com um erro sem adicionar muitas chamadas à sua nova função.