C'è un modo per trovare il tempo di esecuzione dell'ultimo comando eseguito nella shell?

Non so come sia in bash, ma in zsh puoi definire preexec e precmd funzioni in modo che salvino l'ora corrente nelle variabili $STARTTIME (preexec) e $ENDTIME (precmd) in modo da poter trovare il tempo di esecuzione approssimativo. Oppure puoi definire un accept-line funzione in modo che anteponga time prima di ogni comando.

AGGIORNA :Questo è il codice, che memorizzerà i tempi trascorsi nel $_elapsed matrice:

preexec () {
   (( $#_elapsed > 1000 )) && set -A _elapsed $_elapsed[-1000,-1]
   typeset -ig _start=SECONDS
}
precmd() { set -A _elapsed $_elapsed $(( SECONDS-_start )) }

Quindi se esegui sleep 10s :

% set -A _elapsed # Clear the times
% sleep 10s
% sleep 2s ; echo $_elapsed[-1]
10
% echo $_elapsed
0 10 0

Non c'è bisogno di quattro variabili. Nessun problema con nomi o ulteriori ritardi. Basta notare che $_elapsed l'array può diventare molto grande, quindi è necessario eliminare i primi elementi (questo viene fatto con la seguente parte di codice:(( $#_elapsed > 1000 )) && set -A _elapsed $_elapsed[-1000,-1] ).

AGGIORNAMENTO2 :Trovato lo script per supportare precmd e preexec in stile zsh in bash. Forse dovrai rimuovere typeset -ig (L'ho usato solo per forzare $_start essere intero) e sostituire set -A var ... con var=( ... ) per farlo funzionare. E non so come tagliare gli array e ottenere la loro lunghezza in bash.

Script:http://www.twistedmatrix.com/users/glyph/preexec.bash.txt

AGGIORNAMENTO3 :Trovato un problema:se premi invio con una riga vuota preexec non viene eseguito, mentre precmd sì, quindi otterrai valori senza significato in $_elapsed Vettore. Per risolvere questo problema, sostituisci precmd funzione con il seguente codice:

precmd () {
   (( _start >= 0 )) && set -A _elapsed $_elapsed $(( SECONDS-_start ))
   _start=-1 
}

Il mondo potrebbe essere cambiato un po' da quando altre persone hanno risposto a queste domande.

zsh ha alcune funzionalità integrate per calcolare quanto tempo impiegano i comandi.

Se abiliti l'opzione inc_append_history_time con

setopt inc_append_history_time

Quindi il tempo impiegato per eseguire ogni comando viene salvato nella tua cronologia e quindi può essere visualizzato con history -D .

La struttura di questa risposta:

1. Non esiste un modo preconfezionato per cronometrare un comando che è già stato eseguito
2. Ci sono modi in cui puoi dedurre una stima stimata della durata del tempo di esecuzione di un comando.
3. Viene mostrata una dimostrazione del concetto (che inizia con l'ipotesi che non si può fare e termina con la conclusione che l'ipotesi era sbagliata).
4. Ci sono degli hack che puoi mettere in atto in anticipo che registreranno il tempo trascorso di ogni comando che esegui
5. Conclusione

La risposta etichettata dalle sue parti secondo lo schema sopra:

Parte 1 - la risposta breve è "no"

No scusa. Devi usare time .

Parte 2 - forse puoi dedurre un risultato

In alcuni casi, se un programma scrive file di output o informazioni nei file di registro, potresti essere in grado di dedurre il tempo di esecuzione, ma sarebbe specifico del programma e solo una stima stimata. Se hai impostato HISTTIMEFORMAT in Bash, puoi guardare le voci nel file della cronologia per avere un'idea di quando è stato avviato un programma. Ma l'ora di fine non viene registrata, quindi puoi dedurre una durata solo se un altro programma è stato avviato immediatamente dopo la fine di quello che ti interessa.

Parte 3 - un'ipotesi è falsificata

Ipotesi :Il tempo di inattività verrà conteggiato nel tempo trascorso

Ecco un esempio per illustrare il mio punto. Si basa sul suggerimento di ZyX , ma sarebbe simile utilizzando altri metodi.

In zsh :

% precmd() { prevstart=start; start=$SECONDS; }
% preexec() { prevend=$end; end=$SECONDS; }
% echo "T: $SECONDS ps: $prevstart pe: $prevend s: $start e: $end"
T: 1491 ps: 1456 pe: 1458 s: 1459 e: 1491

Ora aspettiamo... diciamo per 15 secondi, poi:

% echo "T: $SECONDS"; sleep 10
T: 1506

Ora aspettiamo... diciamo per 20 secondi, poi:

% echo "T: $SECONDS ps: $prevstart pe: $prevend s: $start e: $end"
T: 1536 ps: 1492 pe: 1506 s: 1516 e: 1536

Come puoi vedere, mi sbagliavo . L'ora di inizio (1516) meno il precedente l'ora di fine (1506) è la durata del comando (sleep 10 ).

Ipotesi falsificata - è possibile ottenere il tempo trascorso corretto senza includere il tempo di inattività

Parte 4 - un trucco per registrare il tempo trascorso di ogni comando

Ecco gli equivalenti di Bash alle funzioni in ZyX's risposta (richiedono lo script collegato lì):

preexec () {
   (( ${#_elapsed[@]} > 1000 )) && _elapsed=(${_elapsed[@]: -1000})
   _start=$SECONDS
}

precmd () {
   (( _start >= 0 )) && _elapsed+=($(( SECONDS-_start )))
   _start=-1 
}

Dopo aver installato preexec.bash (dallo script collegato) e creando le due funzioni di cui sopra, l'esecuzione di esempio sarebbe simile a questa:

$ _elapsed=() # Clear the times
$ sleep 10s
$ sleep 2s ; echo ${_elapsed[@]: -1}
10
$ echo ${_elapsed[@]}
0 10 2

Parte 5 - conclusione

Usa time .