Journal de sortie du code de commande, similaire à la commande time

en utilisant

time sleep 1

rendements:

$ time sleep 1

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

puis-je utiliser une commande pour imprimer le code de sortie sleepou la commande que je veux exécuter?

Quelque chose aime:

$ log-exit-code sleep 1

peut-être cela suffit-il?

sleep 1 && echo "$?"

Dans mes tests jusqu'à présent, cela a fonctionné:

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

Il lui dit simplement de faire écho au code de sortie s'il réussit ou s'il échoue.

Comme Sato l'a souligné ci-dessous, cela revient essentiellement à:

command; echo "$?"

Une chose qui pourrait rendre la commande and / ou intéressante est quelque chose comme:

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

Si vous avez besoin que votre script agisse sur le code de sortie comme c'est le cas d'Olivier, ce n'est pas un problème. Votre script pourrait ressembler à quelque chose comme:

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 "$?"ne fonctionnerait pas car il n'imprimerait par nécessité que des zéros (le echone s'exécuterait qu'en cas de réussite de la commande précédente).

Voici une fonction shell courte pour vous:

tellexit () {
    "$@"

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

Cela imprime le code de sortie de la commande donnée de la même manière que la timecommande.

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

$ tellexit false
exit code       1

En redirigeant le printfvers /dev/ttydans la fonction, nous pouvons toujours utiliser tellexitdes redirections sans obtenir de courrier indésirable dans nos flux de sortie ou d'erreur standard:

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

En enregistrant le code de sortie dans une variable, nous pouvons le renvoyer à l'appelant:

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

Une version plus sophistiquée de la même fonction imprime également le signal qui a tué la commande si le code de sortie est supérieur à 128 (ce qui signifie qu'il s'est terminé en raison d'un signal):

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"
}

Essai:

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

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

(La localchose nécessite ash/ pdksh/ bash/ zsh, ou vous pouvez la changer, typesetce que quelques autres shells comprennent également.)

Utilisez une fonction shell wrapper. Probablement avec un nom différent.

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

(Bien sûr, cela corrompra la sortie standard, alors utilisez le ttycomme indiqué par @Kusalananda ou ne l'utilisez pas en dehors des contextes interactifs.)

En virant vers un territoire non transférable, certains shells peuvent signaler l'état de toutes les commandes dans un pipeline, pas seulement la dernière, par exemple dans ZSH si vous souhaitez que les défaillances soient signalées à partir d'un pipeline entier:

% 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 sinon, il ne se déclenche pas lorsqu'il n'y a pas d'erreur (sur le principe «aucune nouvelle n'est bonne»).

GNU timea une option pour cela:

time -f %x sleep 1
0

Passe par le code de sortie ¹ , sauf s'il est tué par un signal ² :

$ /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

Si vous voulez connaître / gérer la situation de destruction de signal, passez -vet grep le stderr pour la chaîne Command terminated by signal.

¹ Merci à Olivier Dulac d'avoir noté que le code de sortie passe.
² Merci également à Stéphane Chazelas pour avoir souligné que le code de sortie du signal kill ne passe pas.

Je n'aime pas toutes les autres réponses (bien que j'aime beaucoup pour leur intelligence): ils affichent le code de sortie mais ils LE CHANGENT également. (la partie d'affichage est vraie, donc après elle le code retour est 0)

Voici une version modifiée:

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

Pour être un peu plus robuste, envoyez l'état de sortie à un FD séparé afin qu'il puisse être géré indépendamment de 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

Notez que vous devrez faire quelque chose avec FD3 ou cela vous dira Bad file descriptor.

Cela pourrait être configuré davantage pour fournir ces sorties aux entrées d'un autre programme en faisant écouter l'autre programme sur plus d'un FD; vous pouvez l'utiliser comme une sorte de Kibana du début des années 90 :)

Alors que toutes les autres réponses (très intéressantes) répondent à la question exacte posée par le PO, dans la pratique, les choses sont généralement plus simples. Il vous suffit d'enregistrer l'état de sortie dans une variable (immédiatement après la commande) et de le signaler ou de l'enregistrer comme vous le souhaitez. Par exemple, imprimer dans / dev / stderr ou l'écrire / l'ajouter sous forme de message texte dans un fichier journal. Et, il est également conservé pour une utilisation dans la prise de décision / contrôle de flux dans le code suivant.

Si c'est dans une fonction:

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
}

Si c'est directement dans un 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

(Ducking et couvrant parce que cela ne répond pas à la question exacte .)