Comment mesurer le temps d'exécution d'une commande sur la ligne de commande Windows?
Existe-t-il un moyen intégré pour mesurer le temps d'exécution d'une commande sur la ligne de commande Windows?
Si vous utilisez Windows 2003 (notez que Windows Server 2008 et versions ultérieures ne sont pas pris en charge), vous pouvez utiliser le Kit de ressources Windows Server 2003, qui contient timeit.exe qui affiche des statistiques d'exécution détaillées. Voici un exemple, chronométrant la commande "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
Vous pouvez obtenir TimeIt dans le Kit de ressources Windows 2003. Téléchargez-le ici .
Windows PowerShell a également une commande intégrée similaire à la commande "time" de Bash. Cela s'appelle "Mesure-Commande". Vous devrez vous assurer que PowerShell est installé sur la machine qui l'exécute.
Exemple d'entrée:
Measure-Command {echo hi}
Exemple de sortie:
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
Si tu veux
- Pour mesurer le temps d'exécution au centième de seconde au format (hh: mm: ss.ff)
- Pour ne pas avoir à télécharger et installer un pack de ressources
- Pour ressembler à un énorme nerd DOS (qui ne le fait pas)
Essayez de copier le script suivant dans un nouveau fichier batch (par exemple, 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)
Utilisation
Si vous mettez timecmd.bat dans un répertoire de votre chemin, vous pouvez l’appeler à partir de n’importe où comme ceci:
timecmd [your command]
Par exemple.
C:\>timecmd pause
Press any key to continue . . .
command took 0:0:1.18
Si vous souhaitez effectuer une redirection de sortie, vous pouvez citer la commande comme suit:
timecmd "dir c:\windows /s > nul"
Cela devrait gérer les commandes qui vont d’avant-après minuit, mais la sortie sera fausse si votre commande dure 24 heures ou plus.
Hehe, la solution la plus simple pourrait être la suivante:
echo %time%
YourApp.exe
echo %time%
Cela fonctionne sur tous les Windows hors de la boîte.
Dans le cas d’une application utilisant la sortie de la console, il peut être pratique de stocker l’heure de début dans une variable temporaire:
set startTime=%time%
YourApp.exe
echo Start Time: %startTime%
echo Finish Time: %time%
Juste une petite extension de la réponse de Casey.K à propos de l’utilisation du Measure-Command from PowerShell :
Vous pouvez appeler PowerShell à partir de l'invite de commande standard, comme suit:
powershell -Command "Measure-Command {echo hi}"Cela consommera la sortie standard, mais vous pouvez éviter cela en ajoutant
| Out-Defaultcomme ceci depuis PowerShell:Measure-Command {echo hi | Out-Default}Ou à partir d'une invite de commande:
powershell -Command "Measure-Command {echo hi | Out-Default}"
Bien sûr, vous êtes libre d’envelopper cela dans un fichier script *.ps1 ou *.bat.
Le one-liner que j'utilise dans Windows Server 2008 R2 est:
cmd /v:on /c "echo !TIME! & *mycommand* & echo !TIME!"
Tant que mycommand ne nécessite pas de devis (ce qui se fait avec le traitement des devis de cmd) Le /v:on permet aux deux valeurs TIME différentes d'être évaluées indépendamment plutôt qu'une fois lors de l'exécution de la commande.
Si vous avez une fenêtre de commande ouverte et appelez les commandes manuellement, vous pouvez afficher un horodatage sur chaque invite, par exemple.
Prompt $d $t $_$P$G
Cela vous donne quelque chose comme:
23.03.2009 15:45:50,77
C:\>
Si vous avez un petit script batch qui exécute vos commandes, veillez à laisser une ligne vide avant chaque commande, par exemple.
(ligne vide)
myCommand.exe
(ligne vide suivante)
myCommand2.exe
Vous pouvez calculer le temps d'exécution de chaque commande à l'aide des informations de temps figurant dans l'invite. Le mieux serait probablement de diriger la sortie vers un fichier texte pour une analyse plus approfondie:
MyBatchFile.bat > output.txt
Etant donné que d’autres recommandent d’installer des éléments tels que les logiciels gratuits et PowerShell, vous pouvez également installer Cygwin , ce qui vous donnerait accès à de nombreuses commandes Unix de base telles que time :
abe@abe-PC:~$ time sleep 5
real 0m5.012s
user 0m0.000s
sys 0m0.000s
Je ne sais pas combien de temps supplémentaire Cygwin ajoute.
Pas tout à fait aussi élégant que certaines fonctionnalités sur Unix, mais créez un fichier cmd qui ressemble à:
@echo off
time < nul
yourexecutable.exe > c:\temp\output.txt
time < nul
rem on newer windows system you can try time /T
Cela affichera les heures de début et de fin de la manière suivante:
The current time is: 10:31:57.92
Enter the new time:
The current time is: 10:32:05.94
Enter the new time:
J'utilise un logiciel gratuit appelé "GS Timer".
Il suffit de créer un fichier de commandes comme ceci:
timer
yourapp.exe
timer /s
Si vous avez besoin d'un certain nombre de fois, dirigez simplement la sortie de timer/s dans un fichier .txt.
Vous pouvez l'obtenir ici: Utilitaires DOS gratuits de Gammadyne
La résolution est de 0,1 seconde.
J'utilise Windows XP et pour une raison quelconque, timeit.exe ne fonctionne pas pour moi. J'ai trouvé une autre alternative - PTIME. Cela fonctionne très bien.
http://www.pc-tools.net/win32/ptime/
Exemple -
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
Tant que cela ne dure pas plus de 24 heures ...
@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.
Il y a aussi TimeMem (mars 2012):
Il s’agit d’un utilitaire Windows qui exécute un programme et affiche son fichier temps d'exécution, utilisation de la mémoire et statistiques IO. C'est similaire dans fonctionnalité à l'utilitaire de temps Unix.
C'est un one-liner qui évite l'expansion retardée , qui pourrait perturber certaines commandes:
cmd /E /C "Prompt $T$$ & echo.%TIME%$ & COMMAND_TO_MEASURE & for %Z in (.) do rem/ "
La sortie est quelque chose comme:
14:30:27.58$ ... 14:32:43.17$ rem/
Pour les tests à long terme, remplacez $T par $D, $T et %TIME% par %DATE%, %TIME% pour inclure la date.
Pour utiliser ceci à l'intérieur d'un fichier batch, remplacez %Z par %%Z.
Mettre à jour
Voici un amélioré one-liner (sans expansion retardée aussi):
cmd /E /C "Prompt $D, $T$$ & (for %# in (.) do rem/ ) & COMMAND_TO_MEASURE & for %# in (.) do Prompt"
La sortie ressemble à ceci:
2015/09/01, 14:30:27.58$ rem/ ... 2015/09/01, 14:32:43.17$ Prompt
Cette approche n'inclut pas le processus d'instanciation d'une nouvelle cmd dans le résultat, ni la ou les commandes Prompt.
Si quelqu'un d'autre est venu chercher une réponse à cette question, il existe une fonction API Windows appelée GetProcessTimes() . Écrire un petit programme en langage C qui lancerait la commande, passerait cet appel et renverrait les temps de traitement ne semble pas trop demander.
Ceci est un commentaire/une modification du Nice timecmd.bat de Luke Sampson et sa réponse à
Pour une raison quelconque, cela ne me donne qu'une sortie en secondes entières ... ce qui pour moi est inutile. Je veux dire que je lance timecmd pause, et il en résulte toujours en 1.00 sec, 2.00 sec, 4.00 sec ... même 0.00 sec! Windows 7. - Camilo Martin 25 sept. 13 à 16h00 "
Sur certaines configurations, les délimiteurs peuvent différer. La modification suivante devrait concerner au moins la plupart des pays occidentaux.
set options="tokens=1-4 delims=:,." (added comma)
Les %time% millisecondes fonctionnent sur mon système après l'ajout de ','
(* car le site n'autorise pas de commentaire et ne garde pas de trace d'identité même si j'utilise toujours le même courrier électronique invité qui, associé à ipv6 ip et aux empreintes digitales du navigateur, devrait suffire à identifier sans mot de passe)
Une alternative à mesure-temps est simplement "Get-Date". Vous n'avez pas de problème avec le transfert de sortie, etc.
$start = Get-Date
[System.Threading.Thread]::Sleep(1500)
$(Get-Date) - $start
Sortie:
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
mon code vous indique la durée d'exécution, en millisecondes, jusqu'à 24 heures, il ne dépend pas de la localisation et tient compte des valeurs négatives si le code fonctionne jusqu'à minuit. il utilise une expansion retardée et doit être enregistré dans un fichier cmd/bat.
avant votre 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%
après votre 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
Si vous voulez que le temps d'exécution soit au format HH: mm: ss.000, ajoutez:
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
la variable t2 contient votre temps d'exécution, vous pouvez echo %t2% pour l'afficher.
@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.
Le script suivant utilise uniquement "cmd.exe" et génère le nombre de millisecondes à partir du moment où un pipeline est créé jusqu'à la fin du processus précédant le script. c.-à-d., tapez votre commande et transmettez-la au script. Exemple: "timeout 3 | runtime.cmd" devrait donner quelque chose comme "2990". Si vous avez besoin à la fois de la sortie d'exécution et de la sortie stdin, redirigez stdin avant le tube: ex: "dir/s 1> temp.txt | runtime.cmd" dumpait le résultat de la commande "dir" en "temp.txt" et imprimerait le runtime sur la console.
:: --- 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
Selon la version de Windows que vous utilisez, le fait d'exécuter bash vous fera passer en mode Bash. Cela vous permettra d'utiliser un ensemble de commandes qui ne sont pas disponibles directement sur PowerShell (comme la commande time). Programmer votre commande est maintenant aussi simple que d’exécuter:
# The clause <your-command> (without the angle brackets) denotes the command you want to run.
$ time <your-command>
Remarque: Vous pouvez facilement quitter le mode Bash et revenir à votre shell principal en exécutant
exiten mode Bash.
Cela fonctionnait parfaitement pour moi (Windows 10) après avoir essayé d’autres méthodes (comme Measure-Command) qui produisent parfois des statistiques indésirables. J'espère que cela fonctionne pour vous aussi.
Dans le répertoire où se trouve votre programme, tapez
notepad mytimer.bat, cliquez sur "oui" pour créer un nouveau fichier.Collez le code ci-dessous, en remplaçant
YourApp.exepar votre programme, puis enregistrez.@echo off date /t time /t YourApp.exe date /t time /tTapez
mytimer.batdans la ligne de commande, puis appuyez sur Entrée.
La réponse de driblio peut être un peu plus courte (bien que peu lisible)
@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
Pour le remarque de Luke Sampson, cette version est octal sauf, mais la tâche devrait être terminée dans 24 heures.
Une fois que Perl a installé la solution de recrutement disponible, exécutez:
C:\BATCH>time.pl "echo Fine result"
0.01063
Fine result
STDERR vient avant les secondes mesurées
#!/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 avec format régional, prise en charge 24h/24 et entrées mixtes
Adaptation Aacini organisme de méthode de substitution, pas de FI, juste un FOR (mon correctif régional)
1: Fichier timer.bat placé quelque part dans% PATH% ou le répertoire en cours
@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
Usage:
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" no & cmd/v: on/c echo jusqu'à minuit =! timer_end!
L'entrée peut maintenant être mélangée, pour ceux improbables, mais les changements de format d'heure possibles pendant l'exécution
2: Fonction : timer fournie avec le script batch (exemple d'utilisation ci-dessous):
@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
:: pour le tester, copier-coller les sections de code ci-dessus et ci-dessous
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 et CS, DS désignent l'extrémité, la fin et le point du colon, ensemble de points, utilisé pour la prise en charge de formats mixtes
Le script suivant émule l’époque * nix, mais il est local et régional. Il convient de gérer les cas Edge Edge, y compris les années bissextiles. Si Cygwin est disponible, les valeurs Epoch peuvent être comparées en spécifiant l'option Cygwin.
Je suis en HNE et la différence signalée est de 4 heures, ce qui est relativement correct. Il existe des solutions intéressantes pour supprimer les dépendances TZ et régionales, mais rien d’indique que j’ai remarqué.
@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
Voici ma méthode, pas de conversion et pas de ms. Il est utile de déterminer les durées d’encodage (toutefois limitées à 24 heures):
@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 affichera l'heure du noyau, l'heure de l'utilisateur et l'heure du mur (et plein d'autres choses) tant que vous cliquez sur le processus avant de le quitter. Ce n'est pas un outil de ligne de commande, mais il est extrêmement utile quand même.
Pour le script Nice de Luke Sampson, les corrections pour les valeurs négatives doivent être effectuées dans l'ordre inverse car elles peuvent rendre une valeur précédemment nulle négative.
Prenons par exemple un temps où la soustraction initiale donne 1 heure, 0 min. et -29 secondes. Comme cela a été fait dans le post, le résultat sera 1 heure, -1 min et 31 secondes. Si les secondes sont corrigées avant les minutes et les minutes avant les heures, vous obtenez 31 secondes, 59 minutes et 0 heures.
Utiliser un sous-marin pour renvoyer le temps en centièmes de seconde
::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