Registra il codice di uscita del comando, simile al comando time

utilizzando

time sleep 1

rendimenti:

$ time sleep 1

real    0m1.005s
user    0m0.001s
sys     0m0.001s

c'è un comando che posso usare per stampare il codice di uscita sleepo qualunque comando io voglia eseguire?

Qualcosa di simile:

$ log-exit-code sleep 1

forse questo è sufficiente?

sleep 1 && echo "$?"

Finora nei miei test ha funzionato:

command && echo "$?" || echo "$?"

Gli dice solo di fare eco al codice di uscita se ha successo o se fallisce.

Come ha sottolineato Sato, questo è essenzialmente lo stesso di:

command; echo "$?"

Una cosa che potrebbe rendere utile il comando e / o è qualcosa di simile:

command && echo "Success! Exit Code: $?" || echo "Failure! Exit Code: $?"

Se hai bisogno che il tuo script agisca sul codice di uscita come è la preoccupazione di Olivier, non è un problema. La tua sceneggiatura potrebbe assomigliare a:

command
case "$?" in; 
    0) echo "Command exited with: 0"
       <command if good>
       ;;
    1) echo "Command exited with: 1"
        <command if bad>
        ;;
    255) echo "Command exited with: 255"  # for ssh maybe?
         <command if 255>
         ;;
    *) echo "Command exited with: >2"
        <command for other exit code>
        ;;
esac

