Comment mesurer le temps d'exécution d'une commande sur la ligne de commande Windows?

alternativement, Windows PowerShell a une commande intégrée qui est similaire à la commande" time " de Bash. On l'appelle " Mesure-commande."Vous devez 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 vous voulez

1. pour mesurer le temps d'exécution jusqu'au centième de seconde en (hh:mm:SS.format ff)
2. pour ne pas avoir À télécharger et installer un pack de ressources
3. pour ressembler À un énorme DOS nerd (qui ne fait pas)

essayez de copier le script suivant dans un nouveau fichier par lots (par exemple timecmd.chauve-souris ):

@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)

L'utilisation de la

si vous mettez timecmd.bat dans un répertoire de votre chemin, vous pouvez l'appeler de n'importe où comme ceci:

timecmd [your command]

E. G.

C:\>timecmd pause
Press any key to continue . . .
command took 0:0:1.18

si vous voulez faire la redirection de sortie, vous pouvez citer la commande comme suit:

timecmd "dir c:\windows /s > nul"

Ce qui devrait gérer les commandes qui s'exécutent avant - après-minuit, mais le résultat sera mauvais si votre commande s'exécute pendant 24 heures ou plus.

Hehe, la solution la plus simple pourrait être celle-ci:

echo %time%
YourApp.exe
echo %time%

cela fonctionne sur toutes les fenêtres de la boîte.

dans le cas d'une application utilisant la sortie de la console, il peut être commode de stocker l'Heure de départ dans une variable temporaire:

set startTime=%time%
YourApp.exe
echo Start Time: %startTime%
echo Finish Time: %time%

une petite extension de la réponse de Casey.K sur l'utilisation de la Measure-Command à partir de PowerShell :

1. vous pouvez invoquer PowerShell à partir de l'invite de commande standard, comme ceci:

   powershell -Command "Measure-Command {echo hi}"
   

2. cela va manger la sortie standard, mais vous pouvez empêcher cela en ajoutant | Out-Default comme ceci de 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 de l'envelopper dans un fichier de script *.ps1 ou *.bat .

la doublure unique que J'utilise dans Windows Server 2008 R2 est:

cmd /v:on /c "echo !TIME! & *mycommand* & echo !TIME!"

aussi longtemps que mycommand ne nécessite pas de devis (qui visse avec le traitement de devis cmd). Le /v:on doit permettre que les deux valeurs de temps différentes soient évaluées indépendamment plutôt qu'une seule fois à 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

il vous donne quelque chose comme:

23.03.2009 15:45:50,77

C:\>

si vous avez un petit script par lot qui exécute vos commandes, avoir 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 par les informations de temps dans l'invite. Le mieux serait probablement de faire passer la sortie dans un fichier texte pour une analyse plus poussée:

MyBatchFile.bat > output.txt

puisque d'autres recommandent d'installer des choses comme freeware et PowerShell, vous pouvez aussi installer Cygwin , ce qui vous donnerait accès à de nombreuses commandes Unix de base comme time :

abe@abe-PC:~$ time sleep 5

real    0m5.012s
user    0m0.000s
sys 0m0.000s

Je ne sais pas combien Cygwin ajoute.

pas aussi élégant que certaines fonctionnalités D'Unix, mais créer 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

qui affichera les heures de début et d'arrêt comme ceci:

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 freeware appelé"GS Timer".

il suffit de faire un fichier par lot comme ceci:

timer
yourapp.exe
timer /s

si vous avez besoin d'un ensemble de temps, simplement pipe la sortie de minuterie /s dans un .fichier txt.

Vous pouvez l'obtenir ici: Gammadyne Gratuit Utilitaires DOS

la résolution est de 0,1 seconde.

J'utilise Windows XP et pour une raison quelconque timeit.exe ne travaille 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 <jberkes@pc-tools.net>

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 <jberkes@pc-tools.net>

===  cd ===
C:\

Execution time: 0.015 s

tant qu'il ne dure pas plus de 24heures...

@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 Timem (mars 2012):

il s'agit d'un utilitaire Windows qui exécute un programme et affiche son temps d'exécution, utilisation de la mémoire et statistiques D'entrées-sorties. Il est semblable dans fonctionnalité de L'utilitaire Unix time.

il s'agit D'une doublure unique qui évite expansion retardée , ce 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 essais à long terme, remplacer $T par $D, $T et %TIME% par %DATE%, %TIME% pour inclure la date.

pour utiliser cette partie d'un fichier de lot , remplacer %Z par %%Z .

mise à Jour

