¿Hay alguna manera de encontrar el tiempo de ejecución del último comando ejecutado en el shell?

No se, como es en bash, pero en zsh puedes definir preexec y precmd funciones para que guarden la hora actual en las variables $STARTTIME (preejecutivo) y $ENDTIME (precmd) para que pueda encontrar el tiempo de ejecución aproximado. O puede definir un accept-line función para que anteponga time antes de cada comando.

ACTUALIZAR :Este es el código, que almacenará los tiempos transcurridos en el $_elapsed matriz:

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

Luego, si ejecuta sleep 10s :

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

No hay necesidad en cuatro variables. No hay problemas con los nombres o retrasos adicionales. Solo tenga en cuenta que $_elapsed La matriz puede crecer mucho, por lo que debe eliminar los primeros elementos (esto se hace con el siguiente código:(( $#_elapsed > 1000 )) && set -A _elapsed $_elapsed[-1000,-1] ).

ACTUALIZACIÓN2 :Se encontró el script para soportar precmd y preexec estilo zsh en bash. Tal vez necesite eliminar typeset -ig (solía forzar $_start para ser entero) y reemplace set -A var ... con var=( ... ) para que esto funcione. Y no sé cómo dividir matrices y obtener su longitud en bash.

Guión:http://www.twistedmatrix.com/users/glyph/preexec.bash.txt

ACTUALIZAR3 :Encontró un problema:si presiona regresar con una línea vacía, preexec no se ejecuta, mientras que precmd sí, por lo que obtendrá valores sin sentido en $_elapsed formación. Para solucionar esto, reemplace el precmd función con el siguiente código:

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

El mundo podría haber avanzado un poco desde que otras personas respondieron estas preguntas.

zsh tiene algunas funciones integradas para medir el tiempo que tardan los comandos.

Si activa la opción inc_append_history_time con

setopt inc_append_history_time

Luego, el tiempo necesario para ejecutar cada comando se guarda en su historial y luego se puede ver con history -D .

La estructura de esta respuesta:

1. No existe una forma preestablecida de cronometrar un comando que ya se ha ejecutado
2. Hay formas de deducir una estimación aproximada de la duración del tiempo de ejecución de un comando.
3. Se muestra una prueba de concepto (comenzando con la hipótesis de que no se puede hacer y terminando con la conclusión de que la hipótesis era incorrecta).
4. Hay trucos que puede implementar de antemano que registrarán el tiempo transcurrido de cada comando que ejecute
5. Conclusión

La respuesta etiquetada por sus partes según el esquema anterior:

Parte 1 - la respuesta corta es "no"

No, lo siento. Tienes que usar time .

Parte 2 - tal vez puedas deducir un resultado

En algunos casos, si un programa escribe archivos de salida o información en archivos de registro, es posible que pueda deducir el tiempo de ejecución, pero eso sería específico del programa y solo una estimación. Si tiene configurado HISTTIMEFORMAT en Bash, puede mirar las entradas en el archivo de historial para tener una idea de cuándo se inició un programa. Pero la hora de finalización no se registra, por lo que solo puede deducir una duración si otro programa se inició inmediatamente después de que finalizó el que le interesa.

Parte 3 - se falsea una hipótesis

Hipótesis :El tiempo de inactividad se contará en el tiempo transcurrido

Aquí hay un ejemplo para ilustrar mi punto. Se basa en la sugerencia de ZyX , pero sería similar usando otros métodos.

En 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

Ahora esperamos... digamos durante 15 segundos, luego:

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

Ahora esperamos... digamos durante 20 segundos, luego:

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

Como puedes ver, estaba equivocado . La hora de inicio (1516) menos la anterior tiempo final (1506) es la duración del comando (sleep 10 ).

Hipótesis falseada - es es posible obtener el tiempo transcurrido correcto sin incluir el tiempo de inactividad

Parte 4 - un truco para registrar el tiempo transcurrido de cada comando

Estos son los equivalentes de Bash a las funciones en ZyX's respuesta (requieren el script vinculado allí):

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

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

Después de instalar preexec.bash (del script vinculado) y creando las dos funciones anteriores, la ejecución del ejemplo se vería así:

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

Parte 5 - conclusión

Usa time .