cmd && echo "$?"non funzionerebbe poiché avrebbe necessariamente solo la stampa degli zeri (l' echoesecuzione sarebbe eseguita solo al completamento con successo del comando precedente).

Ecco una funzione di shell corta per te:

tellexit () {
    "$@"

    local err="$?"
    printf 'exit code\t%d\n' "$err" >/dev/tty
    return "$err"
}

Questo stampa il codice di uscita del comando dato in un modo simile a quello del timecomando.

$ tellexit echo "hello world"
hello world
exit code       0

$ tellexit false
exit code       1

Reindirizzando il printfto /dev/ttynella funzione, possiamo ancora utilizzare i tellexitreindirizzamenti senza ottenere spazzatura nei nostri output standard o flussi di errori:

$ tellexit bash -c 'echo hello; echo world >&2' >out 2>err
exit code       0
$ cat out
hello
$ cat err
world

Salvando il codice di uscita in una variabile siamo in grado di restituirlo al chiamante:

$ tellexit false || echo 'failed'
exit code       1
failed

Una versione più elaborata della stessa funzione stampa anche il segnale che ha interrotto il comando se il codice di uscita è maggiore di 128 (il che significa che è terminato a causa di un segnale):

tellexit () {
    "$@"

    local err="$?"

    if [ "$err" -gt 128 ]; then
        printf 'exit code\t%d (%s)\n' "$err" "$(kill -l "$err")" >/dev/tty
    else
        printf 'exit code\t%d\n' "$err" >/dev/tty
    fi

    return "$err"
}

test:

$ tellexit sh -c 'kill $$'
exit code       143 (TERM)

$ tellexit sh -c 'kill -9 $$'
Killed
exit code       137 (KILL)

(La localcosa richiede ash/ pdksh/ bash/ zsh, oppure puoi cambiarla in modo typesetche anche alcune altre shell capiscano.)

Usa una funzione wrapper shell. Probabilmente con un nome diverso.

$ exito() { "$@"; echo $?; }
$ exito true
0
$ exito false
1
$ exito echo "test test"      
test test
0
$ 

(Questo ovviamente corromperà l'output standard, quindi usa o ttyquello mostrato da @Kusalananda o non usalo al di fuori dei contesti interattivi.)

Svoltando in un territorio non portabile, alcune shell possono riportare sullo stato di tutti i comandi in una pipeline, non solo l'ultimo, ad esempio in ZSH se si desidera che vengano segnalati guasti da un'intera pipeline:

% TRAPZERR() { print >/dev/tty $pipestatus }
% perl -e 'exit 42' | perl -e 'exit 99'
42 99
% false | perl -e 'exit 42' | perl -e 'exit 99'
1 42 99
% perl -e 'exit 42' | perl -e 'exit 99' | true
% 

TRAPZERR altrimenti non si attiva quando non si verifica alcun errore (sul principio "nessuna notizia è una buona notizia").

GNU timeha un'opzione per questo:

time -f %x sleep 1
0

Passa attraverso il codice di uscita ¹ , a meno che non venga ucciso da un segnale ² :

$ /usr/bin/time -f %x sleep 1; echo $?
0
0

$ /usr/bin/time -f %x sleep 2x; echo $?
sleep: invalid time interval ‘2x’
Try 'sleep --help' for more information.
1
1

$ /usr/bin/time -f %x sleep 60s; echo $? # Press ^C before a minute elapses
0
2

Se vuoi conoscere / gestire la situazione di kill del segnale, passa -ve grep lo stderr per la stringa Command terminated by signal.

¹ Grazie a Olivier Dulac per aver notato il codice di uscita che passa.
² Inoltre, grazie a Stéphane Chazelas per aver segnalato il codice di uscita del segnale di interruzione non passa.

Non mi piacciono tutte le altre risposte (anche se mi piace molto per la loro intelligenza): visualizzano il codice di uscita ma lo cambiano. (la parte visualizzata è vera, quindi dopo di essa il codice di ritorno è 0)

Ecco una versione modificata:

do_and_tell () {
   "$@"
   returncode="$?"
   printf "Execution of : \n%s\n yelded a return code of: \n%s\n" "$*" "$returncode"
   return $returncode  # the interresting addition... keeps the commands return value.
}

## usage:

prompt$ do_and_tell true
Execution of : 
true
 yelded a return code of: 
0

prompt$ echo $?
0

prompt$ do_and_tell false
Execution of : 
false
 yelded a return code of: 
1

prompt$ echo $?
1

Per essere un po 'più robusto, invia lo stato di uscita a un FD separato in modo che possa essere gestito indipendentemente da stdout / stderr:

exit_status() {
    "$@"
    rv=$?
    echo >&3 "$rv"
    return "$rv"
}

# exit status and stdout to stdout:
> exit_status echo "hello" 3>&1
hello
0

# exit_status to stdout, stdout to /dev/null
> exit_status echo "hello" 3>&1 1>/dev/null
0
> exit_status ehco "hello" 3>&1 1>/dev/null
ehco: command not found
127

# exit_status to stdout, stdout and stderr to /dev/null
> exit_status ehco "hello" 3>&1 &>/dev/null
127

Nota che dovrai fare qualcosa con FD3 o lo dirà Bad file descriptor.

Questo potrebbe essere ulteriormente configurato per fornire queste uscite agli ingressi di un altro programma facendo ascoltare l'altro programma su più di un FD; potresti usarlo come una specie di Kibana dei primi anni '90 :)

Mentre tutte le altre (molto interessanti) risposte rispondono alla domanda esatta che l'OP ha posto, in pratica le cose sono di solito più semplici. È sufficiente salvare lo stato di uscita in una variabile (immediatamente dopo il comando) e segnalarlo o registrarlo nel modo desiderato. Ad esempio, stampare su / dev / stderr o scrivere / aggiungere come messaggio di testo in un file di registro. Inoltre, è anche conservato per l'uso nel processo decisionale / controllo del flusso nel codice successivo.

Se è in una funzione:

function some-function () {
    local rc ## to avoid side effects
    ...
    some-command ## run any command
    rc=$?  ## save the return status in a variable
    echo "some-command returned $rc" ## optionally tell the user about it
    ...
    return $rc  ## at the end, if appropriate
}

Se è direttamente in uno script:

some-command ## run any command
rc=$?  ## save the return status in a variable
echo "some-command returned $rc" ## optionally tell the user about it
...
exit $rc    ## at the end to tell any calling script about it, if appropriate

(Anatra e copertura perché questo non risponde alla domanda esatta .)