voici un revêtement amélioré (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'instancing d'un nouveau cmd dans le résultat, pas plus que il comprend la commande prompt .

voici un

Postfix minuterie version:

exemple d'utilisation:

délai d'attente 1 | TimeIt.cmd

Execution took  ~969 milliseconds.

copiez et collez ceci dans un éditeur comme par exemple Notepad++ et enregistrez-le comme 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

^ - basé sur "Daniel Sparks" Version

dans le cas où quelqu'un d'autre est venu ici à la recherche d'une réponse à cette question, Il ya une fonction API Windows appelé GetProcessTimes() . Il ne semble pas y avoir trop de travail pour écrire un petit programme C qui démarrerait la commande, ferait cet appel, et retournerait les temps de processus.

Ce , un commentaire/modifier Luc Sampson est gentil timecmd.bat et répond à

pour une raison quelconque, cela ne me donne la sortie qu'en secondes entières... qui pour moi est inutile. Je veux dire que j'exécute timecmd pause, et il en résulte toujours en 1.00 sec, 2.00 sec, 4.00 sec... même 0,00 seconde! Windows 7. - Camilo Martin Sep 25 '13 at 16: 00 "

Sur certaines configurations, les délimiteurs peuvent différer. Le les modifications suivantes devraient concerner au moins la plupart des pays occidentaux.

set options="tokens=1-4 delims=:,." (added comma)

le %time% millisecondes de travail sur mon système après avoir ajouté que', '

(*parce que le site ne permet pas de commentaire anon et ne garde pas une bonne trace de l'identité même si j'utilise toujours le même e-mail invité qui combiné avec ipv6 IP et l'empreinte digitale du navigateur devrait être suffisant pour identifier uniquement sans mot de passe)

@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 n'utilise que" cmd.exe" et renvoie le nombre de millisecondes entre le moment où un pipeline est créé au moment où le processus précédant le script se termine. i.e., Tapez votre commande, et pipez le au script. Exemple: "délai d'attente de 3 | de l'exécution.cmd" devrait donner quelque chose comme "2990."Si vous avez besoin à la fois de la sortie runtime et de la sortie stdin, redirigez stdin avant la pipe - ex:" dir /s 1>temp.txt / runtime.cmd " dumperait la sortie de la commande "dir" à "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

La réponse de driblio peut être fait un peu plus court (mais pas bien 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

à la remarque de Luke Sampson cette version est octal sûr, bien que la tâche devrait être terminée dans 24 heures.

mon code vous donne le temps de fonctionnement en millisecondes, jusqu'à 24 heures, il est insensible à la localisation, et tient compte des valeurs négatives si le code passe à minuit. il utilise une extension retardée, et doit être sauvegardé 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 souhaitez exécuter l'heure au format HH:mm:ss.000 format, ajouter:

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

variable t2 tient votre durée de fonctionnement, vous pouvez echo %t2% pour l'afficher.

à l'Aide d'un sous à revenir de 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

"Lean and Mean" TIMER avec format Régional, le 24 et mixtes de saisie

L'adaptation de Aacini méthode de substitution de corps, pas SI, juste une POUR (mon niveau régional)

1: le Fichier de la minuterie.bat placé quelque part dans le % chemin% ou le dir actuel

@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:

minuterie & echo start_cmds & timeout /t 3 de l'écho et des end_cmds & timer

timer & timer "23:23:23,00"

minuterie "23:23:23,00" & minuterie

minuterie "13.23.23,00" & minuterie "03:03:03.00"

timer & timer "0:00:00.00" no & cmd /v:sur /c echo jusqu'à minuit=!timer_end!

L'entrée peut maintenant être mélangée, pour ceux peu probables, mais des changements de format de temps possibles pendant l'exécution

2: Fonction : minuterie fournie avec le script de lot (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 à la fois au-dessus et en dessous des sections de code

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 stand du côlon fin, le point de fin et du côlon ensemble, point - utilisé pour mixte en charge du format

1. dans le répertoire où se trouve votre programme, tapez notepad mytimer.bat , cliquez sur " Oui " pour créer un nouveau fichier.

2. collez le code ci-dessous, en remplaçant YourApp.exe par votre programme, puis enregistrez.

   @echo off
   date /t
   time /t
   YourApp.exe
   date /t
   time /t
   

3. Tapez mytimer.bat dans la ligne de commande appuyez ensuite sur Enter.

Process Explorer affichera l'heure du noyau, l'Heure de l'utilisateur, l'heure du mur (et beaucoup d'autres choses) tant que vous cliquez sur le processus avant qu'il ne sorte. Ce n'est pas un outil de ligne de commande, mais il est extrêmement utile de toute façon.

pour le script nice de Luke Sampson, les corrections pour les valeurs négatives doivent être faites dans l'ordre inverse car elles peuvent faire passer une valeur 0 précédemment négative.

prendre par exemple un temps où la soustraction initiale donne 1 heure, 0 min. et -29 secondes. Comme fait dans le post le résultat sera 1 heure, -1 min, et 31 secondes. Si les secondes sont corrigées avant minutes et minutes avant heures, vous obtenez 31 secondes, 59 min, 0 heures.

le script suivant émule *nix époque, mais il est local et régional. Il devrait traiter les cas de bordures de calandre, y compris les années bissextiles. Si Cygwin est disponible, les valeurs d'époque peuvent être comparées en spécifiant l'option Cygwin .

je suis dans L'EST et la différence signalée est de 4 heures ce qui est relativement correct. Il y a quelques solutions intéressantes pour supprimer la TZ et les dépendances régionales, mais rien de trivial 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 (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

une alternative à la mesure-le temps est simplement"Get-Date". Vous n'avez pas ce tracas avec la sortie de renvoi et ainsi de suite.

$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