Gibt es eine Möglichkeit, die Laufzeit des zuletzt ausgeführten Befehls in der Shell zu finden?

Ich weiß nicht, wie es in bash ist, aber in zsh kann man preexec definieren und precmd Funktionen so, dass sie die aktuelle Uhrzeit in den Variablen $STARTTIME speichern (preexec) und $ENDTIME (precmd), damit Sie die ungefähre Laufzeit ermitteln können. Oder Sie können einen accept-line definieren Funktion, sodass ihr time vorangestellt wird vor jedem Befehl.

AKTUALISIEREN :Dies ist der Code, der die verstrichene Zeit in $_elapsed speichert Array:

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

Wenn Sie dann sleep 10s ausführen :

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

Keine Notwendigkeit in vier Variablen. Keine Probleme mit Namen oder zusätzlichen Verzögerungen. Beachten Sie einfach, dass $_elapsed Das Array kann sehr groß werden, daher müssen Sie die ersten Elemente löschen (dies geschieht mit dem folgenden Codeabschnitt:(( $#_elapsed > 1000 )) && set -A _elapsed $_elapsed[-1000,-1] ).

UPDATE2 :Das Skript gefunden, um precmd und preexec im zsh-Stil in bash zu unterstützen. Möglicherweise müssen Sie typeset -ig entfernen (Früher habe ich nur $_start erzwungen ganzzahlig sein) und ersetzen Sie set -A var ... mit var=( ... ) damit das funktioniert. Und ich weiß nicht, wie man Arrays aufteilt und ihre Länge in Bash erhält.

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

UPDATE3 :Fand ein Problem:Wenn Sie die Eingabetaste mit einer leeren Zeile drücken, wird preexec nicht ausgeführt, während precmd dies tut, sodass Sie bedeutungslose Werte in $_elapsed erhalten Reihe. Um dies zu beheben, ersetzen Sie precmd Funktion mit folgendem Code:

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

Die Welt hat sich möglicherweise ein wenig weiterentwickelt, seit andere Leute diese Fragen beantwortet haben.

zsh hat einige eingebaute Funktionen, um zu bestimmen, wie lange Befehle dauern.

Wenn Sie die Option inc_append_history_time mit

aktivieren

setopt inc_append_history_time

Dann wird die Zeit, die für die Ausführung jedes Befehls benötigt wird, in Ihrem Verlauf gespeichert und kann dann mit history -D angezeigt werden .

Die Struktur dieser Antwort:

1. Es gibt keine vorgefertigte Möglichkeit, einen bereits ausgeführten Befehl zu timen
2. Es gibt Möglichkeiten, wie Sie die Dauer der Ausführungszeit eines Befehls schätzen können.
3. Ein Machbarkeitsnachweis wird gezeigt (beginnend mit der Hypothese, dass es nicht möglich ist, und endend mit der Schlussfolgerung, dass die Hypothese falsch war).
4. Es gibt Hacks, die Sie im Voraus einbauen können und die die verstrichene Zeit jedes ausgeführten Befehls aufzeichnen
5. Schlussfolgerung

Die Antwort, gekennzeichnet durch ihre Teile gemäß der obigen Gliederung:

Teil 1 - Die kurze Antwort ist "nein"

Nein Entschuldigung. Sie müssen time verwenden .

Teil 2 - vielleicht können Sie daraus ein Ergebnis ableiten

Wenn ein Programm Ausgabedateien oder Informationen in Protokolldateien schreibt, können Sie in einigen Fällen möglicherweise die Laufzeit ableiten, aber das wäre programmspezifisch und nur eine Schätzung. Wenn Sie HISTTIMEFORMAT in Bash eingestellt haben, können Sie sich Einträge in der History-Datei ansehen, um eine Vorstellung davon zu bekommen, wann ein Programm gestartet wurde. Die Endzeit wird jedoch nicht protokolliert, sodass Sie nur dann eine Dauer ableiten können, wenn ein anderes Programm unmittelbar nach dem Ende des gewünschten Programms gestartet wurde.

Teil 3 - eine Hypothese falsifiziert wird

Hypothese :Leerlaufzeit wird in die verstrichene Zeit eingerechnet

Hier ist ein Beispiel, um meinen Standpunkt zu veranschaulichen. Es basiert auf dem Vorschlag von ZyX , wäre aber mit anderen Methoden ähnlich.

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

Jetzt warten wir ... sagen wir mal 15 Sekunden, dann:

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

Jetzt warten wir ... sagen wir mal 20 Sekunden, dann:

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

Wie Sie sehen, lag ich falsch . Die Startzeit (1516) minus der vorherigen Endzeit (1506) ist die Dauer des Befehls (sleep 10 ).

Hypothese falsifiziert - es ist möglich, die korrekte verstrichene Zeit zu erhalten, ohne die Leerlaufzeit einzubeziehen

Teil 4 - ein Hack, um die verstrichene Zeit von jedem aufzuzeichnen Befehl

Hier sind die Bash-Äquivalente zu den Funktionen in ZyX's Antwort (sie benötigen das dort verlinkte Skript):

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

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

Nach der Installation von preexec.bash (aus dem verknüpften Skript) und Erstellen der beiden obigen Funktionen, würde die Beispielausführung wie folgt aussehen:

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

Teil 5 - Fazit

Verwenden Sie time .