Gibt es eine integrierte Methode zum Messen der Ausführungszeit eines Befehls in der Windows-Befehlszeile?
Wenn Sie Windows 2003 verwenden (beachten Sie, dass Windows Server 2008 und höher nicht unterstützt wird), können Sie das Windows Server 2003 Resource Kit verwenden, das timeit.exe enthält, das detaillierte Ausführungsstatistiken anzeigt. Hier ein Beispiel, wie der Befehl "timeit -?"
C:\>timeit timeit -?
Invalid switch -?
Usage: TIMEIT [-f filename] [-a] [-c] [-i] [-d] [-s] [-t] [-k keyname | -r keyname] [-m mask] [commandline...]
where: -f specifies the name of the database file where TIMEIT
keeps a history of previous timings. Default is .\timeit.dat
-k specifies the keyname to use for this timing run
-r specifies the keyname to remove from the database. If
keyname is followed by a comma and a number then it will
remove the slowest (positive number) or fastest (negative)
times for that keyname.
-a specifies that timeit should display average of all timings
for the specified key.
-i specifies to ignore non-zero return codes from program
-d specifies to show detail for average
-s specifies to suppress system wide counters
-t specifies to tabular output
-c specifies to force a resort of the data base
-m specifies the processor affinity mask
Version Number: Windows NT 5.2 (Build 3790)
Exit Time: 7:38 am, Wednesday, April 15 2009
Elapsed Time: 0:00:00.000
Process Time: 0:00:00.015
System Calls: 731
Context Switches: 299
Page Faults: 515
Bytes Read: 0
Bytes Written: 0
Bytes Other: 298
Sie können TimeIt im Windows 2003 Resource Kit erhalten. Laden Sie es herunter hier .
Alternativ verfügt Windows PowerShell über einen integrierten Befehl, der dem Bash-Befehl "time" ähnelt. Es heißt "Measure-Command". Sie müssen sicherstellen, dass PowerShell auf dem Computer installiert ist, auf dem sie ausgeführt wird.
Beispieleingabe:
Measure-Command {echo hi}
Beispielausgabe:
Days : 0
Hours : 0
Minutes : 0
Seconds : 0
Milliseconds : 0
Ticks : 1318
TotalDays : 1.52546296296296E-09
TotalHours : 3.66111111111111E-08
TotalMinutes : 2.19666666666667E-06
TotalSeconds : 0.0001318
TotalMilliseconds : 0.1318
Falls Sie es wollen
Kopieren Sie das folgende Skript in eine neue Batchdatei (z. B. timecmd.bat ):
@echo off
@setlocal
set start=%time%
:: Runs your command
cmd /c %*
set end=%time%
set options="tokens=1-4 delims=:.,"
for /f %options% %%a in ("%start%") do set start_h=%%a&set /a start_m=100%%b %% 100&set /a start_s=100%%c %% 100&set /a start_ms=100%%d %% 100
for /f %options% %%a in ("%end%") do set end_h=%%a&set /a end_m=100%%b %% 100&set /a end_s=100%%c %% 100&set /a end_ms=100%%d %% 100
set /a hours=%end_h%-%start_h%
set /a mins=%end_m%-%start_m%
set /a secs=%end_s%-%start_s%
set /a ms=%end_ms%-%start_ms%
if %ms% lss 0 set /a secs = %secs% - 1 & set /a ms = 100%ms%
if %secs% lss 0 set /a mins = %mins% - 1 & set /a secs = 60%secs%
if %mins% lss 0 set /a hours = %hours% - 1 & set /a mins = 60%mins%
if %hours% lss 0 set /a hours = 24%hours%
if 1%ms% lss 100 set ms=0%ms%
:: Mission accomplished
set /a totalsecs = %hours%*3600 + %mins%*60 + %secs%
echo command took %hours%:%mins%:%secs%.%ms% (%totalsecs%.%ms%s total)
Verwendungszweck
Wenn Sie timecmd.bat in einem Verzeichnis in Ihrem Pfad ablegen, können Sie es wie folgt aufrufen:
timecmd [your command]
Z.B.
C:\>timecmd pause
Press any key to continue . . .
command took 0:0:1.18
Wenn Sie die Ausgabe umleiten möchten, können Sie den Befehl wie folgt zitieren:
timecmd "dir c:\windows /s > nul"
Dies sollte Befehle behandeln, die von vor bis nach Mitternacht ausgeführt werden. Die Ausgabe ist jedoch falsch, wenn der Befehl 24 Stunden oder länger ausgeführt wird.
Hehe, die einfachste Lösung könnte folgende sein:
echo %time%
YourApp.exe
echo %time%
Dies funktioniert auf jedem Windows-Standard.
Wenn eine Anwendung die Konsolenausgabe verwendet, kann es zweckmäßig sein, die Startzeit in einer temporären Variablen zu speichern:
set startTime=%time%
YourApp.exe
echo Start Time: %startTime%
echo Finish Time: %time%
Nur eine kleine Erweiterung von der Antwort von Casey.K zur Verwendung des Measure-Command
von PowerShell :
Sie können PowerShell über die Standardbefehlsaufforderung wie folgt aufrufen:
powershell -Command "Measure-Command {echo hi}"
Dadurch wird die Standardausgabe verbraucht. Sie können dies jedoch verhindern, indem Sie | Out-Default
wie folgt von PowerShell hinzufügen:
Measure-Command {echo hi | Out-Default}
Oder von einer Eingabeaufforderung:
powershell -Command "Measure-Command {echo hi | Out-Default}"
Natürlich können Sie dies in eine Skriptdatei *.ps1
oder *.bat
einpacken.
Der One-Liner, den ich in Windows Server 2008 R2 verwende, lautet:
cmd /v:on /c "echo !TIME! & *mycommand* & echo !TIME!"
Solange mycommand keine Anführungszeichen benötigt (was bei cmds Zitatverarbeitung schraubt). Der /v:on
soll ermöglichen, dass die zwei verschiedenen TIME-Werte bei der Ausführung des Befehls unabhängig voneinander und nicht einmal ausgewertet werden.
Wenn Sie ein Befehlsfenster geöffnet haben und die Befehle manuell aufrufen, können Sie auf jeder Eingabeaufforderung einen Zeitstempel anzeigen, z.
Prompt $d $t $_$P$G
Es gibt Ihnen etwas wie:
23.03.2009 15:45:50,77
C:\>
Wenn Sie über ein kleines Batch-Skript verfügen, das Ihre Befehle ausführt, müssen Sie vor jedem Befehl eine leere Zeile angeben, z.
(leere Zeile)
myCommand.exe
(nächste leere Zeile)
myCommand2.exe
Sie können die Ausführungszeit für jeden Befehl anhand der Zeitangaben in der Eingabeaufforderung berechnen. Am besten wäre es wahrscheinlich, die Ausgabe zur weiteren Analyse in eine Textdatei zu leiten:
MyBatchFile.bat > output.txt
Da andere Benutzer die Installation von Freeware und PowerShell empfehlen, können Sie auch Cygwin installieren, wodurch Sie auf viele grundlegende Unix-Befehle wie time zugreifen können:
[email protected]:~$ time sleep 5
real 0m5.012s
user 0m0.000s
sys 0m0.000s
Nicht sicher, wie viel Aufwand Cygwin hinzufügt.
Nicht ganz so elegant wie einige Funktionen unter Unix, aber erstellen Sie eine cmd-Datei, die folgendermaßen aussieht:
@echo off
time < nul
yourexecutable.exe > c:\temp\output.txt
time < nul
rem on newer windows system you can try time /T
Dadurch werden die Start- und Stoppzeiten wie folgt angezeigt:
The current time is: 10:31:57.92
Enter the new time:
The current time is: 10:32:05.94
Enter the new time:
Ich benutze Freeware namens "GS Timer".
Machen Sie einfach eine Batch-Datei wie folgt:
timer
yourapp.exe
timer /s
Wenn Sie eine Reihe von Zeiten benötigen, leiten Sie einfach die Ausgabe von Timer/s in eine TXT-Datei.
Sie können es hier bekommen: Gammadynes Free DOS Utilities
Die Auflösung beträgt 0,1 Sekunden.
Ich verwende Windows XP und aus irgendeinem Grund funktioniert timeit.exe nicht für mich. Ich habe eine andere Alternative gefunden - PTIME. Das funktioniert sehr gut.
http://www.pc-tools.net/win32/ptime/
Beispiel -
C:\> ptime
ptime 1.0 for Win32, Freeware - http://www.pc-tools.net/
Copyright(C) 2002, Jem Berkes <[email protected]>
Syntax: ptime command [arguments ...]
ptime will run the specified command and measure the execution time
(run time) in seconds, accurate to 5 millisecond or better. It is an
automatic process timer, or program timer.
C:\> ptime cd
ptime 1.0 for Win32, Freeware - http://www.pc-tools.net/
Copyright(C) 2002, Jem Berkes <[email protected]>
=== cd ===
C:\
Execution time: 0.015 s
Solange es nicht länger als 24 Stunden dauert ...
@echo off
set starttime=%TIME%
set startcsec=%STARTTIME:~9,2%
set startsecs=%STARTTIME:~6,2%
set startmins=%STARTTIME:~3,2%
set starthour=%STARTTIME:~0,2%
set /a starttime=(%starthour%*60*60*100)+(%startmins%*60*100)+(%startsecs%*100)+(%startcsec%)
:TimeThis
ping localhost
set endtime=%time%
set endcsec=%endTIME:~9,2%
set endsecs=%endTIME:~6,2%
set endmins=%endTIME:~3,2%
set endhour=%endTIME:~0,2%
if %endhour% LSS %starthour% set /a endhour+=24
set /a endtime=(%endhour%*60*60*100)+(%endmins%*60*100)+(%endsecs%*100)+(%endcsec%)
set /a timetaken= ( %endtime% - %starttime% )
set /a timetakens= %timetaken% / 100
set timetaken=%timetakens%.%timetaken:~-2%
echo.
echo Took: %timetaken% sec.
Es gibt auch TimeMem (März 2012):
Dies ist ein Windows-Dienstprogramm, das ein Programm ausführt und dessen .__ anzeigt. Ausführungszeit, Speicherauslastung und IO - Statistiken. Ähnlich ist es in Funktionalität für das Unix-Zeitprogramm.
Dies ist ein Einzeiler, der verzögerte Erweiterung vermeidet, wodurch bestimmte Befehle gestört werden könnten:
cmd /E /C "Prompt $T$$ & echo.%TIME%$ & COMMAND_TO_MEASURE & for %Z in (.) do rem/ "
Die Ausgabe ist so etwas wie:
14:30:27.58$ ... 14:32:43.17$ rem/
Für Langzeittests ersetzen Sie $T
durch $D, $T
und %TIME%
durch %DATE%, %TIME%
, um das Datum einzuschließen.
Um dies in einer batch-Datei zu verwenden, ersetzen Sie %Z
durch %%Z
.
Hier ist ein verbesserter Einzeiler (ohne verzögerte Erweiterung auch):
cmd /E /C "Prompt $D, $T$$ & (for %# in (.) do rem/ ) & COMMAND_TO_MEASURE & for %# in (.) do Prompt"
Die Ausgabe sieht ähnlich aus:
2015/09/01, 14:30:27.58$ rem/ ... 2015/09/01, 14:32:43.17$ Prompt
Dieser Ansatz beinhaltet weder das Einfügen einer neuen cmd
im Ergebnis noch den Prompt
-Befehl (en).
Hier ist ein
Anwendungsbeispiel:
Zeitüberschreitung 1| TimeIt.cmd
Execution took ~969 milliseconds.
Kopieren Sie diese in einen Editor, wie zum Beispiel Notepad ++ und speichern Sie sie unter TimeIt.cmd:
:: --- TimeIt.cmd ----
@echo off
setlocal enabledelayedexpansion
call :ShowHelp
:: Set pipeline initialization time
set t1=%time%
:: Wait for stdin
more
:: Set time at which stdin was ready
set t2=!time!
:: Calculate difference
Call :GetMSeconds Tms1 t1
Call :GetMSeconds Tms2 t2
set /a deltaMSecs=%Tms2%-%Tms1%
echo Execution took ~ %deltaMSecs% milliseconds.
endlocal
goto :eof
:GetMSeconds
Call :Parse TimeAsArgs %2
Call :CalcMSeconds %1 %TimeAsArgs%
goto :eof
:CalcMSeconds
set /a %1= (%2 * 3600*1000) + (%3 * 60*1000) + (%4 * 1000) + (%5)
goto :eof
:Parse
:: Mask time like " 0:23:29,12"
set %1=!%2: 0=0!
:: Replace time separators with " "
set %1=!%1::= !
set %1=!%1:.= !
set %1=!%1:,= !
:: Delete leading zero - so it'll not parsed as octal later
set %1=!%1: 0= !
goto :eof
:ShowHelp
echo %~n0 V1.0 [Dez 2015]
echo.
echo Usage: ^<Command^> ^| %~nx0
echo.
echo Wait for pipe getting ready... :)
echo (Press Ctrl+Z ^<Enter^> to Cancel)
goto :eof
^ - Basierend auf 'Daniel Sparks' Version
Falls noch jemand hierher gekommen ist, um eine Antwort auf diese Frage zu finden, gibt es eine Windows-API-Funktion namens GetProcessTimes()
. Es sieht nicht nach viel Arbeit aus, ein kleines C-Programm zu schreiben, das den Befehl startet, diesen Aufruf ausführt und die Prozesszeiten zurückgibt.
Dies ist ein Kommentar/Bearbeitung von Luke Sampson's Nice timecmd.bat
und Antwort auf
Aus irgendeinem Grund gibt mir das nur Ausgabe in ganzen Sekunden ... was für mich nutzlos ist. Ich meine, dass ich timecmd pause starte, und das ergibt immer 1,00 Sekunden, 2,00 Sekunden, 4,00 Sekunden ... sogar 0,00 Sekunden! Windows 7. - Camilo Martin 25. September 13 um 16:00 Uhr "
Bei einigen Konfigurationen können sich die Trennzeichen unterscheiden. Die folgende Änderung sollte mindestens die meisten westlichen Länder abdecken.
set options="tokens=1-4 delims=:,." (added comma)
Die %time%
-Millisekunden funktionieren auf meinem System, nachdem sie das ',' hinzugefügt haben.
(* weil die Site keinen Kommentar zulässt und die Identität nicht gut nachvollziehbar ist, obwohl ich immer dieselbe Gast-E-Mail verwende, was in Kombination mit ipv6 ip und browser Fingerprint ausreichen sollte, um ohne Passwort eindeutig identifiziert zu werden.
Eine Alternative zur Taktzeit ist einfach "Get-Date". Sie haben keinen Aufwand mit Weiterleitungsausgabe und so weiter.
$start = Get-Date
[System.Threading.Thread]::Sleep(1500)
$(Get-Date) - $start
Ausgabe:
Days : 0
Hours : 0
Minutes : 0
Seconds : 1
Milliseconds : 506
Ticks : 15060003
TotalDays : 1.74305590277778E-05
TotalHours : 0.000418333416666667
TotalMinutes : 0.025100005
TotalSeconds : 1.5060003
TotalMilliseconds : 1506.0003
mein Code gibt die Laufzeit in Millisekunden (bis zu 24 Stunden) an, ist unabhängig vom Gebietsschema und berücksichtigt negative Werte, wenn der Code bis Mitternacht läuft. Es verwendet eine verzögerte Erweiterung und sollte in einer Cmd/Bat-Datei gespeichert werden.
vor Ihrem Code:
SETLOCAL EnableDelayedExpansion
for /f "tokens=2 delims==" %%I in ('wmic os get localdatetime /format:list') do set t=%%I
set /a t1 = %t:~8,1%*36000 + %t:~9,1%*3600 + %t:~10,1%*600 + %t:~11,1%*60 + %t:~12,1%*10 + %t:~13,1% && set t1=!t1!%t:~15,3%
nach Ihrem Code:
for /f "tokens=2 delims==" %%I in ('wmic os get localdatetime /format:list') do set t=%%I
set /a t2 = %t:~8,1%*36000 + %t:~9,1%*3600 + %t:~10,1%*600 + %t:~11,1%*60 + %t:~12,1%*10 + %t:~13,1% && set t2=!t2!%t:~15,3%
set /a t2-=t1 && if !t2! lss 0 set /a t2+=24*3600000
Wenn Sie Laufzeit im Format HH: mm: ss.000 wünschen, fügen Sie Folgendes hinzu:
set /a "h=t2/3600000,t2%%=3600000,m=t2/60000,t2%%=60000" && set t2=00000!t2!&& set t2=!t2:~-5!
if %h% leq 9 (set h=0%h%) && if %m% leq 9 (set m=0%m%)
set t2=%h%:%m%:%t2:~0,2%.%t2:~2,3%
ENDLOCAL
die Variable t2
enthält Ihre Laufzeit. Sie können echo %t2%
anzeigen, um sie anzuzeigen.
@echo off & setlocal
set start=%time%
REM Do stuff to be timed here.
REM Alternatively, uncomment the line below to be able to
REM pass in the command to be timed when running this script.
REM cmd /c %*
set end=%time%
REM Calculate time taken in seconds, to the hundredth of a second.
REM Assumes start time and end time will be on the same day.
set options="tokens=1-4 delims=:."
for /f %options% %%a in ("%start%") do (
set /a start_s="(100%%a %% 100)*3600 + (100%%b %% 100)*60 + (100%%c %% 100)"
set /a start_hs=100%%d %% 100
)
for /f %options% %%a in ("%end%") do (
set /a end_s="(100%%a %% 100)*3600 + (100%%b %% 100)*60 + (100%%c %% 100)"
set /a end_hs=100%%d %% 100
)
set /a s=%end_s%-%start_s%
set /a hs=%end_hs%-%start_hs%
if %hs% lss 0 (
set /a s=%s%-1
set /a hs=100%hs%
)
if 1%hs% lss 100 set hs=0%hs%
echo.
echo Time taken: %s%.%hs% secs
echo.
Das folgende Skript verwendet nur "cmd.exe" und gibt die Anzahl der Millisekunden ab dem Zeitpunkt, zu dem eine Pipeline erstellt wird, bis zu dem Zeitpunkt aus, an dem der dem Skript vorangehende Prozess beendet wird. Geben Sie Ihren Befehl ein und leiten Sie den Befehl an das Skript weiter. Beispiel: "timeout 3 | runtime.cmd" sollte etwas wie "2990" ergeben. Wenn Sie sowohl die Laufzeitausgabe als auch die Ausgabe von stdin benötigen, leiten Sie stdin vor dem Pipe-Ex um: "dir/s 1> temp.txt | runtime.cmd" würde die Ausgabe des Befehls "dir" in "temp.txt" speichern. und würde die Laufzeit auf die Konsole drucken.
:: --- runtime.cmd ----
@echo off
setlocal enabledelayedexpansion
:: find target for recursive calls
if not "%1"=="" (
shift /1
goto :%1
exit /b
)
:: set pipeline initialization time
set t1=%time%
:: wait for stdin
more > nul
:: set time at which stdin was ready
set t2=!time!
::parse t1
set t1=!t1::= !
set t1=!t1:.= !
set t1=!t1: 0= !
:: parse t2
set t2=!t2::= !
set t2=!t2:.= !
set t2=!t2: 0= !
:: calc difference
pushd %~dp0
for /f %%i in ('%0 calc !t1!') do for /f %%j in ('%0 calc !t2!') do (
set /a t=%%j-%%i
echo !t!
)
popd
exit /b
goto :eof
:calc
set /a t=(%1*(3600*1000))+(%2*(60*1000))+(%3*1000)+(%4)
echo !t!
goto :eof
endlocal
Je nachdem, welche Windows-Version Sie verwenden, wird durch Ausführen von bash
der Bash-Modus aktiviert. Auf diese Weise können Sie eine Reihe von Befehlen verwenden, die nicht direkt in PowerShell verfügbar sind (wie der Befehl time
). Das Timing Ihres Befehls ist jetzt so einfach wie das Ausführen:
# The clause <your-command> (without the angle brackets) denotes the command you want to run.
$ time <your-command>
Hinweis: Sie können den Bash-Modus einfach beenden und in die Mainstream-Shell zurückkehren, indem Sie im Bash-Modus
exit
ausführen.
Dies funktionierte perfekt für mich (Windows 10), nachdem ich andere Methoden ausprobiert hatte (wie Measure-Command
), die manchmal unerwünschte Werte erzeugen. Ich hoffe, das funktioniert auch für Sie.
Geben Sie in dem Verzeichnis, in dem sich Ihr Programm befindet, notepad mytimer.bat
ein, klicken Sie auf "Ja", um eine neue Datei zu erstellen.
Fügen Sie den Code unten ein, ersetzen Sie YourApp.exe
durch Ihr Programm und speichern Sie dann.
@echo off
date /t
time /t
YourApp.exe
date /t
time /t
Geben Sie mytimer.bat
in die Befehlszeile ein und drücken Sie die Eingabetaste.
Die Antwort von driblio kann etwas kürzer gemacht werden (wenn auch nicht viel lesbar)
@echo off
:: Calculate the start timestamp
set _time=%time%
set /a _hours=100%_time:~0,2%%%100,_min=100%_time:~3,2%%%100,_sec=100%_time:~6,2%%%100,_cs=%_time:~9,2%
set /a _started=_hours*60*60*100+_min*60*100+_sec*100+_cs
:: yourCommandHere
:: Calculate the difference in cSeconds
set _time=%time%
set /a _hours=100%_time:~0,2%%%100,_min=100%_time:~3,2%%%100,_sec=100%_time:~6,2%%%100,_cs=%_time:~9,2%
set /a _duration=_hours*60*60*100+_min*60*100+_sec*100+_cs-_started
:: Populate variables for rendering (100+ needed for padding)
set /a _hours=_duration/60/60/100,_min=100+_duration/60/100%%60,_sec=100+(_duration/100%%60%%60),_cs=100+_duration%%100
echo Done at: %_time% took : %_hours%:%_min:~-2%:%_sec:~-2%.%_cs:~-2%
::prints something like:
::Done at: 12:37:53,70 took: 0:02:03.55
Zur Bemerkung von Luke Sampson ist diese Version octal-sicher, obwohl die Aufgabe in 24 Stunden abgeschlossen sein sollte.
Nachdem Perl die verfügbare Hires-Lösung installiert hat, führen Sie Folgendes aus:
C:\BATCH>time.pl "echo Fine result"
0.01063
Fine result
STDERR kommt vor den gemessenen Sekunden
#!/usr/bin/Perl -w
use Time::HiRes qw();
my $T0 = [ Time::HiRes::gettimeofday ];
my $stdout = `@ARGV`;
my $time_elapsed = Time::HiRes::tv_interval( $T0 );
print $time_elapsed, "\n";
print $stdout;
"Lean and Mean" TIMER mit Regionalformat, 24h und Unterstützung für gemischte Eingaben
Anpassung Aacinis Substitutionsmethode Körper, keine IFs, nur ein FOR (mein regionaler Fix)
1: Datei timer.bat irgendwo in% PATH% oder im aktuellen Verzeichnis abgelegt
@echo off & rem :AveYo: compact timer function with Regional format, 24-hours and mixed input support
if not defined timer_set (if not "%~1"=="" (call set "timer_set=%~1") else set "timer_set=%TIME: =0%") & goto :eof
(if not "%~1"=="" (call set "timer_end=%~1") else set "timer_end=%TIME: =0%") & setlocal EnableDelayedExpansion
for /f "tokens=1-6 delims=0123456789" %%i in ("%timer_end%%timer_set%") do (set CE=%%i&set DE=%%k&set CS=%%l&set DS=%%n)
set "TE=!timer_end:%DE%=%%100)*100+1!" & set "TS=!timer_set:%DS%=%%100)*100+1!"
set/A "T=((((10!TE:%CE%=%%100)*60+1!%%100)-((((10!TS:%CS%=%%100)*60+1!%%100)" & set/A "T=!T:-=8640000-!"
set/A "cc=T%%100+100,T/=100,ss=T%%60+100,T/=60,mm=T%%60+100,hh=T/60+100"
set "value=!hh:~1!%CE%!mm:~1!%CE%!ss:~1!%DE%!cc:~1!" & if "%~2"=="" echo/!value!
endlocal & set "timer_end=%value%" & set "timer_set=" & goto :eof
Verwendungszweck:
timer _ & echo start_cmds & timeout/t 3 & echo end_cmds &timer
timer & timer "23: 23: 23,00"
timer "23: 23: 23,00" & timer
timer "13.23.23,00" & timer "03: 03: 03.00"
timer & timer "0: 00: 00.00" nein & cmd/v: on/c Echo bis Mitternacht =! timer_end!
Die Eingabe kann jetzt gemischt werden, für unwahrscheinliche, aber mögliche Formatänderungen während der Ausführung.
2: Funktion : timer im Batch-Skript enthalten (Verwendungsbeispiel unten):
@echo off
set "TIMER=call :timer" & rem short macro
echo.
echo EXAMPLE:
call :timer
timeout /t 3 >nul & rem Any process here..
call :timer
echo.
echo SHORT MACRO:
%TIMER% & timeout /t 1 & %TIMER%
echo.
echo TEST INPUT:
set "start=22:04:04.58"
set "end=04.22.44,22"
echo %start% ~ start & echo %end% ~ end
call :timer "%start%"
call :timer "%end%"
echo.
%TIMER% & %TIMER% "00:00:00.00" no
echo UNTIL MIDNIGHT: %timer_end%
echo.
pause
exit /b
:: um es zu testen, fügen Sie sowohl über als auch unter den Codeabschnitten das Kopieren und Einfügen ein
rem :AveYo: compact timer function with Regional format, 24-hours and mixed input support
:timer Usage " call :timer [input - optional] [no - optional]" :i Result printed on second call, saved to timer_end
if not defined timer_set (if not "%~1"=="" (call set "timer_set=%~1") else set "timer_set=%TIME: =0%") & goto :eof
(if not "%~1"=="" (call set "timer_end=%~1") else set "timer_end=%TIME: =0%") & setlocal EnableDelayedExpansion
for /f "tokens=1-6 delims=0123456789" %%i in ("%timer_end%%timer_set%") do (set CE=%%i&set DE=%%k&set CS=%%l&set DS=%%n)
set "TE=!timer_end:%DE%=%%100)*100+1!" & set "TS=!timer_set:%DS%=%%100)*100+1!"
set/A "T=((((10!TE:%CE%=%%100)*60+1!%%100)-((((10!TS:%CS%=%%100)*60+1!%%100)" & set/A "T=!T:-=8640000-!"
set/A "cc=T%%100+100,T/=100,ss=T%%60+100,T/=60,mm=T%%60+100,hh=T/60+100"
set "value=!hh:~1!%CE%!mm:~1!%CE%!ss:~1!%DE%!cc:~1!" & if "%~2"=="" echo/!value!
endlocal & set "timer_end=%value%" & set "timer_set=" & goto :eof
CE, DE und CS, DS stehen für Doppelpunkt, Endpunkt und Doppelpunkt, Punktsatz - wird für die Unterstützung gemischter Formate verwendet
Das folgende Skript emuliert * nix Epoche, ist jedoch lokal und regional. Es sollte für Edge-Fälle mit Kalendern einschließlich Schaltjahren geeignet sein. Wenn Cygwin verfügbar ist, können Epochenwerte mit der Option Cygwin verglichen werden.
Ich bin in EST und der gemeldete Unterschied beträgt 4 Stunden, was relativ korrekt ist. Es gibt einige interessante Lösungen, um die TZ und regionale Abhängigkeiten zu beseitigen, aber nichts Triviales, das mir aufgefallen ist.
@ECHO off
SETLOCAL EnableDelayedExpansion
::
:: Emulates local Epoch seconds
::
:: Call passing local date and time
CALL :SECONDS "%DATE%" "%TIME%"
IF !SECONDS! LEQ 0 GOTO END
:: Not testing - print and exit
IF NOT "%~1"=="cygwin" (
ECHO !SECONDS!
GOTO END
)
:: Call on Cygwin to get Epoch time
FOR /F %%c IN ('C:\cygwin\bin\date +%%s') DO SET Epoch=%%c
:: Show the results
ECHO Local Seconds: !SECONDS!
ECHO Epoch Seconds: !Epoch!
:: Calculate difference between script and Cygwin
SET /A HOURS=(!Epoch!-!SECONDS!)/3600
SET /A FRAC=(!Epoch!-!SECONDS!)%%3600
:: Delta hours shown reflect TZ
ECHO Delta Hours: !HOURS! Remainder: !FRAC!
GOTO END
:SECONDS
SETLOCAL EnableDelayedExpansion
:: Expecting values from caller
SET DATE=%~1
SET TIME=%~2
:: Emulate Unix Epoch time without considering TZ
SET "SINCE_YEAR=1970"
:: Regional constraint! Expecting date and time in the following formats:
:: Sun 03/08/2015 Day MM/DD/YYYY
:: 20:04:53.64 HH:MM:SS
SET VALID_DATE=0
ECHO !DATE! | FINDSTR /R /C:"^... [0-9 ][0-9]/[0-9 ][0-9]/[0-9][0-9][0-9][0-9]" > nul && SET VALID_DATE=1
SET VALID_TIME=0
ECHO !TIME! | FINDSTR /R /C:"^[0-9 ][0-9]:[0-9 ][0-9]:[0-9 ][0-9]" > nul && SET VALID_TIME=1
IF NOT "!VALID_DATE!!VALID_TIME!"=="11" (
IF !VALID_DATE! EQU 0 ECHO Unsupported Date value: !DATE! 1>&2
IF !VALID_TIME! EQU 0 ECHO Unsupported Time value: !TIME! 1>&2
SET SECONDS=0
GOTO SECONDS_END
)
:: Parse values
SET "YYYY=!DATE:~10,4!"
SET "MM=!DATE:~4,2!"
SET "DD=!DATE:~7,2!"
SET "HH=!TIME:~0,2!"
SET "NN=!TIME:~3,2!"
SET "SS=!TIME:~6,2!"
SET /A YEARS=!YYYY!-!SINCE_YEAR!
SET /A DAYS=!YEARS!*365
:: Bump year if after February - want leading zeroes for this test
IF "!MM!!DD!" GEQ "0301" SET /A YEARS+=1
:: Remove leading zeros that can cause octet probs for SET /A
FOR %%r IN (MM,DD,HH,NN,SS) DO (
SET "v=%%r"
SET "t=!%%r!"
SET /A N=!t:~0,1!0
IF 0 EQU !N! SET "!v!=!t:~1!"
)
:: Increase days according to number of leap years
SET /A DAYS+=(!YEARS!+3)/4-(!SINCE_YEAR!%%4+3)/4
:: Increase days by preceding months of current year
FOR %%n IN (31:1,28:2,31:3,30:4,31:5,30:6,31:7,31:8,30:9,31:10,30:11) DO (
SET "n=%%n"
IF !MM! GTR !n:~3! SET /A DAYS+=!n:~0,2!
)
:: Multiply and add it all together
SET /A SECONDS=(!DAYS!+!DD!-1)*86400+!HH!*3600+!NN!*60+!SS!
:SECONDS_END
ENDLOCAL & SET "SECONDS=%SECONDS%"
GOTO :EOF
:END
ENDLOCAL
Hier ist meine Methode, keine Konvertierung und keine ms. Es ist nützlich, die Kodierungsdauer zu bestimmen (allerdings auf 24 Stunden begrenzt):
@echo off
:start
REM Start time storage
set ST=%time%
echo Process started at %ST%
echo.
echo.
REM Your commands
REM Your commands
REM Your commands
:end
REM Start Time Definition
for /f "tokens=1-3 delims=:" %%a in ("%ST%") do set /a h1=%%a & set /a m1=%%b & set /a s1=%%c
REM End Time Definition
for /f "tokens=1-3 delims=:" %%a in ("%TIME%") do set /a h2=%%a & set /a m2=%%b & set /a s2=%%c
REM Difference
set /a h3=%h2%-%h1% & set /a m3=%m2%-%m1% & set /a s3=%s2%-%s1%
REM Time Adjustment
if %h3% LSS 0 set /a h3=%h3%+24
if %m3% LSS 0 set /a m3=%m3%+60 & set /a h3=%h3%-1
if %s3% LSS 0 set /a s3=%s3%+60 & set /a m3=%m3%-1
echo Start : %ST%
echo End : %time%
echo.
echo Total : %h3%:%m3%:%s3%
echo.
pause
Process Explorer zeigt Kernel-Zeit, Benutzerzeit und Wandzeit (und viele andere Dinge) an, solange Sie auf den Prozess klicken, bevor er beendet wird. Es ist kein Befehlszeilentool, aber es ist trotzdem sehr nützlich.
Für das Nice-Skript von Luke Sampson sollten die Korrekturen für negative Werte in umgekehrter Reihenfolge durchgeführt werden, da sie dazu führen können, dass ein zuvor 0-Wert negativ wird.
Nehmen Sie zum Beispiel eine Zeit, bei der die anfängliche Subtraktion 1 Stunde, 0 Minuten ergibt. und -29 Sekunden. Wie in der Post erfolgt das Ergebnis 1 Stunde, -1 Minuten und 31 Sekunden. Wenn die Sekunden vor Minuten und Minuten vor Stunden korrigiert werden, erhalten Sie stattdessen 31 Sekunden, 59 Minuten und 0 Stunden.
Verwenden Sie ein U-Boot, um die Zeit in Hundertstel Sekunden zurückzugeben
::tiemeit.cmd
@echo off
Setlocal EnableDelayedExpansion
call :clock
::call your_command or more > null to pipe this batch after your_command
call :clock
echo %timed%
pause
goto:eof
:clock
if not defined timed set timed=0
for /F "tokens=1-4 delims=:.," %%a in ("%time%") do (
set /A timed = "(((1%%a - 100) * 60 + (1%%b - 100)) * 60 + (1%%c - 100)) * 100 + (1%%d - 100)- %timed%"
)
goto:eof