क्या विंडोज कमांड लाइन पर कमांड के निष्पादन समय को मापने का एक अंतर्निहित तरीका है?
जवाबों:
यदि आप Windows 2003 का उपयोग कर रहे हैं (ध्यान दें कि Windows Server 2008 और बाद में समर्थित नहीं हैं) तो आप Windows Server 2003 संसाधन किट का उपयोग कर सकते हैं, जिसमें timeit.exe होता है जो विस्तृत निष्पादन आँकड़े प्रदर्शित करता है। यहाँ एक उदाहरण है, कमांड "टाइमिट -?":
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
आप Windows 2003 संसाधन किट में TimeIt प्राप्त कर सकते हैं। इसे यहाँ डाउनलोड करें ।
वैकल्पिक रूप से, Windows PowerShell में एक अंतर्निहित कमांड है जो बैश के "टाइम" कमांड के समान है। इसे "माप-कमान" कहा जाता है। आपको यह सुनिश्चित करना होगा कि PowerShell उस मशीन पर स्थापित है जो इसे चलाता है।
उदाहरण इनपुट:
Measure-Command {echo hi}
उदाहरण आउटपुट:
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
.exeवर्तमान निर्देशिका में बेंचमार्किंग कर रहे हैं , तो इसका उपयोग करें Measure-Command { .\your.exe }:। PowerShell स्पष्ट pwdरूप से चीजों को तब तक नहीं चलाता जब तक कि स्पष्ट रूप से नहीं बताया गया हो।
<stdout> घुंघराले कोष्ठक में संलग्न कमांड के परिणामों पर लौटता है !
अगर तुम चाहते हो
निम्नलिखित स्क्रिप्ट को एक नई बैच फ़ाइल में कॉपी करने का प्रयास करें (जैसे 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)
प्रयोग
यदि आप अपने पथ में एक निर्देशिका में timecmd.bat डालते हैं, तो आप इसे इस तरह से कहीं से भी कॉल कर सकते हैं:
timecmd [your command]
उदाहरण के लिए
C:\>timecmd pause
Press any key to continue . . .
command took 0:0:1.18
यदि आप आउटपुट पुनर्निर्देशन करना चाहते हैं, तो आप कमांड को इस तरह उद्धृत कर सकते हैं:
timecmd "dir c:\windows /s > nul"
इससे पहले से लेकर मध्यरात्रि तक चलने वाले आदेशों को संभालना चाहिए, लेकिन यदि आपकी आज्ञा 24 घंटे या अधिक समय तक चलती है तो आउटपुट गलत होगा।
timecmd pause, और इसका परिणाम हमेशा 1.00 सेकंड, 2.00 सेकंड, 4.00 सेकंड ... यहां तक कि 0.00 सेकंड में होता है! विंडोज 7.
delims=:.दें delims=:.,और फिर इसे "पूरे मंडल में" काम करना चाहिए।
set start=10:10:10.10 set end=10:11:10.09और यह आउटपुट देगा: command took 0:1:-1.99 (59.99s total) आपको "lss 0" तुलना करने वाली 4 पंक्तियों के क्रम को उल्टा करना चाहिए, ताकि कैरी कम से उच्च लिंगानुपात अंकों तक सही ढंग से आगे बढ़े। फिर आउटपुट बन जाता है: command took 0:0:59.99 (59.99s total)
हे, सबसे सरल समाधान यह हो सकता है:
echo %time%
YourApp.exe
echo %time%
यह हर विंडोज बॉक्स से बाहर काम करता है।
कंसोल आउटपुट का उपयोग करने वाले एप्लिकेशन के मामले में, शुरुआती समय को अस्थायी चर में स्टोर करना सुविधाजनक हो सकता है:
set startTime=%time%
YourApp.exe
echo Start Time: %startTime%
echo Finish Time: %time%
set startTime=%time% \n YourApp.exe \n echo Start Time: %startTime% \n echo Finish Time: %time% (क्षमा करें, टिप्पणी में नई जानकारी नहीं मिल सकती)
setगणित करने के लिए उपयोग कर सकते हैं । ;-)ओह रुको, कभी नहीं, आप पहले से ही नीचे किया था।
बस के एक छोटे से विस्तार Casey.K से जवाब का उपयोग कर के बारे में Measure-Commandसे PowerShell :
आप इस तरह से मानक कमांड प्रॉम्प्ट से PowerShell को लागू कर सकते हैं:
powershell -Command "Measure-Command {echo hi}"
यह मानक आउटपुट खाएगा, लेकिन आप इसे | Out-DefaultPowerShell से इस तरह जोड़कर रोक सकते हैं :
Measure-Command {echo hi | Out-Default}
या कमांड प्रॉम्प्ट से:
powershell -Command "Measure-Command {echo hi | Out-Default}"
बेशक, आप इसे स्क्रिप्ट फ़ाइल में लपेटने के लिए स्वतंत्र हैं *.ps1या *.bat।
measureTime.bat "c:\program files\some dir\program.exe"
Windows Server 2008 R2 में मेरे द्वारा उपयोग किया जाने वाला एक-लाइनर है:
cmd /v:on /c "echo !TIME! & *mycommand* & echo !TIME!"
जब तक mycommand को उद्धरण की आवश्यकता नहीं होती है (जो cmd के उद्धरण प्रसंस्करण के साथ शिकंजा है)। /v:onआदेश के निष्पादन के एक ही बार में के बजाय स्वतंत्र रूप से मूल्यांकन किया जाना दो अलग-अलग समय मूल्यों के लिए अनुमति देने के लिए है।
^cmd (जैसे ^")
cmd /v:on /c echo !TIME! & echo "Quoted mycommand" & cmd /v:on /c echo !TIME!।
echo %time% & *mycommand* & call echo %^time%। इस उत्तर को भी देखें ।
cmd /v:on /c "mycommand & echo begin=%time% endtime=!time!"
यदि आपके पास कमांड विंडो खुली है और कमांड को मैन्युअल रूप से कॉल करते हैं, तो आप प्रत्येक प्रॉम्प्ट पर टाइमस्टैम्प प्रदर्शित कर सकते हैं, जैसे
prompt $d $t $_$P$G
यह आपको कुछ इस तरह देता है:
23.03.2009 15:45:50,77
C:\>
यदि आपके पास एक छोटा बैच स्क्रिप्ट है जो आपकी आज्ञाओं को क्रियान्वित करता है, तो प्रत्येक कमांड से पहले एक खाली लाइन है, जैसे
(खाली लाइन)
myCommand.exe
(अगली खाली लाइन)
myCommand2.exe
आप शीघ्र में समय की जानकारी के द्वारा प्रत्येक कमांड के लिए निष्पादन समय की गणना कर सकते हैं। सबसे अच्छा संभवतया आगे के विश्लेषण के लिए एक टेक्स्टफाइल के लिए आउटपुट को पाइप करना होगा:
MyBatchFile.bat > output.txt
चूंकि अन्य लोग फ्रीवेयर और पॉवरशेल जैसी चीजों को स्थापित करने की सिफारिश कर रहे हैं, आप सिग्विन भी स्थापित कर सकते हैं , जो आपको समय की तरह कई बुनियादी यूनिक्स कमांड तक पहुंच प्रदान करेगा :
abe@abe-PC:~$ time sleep 5
real 0m5.012s
user 0m0.000s
sys 0m0.000s
यह सुनिश्चित नहीं है कि सिगविन कितना ओवरहेड जोड़ता है।
यूनिक्स पर कुछ कार्यक्षमता के रूप में बहुत सुंदर नहीं है, लेकिन एक cmd फ़ाइल बनाएं जो दिखता है:
@echo off
time < nul
yourexecutable.exe > c:\temp\output.txt
time < nul
rem on newer windows system you can try time /T
ऐसा शुरू करने और रोकने के समय को प्रदर्शित करेगा:
The current time is: 10:31:57.92
Enter the new time:
The current time is: 10:32:05.94
Enter the new time:
timeमें एक /tविकल्प होता है जो सिर्फ वर्तमान सिस्टम समय को प्रदर्शित करता है, आपको नए समय में प्रवेश करने के लिए संकेत दिए बिना। हालाँकि जब आप ऐसा करते हैं तो यह केवल घंटों और मिनटों को प्रदर्शित करता है, जो कि कुछ उपयोगों के लिए पर्याप्त नहीं हो सकता है। (इस सवाल का जॉन स्नो का जवाब देखें।)
time /Tयदि प्रक्रिया कई मिनट तक चलती है तो ही प्रयोग करने योग्य है! time < nulबदसूरत है, लेकिन अधिक सटीक है।
echo %time%जो समान प्रारूप और सटीकता प्रदान करता है time < nul, लेकिन आप Enter the new time:आउटपुट से बचते हैं ...
wmic os get LocalDateTime
मैं फ्रीवेयर का उपयोग करता हूं जिसे "जीएस टाइमर" कहा जाता है।
बस इस तरह एक बैच फ़ाइल बनाएँ:
timer
yourapp.exe
timer /s
यदि आपको कई बार सेट की आवश्यकता होती है, तो टाइमर के आउटपुट को एक .txt फ़ाइल में पाइप करें।
आप इसे यहाँ प्राप्त कर सकते हैं: गमादीन की मुफ्त डॉस उपयोगिताएँ
संकल्प 0.1 सेकंड है।
मैं Windows XP का उपयोग कर रहा हूं और किसी कारण से timeit.exe मेरे लिए काम नहीं करता है। मुझे एक और विकल्प मिला - PTIME। यह बहुत अच्छा काम करता है।
http://www.pc-tools.net/win32/ptime/
उदाहरण -
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
वहाँ भी है TimeMem (मार्च 2012):
यह एक विंडोज यूटिलिटी है जो एक प्रोग्राम को निष्पादित करता है और इसके निष्पादन समय, मेमोरी उपयोग और IO आँकड़े प्रदर्शित करता है। यह यूनिक्स समय उपयोगिता के लिए कार्यक्षमता में समान है।
जब तक यह 24 घंटे से अधिक समय तक नहीं रहता है ...
@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.
यहां है
उपयोग उदाहरण:
टाइमआउट 1 | TimeIt.cmd
Execution took ~969 milliseconds.
उदाहरण के लिए नोटपैड ++ जैसे कुछ संपादक में इसे कॉपी और पेस्ट करें और इसे 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
^ - 'डैनियल स्पार्क्स' संस्करण पर आधारित
माप-समय का एक विकल्प केवल "गेट-डेट" है। आपके पास आउटपुट वगैरह के साथ वह परेशानी नहीं है।
$start = Get-Date
[System.Threading.Thread]::Sleep(1500)
$(Get-Date) - $start
आउटपुट:
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
यह एक-लाइनर है जो विलंबित विस्तार से बचता है , जो कुछ आदेशों को विचलित कर सकता है:
cmd /E /C "prompt $T$$ & echo.%TIME%$ & COMMAND_TO_MEASURE & for %Z in (.) do rem/ "
आउटपुट कुछ इस तरह है:
14:30:27.58$ ... 14:32:43.17$ rem/
तारीख को शामिल करने के लिए लंबी अवधि के परीक्षणों के $Tद्वारा $D, $Tऔर इसके %TIME%द्वारा प्रतिस्थापित किया जाता %DATE%, %TIME%है।
बैच फ़ाइल के अंदर इसका उपयोग करने के लिए , इसके %Zद्वारा प्रतिस्थापित करें %%Z।
यहां एक बेहतर वन-लाइनर है (बिना देरी किए विस्तार भी):
cmd /E /C "prompt $D, $T$$ & (for %# in (.) do rem/ ) & COMMAND_TO_MEASURE & for %# in (.) do prompt"
आउटपुट इस तरह दिखता है:
2015/09/01, 14:30:27.58$ rem/ ... 2015/09/01, 14:32:43.17$ prompt
इस दृष्टिकोण cmdमें परिणाम में किसी नए को शामिल करने की प्रक्रिया शामिल नहीं है , और न ही इसमें promptकमांड शामिल हैं ।
आपके द्वारा उपयोग किए जा रहे विंडोज के संस्करण के आधार पर, बस चलाना bashआपको बैश मोड में डाल देगा। यह आपको आदेशों के एक समूह का उपयोग करने की अनुमति देगा जो सीधे पॉवरशेल पर उपलब्ध नहीं हैं (जैसे timeकमांड)। अपने आदेश को अब निष्पादित करना जितना आसान है:
# The clause <your-command> (without the angle brackets) denotes the command you want to run.
$ time <your-command>
नोट: आप बैश मोड से आसानी से निकल सकते हैं और बैश मोड में रहते हुए अपने मुख्यधारा के शेल में वापस आ सकते हैं
exit।
यह मेरे लिए पूरी तरह से (विंडोज 10) अन्य तरीकों (जैसे Measure-Command) को आज़माने के बाद काम करता है जो कभी-कभी अवांछित आँकड़े पैदा करते हैं। आशा है कि यह आपके लिए भी काम करेगा।
यदि कोई अन्य व्यक्ति इस प्रश्न के उत्तर की तलाश में यहाँ आया है, तो वहाँ एक विंडोज एपीआई फ़ंक्शन कहा जाता है GetProcessTimes()। यह बहुत ज्यादा काम की तरह नहीं दिखता है थोड़ा सी प्रोग्राम लिखने के लिए जो कमांड शुरू करेगा, यह कॉल करेगा, और प्रक्रिया के समय को वापस करेगा।
यह एक टिप्पणी है / ल्यूक सैम्पसन के लिए संपादित timecmd.batऔर अच्छा है
किसी कारण से यह केवल मुझे पूरे सेकंड में आउटपुट देता है ... जो मेरे लिए बेकार है। मेरा मतलब है कि मैं timecmd ठहराव चलाता हूं, और इसका परिणाम हमेशा 1.00 सेकंड, 2.00 सेकंड, 4.00 सेकंड ... यहां तक कि 0.00 सेकंड में होता है! विंडोज 7. - कैमिलो मार्टिन सेप 25 '13 16:00 बजे "
कुछ कॉन्फ़िगरेशन पर सीमांकक भिन्न हो सकते हैं। निम्न परिवर्तन को कम से कम अधिकांश पश्चिमी देशों को कवर करना चाहिए।
set options="tokens=1-4 delims=:,." (added comma)
%time%मिलीसेकेंड कि जोड़ने के बाद अपने सिस्टम पर काम करते हैं ','
(* क्योंकि साइट एनॉन टिप्पणी की अनुमति नहीं देती है और पहचान का अच्छा ट्रैक नहीं रखती है, भले ही मैं हमेशा एक ही अतिथि ईमेल का उपयोग करता हूं जो कि आईपीवी 6 आईपी और ब्राउज़र फिंगरप्रिंट के साथ संयुक्त रूप से पासवर्ड के बिना विशिष्ट रूप से पहचानने के लिए पर्याप्त होना चाहिए)
यहाँ मेरी विधि है, कोई रूपांतरण नहीं है और कोई एमएस नहीं है। एन्कोडिंग अवधि निर्धारित करना उपयोगी है (हालांकि 24 घंटे तक सीमित):
@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
@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.
निम्न स्क्रिप्ट केवल "cmd.exe" का उपयोग करता है और एक पाइप लाइन के निर्माण के समय से मिलीसेकंड की संख्या को आउटपुट करता है जो स्क्रिप्ट से पहले की प्रक्रिया से बाहर निकलता है। यानी, अपनी कमांड टाइप करें और स्क्रिप्ट पर जाएं। उदाहरण: "टाइमआउट 3 | रनटाइम.सीएमडी" को "2990" जैसा कुछ बनाना चाहिए। यदि आपको रनटाइम आउटपुट और स्टड आउटपुट दोनों की आवश्यकता है, तो पाइप से पहले स्टड पुनर्निर्देशित करें - Ex: "dir / s 1> temp.txt | runtime.cmd" "dir" कमांड के आउटपुट को "temt.txt" को डंप करेगा। और कंसोल को रनटाइम प्रिंट करेगा।
:: --- 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
ड्रिब्लियो के उत्तर को थोड़ा कम किया जा सकता है (हालांकि ज्यादा पठनीय नहीं है)
@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
ल्यूक सैम्पसन की टिप्पणी के लिए यह संस्करण अष्टक सुरक्षित है, हालांकि यह कार्य 24 घंटे में पूरा होना चाहिए।
set _time=%time: =0%एकल अंक घंटे की समस्या को हल करता है - दोनों स्थानों पर प्रतिस्थापित करें।
उस निर्देशिका में जहां आपका प्रोग्राम है, टाइप notepad mytimer.batकरें, एक नई फ़ाइल बनाने के लिए 'हां' पर क्लिक करें।
YourApp.exeअपने प्रोग्राम की जगह , फिर नीचे दिए गए कोड को पेस्ट करें ।
@echo off
date /t
time /t
YourApp.exe
date /t
time /tmytimer.batकमांड लाइन में टाइप करें फिर Enter दबाएँ।
मेरा कोड आपको मिलिसेकंड में चलने का समय देता है, 24 घंटे तक, यह लोकल असंवेदनशील है, और अगर कोड आधी रात को चलता है तो नकारात्मक मूल्यों के लिए जिम्मेदार है। यह विलंबित विस्तार का उपयोग करता है, और इसे cmd / बैट फ़ाइल में सहेजा जाना चाहिए।
आपके कोड से पहले:
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%
आपके कोड के बाद:
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
यदि आप HH में समय चलाना चाहते हैं: mm: ss.000 प्रारूप, जोड़ें:
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
चर t2आपके चलने का समय रखता है, आप echo %t2%इसे प्रदर्शित कर सकते हैं ।
उपलब्ध होने के कारण पर्ल ने हायर सॉल्यूशन स्थापित किया है:
C:\BATCH>time.pl "echo Fine result"
0.01063
Fine result
STDERR मापा सेकंड से पहले आता है
#!/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;
सेकंड के सौवें हिस्से में समय लौटने के लिए एक उप का उपयोग करना
::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
"लीन एंड मीन" TIMER रीजनल फॉर्मेट, 24h और मिक्स्ड इनपुट सपोर्ट के साथ Aacini की प्रतिस्थापन विधि बॉडी को एडॉप्ट
करना , नो IF's, सिर्फ एक फॉर (मेरा रीजनल फिक्स)
1: फ़ाइल टाइमर। PAT % PATH% या वर्तमान dir में कहीं रखा गया है
@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
उपयोग:
टाइमर और गूंज start_cmds और timeout / t 3 और इको एंड_cmds और टाइमर
टाइमर और टाइमर "23: 23: 2300"
टाइमर "23: 23: 23,00" और टाइमर
टाइमर "13.23.23,00 और टाइमर " "03: 03: 03.00"
टाइमर और टाइमर "0: 00: 00.00" नहीं & cmd / v: on / c गूंज आधी रात तक =! टाइमर_एंड!
इनपुट अब मिलाया जा सकता है, उन लोगों के लिए, जो निष्पादन के दौरान संभव नहीं हैं, लेकिन संभव समय प्रारूप बदल जाता है
2: समारोह : टाइमर बैच स्क्रिप्ट (नीचे नमूना उपयोग) के साथ बंडल:
@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
:: इसका परीक्षण करने के लिए, कोड अनुभागों के ऊपर और नीचे दोनों को कॉपी-पेस्ट करें
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
सीई, डीई और सीएस, डीएस औपनिवेशिक छोर, डॉट एंड और कोलन सेट, डॉट सेट - मिश्रित प्रारूप समर्थन के लिए उपयोग किए जाते हैं
निम्न लिपि में * निक्स युग का समय आता है, लेकिन यह स्थानीय और क्षेत्रीय है। यह लीप वर्ष सहित कैलेंडर के मामलों को संभालना चाहिए। यदि Cygwin उपलब्ध है, तो युगीन मूल्यों की तुलना Cygwin को निर्दिष्ट करके की जा सकती है विकल्प ।
मैं ईएसटी में हूं और बताया गया अंतर 4 घंटे का है जो अपेक्षाकृत सही है। टीबी और क्षेत्रीय निर्भरता को हटाने के लिए कुछ दिलचस्प समाधान हैं, लेकिन कुछ भी तुच्छ नहीं है जो मैंने देखा।
@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
@echo off
setlocal enableextensions
REM set start time env var
FOR /F "tokens=* USEBACKQ" %%F IN (`php -r "echo microtime(true);"`) DO ( SET start_time=%%F )
## PUT_HERE_THE_COMMAND_TO_RUN ##
REM echo elapsed time
php -r "echo 'elapsed: ' . (round(microtime(true) - trim(getenv('start_time')), 2)) . ' seconds' . mb_convert_encoding(' ', 'UTF-8', 'HTML-ENTITIES');"
साइबरविन या गैर-विश्वसनीय उपयोगिताओं की कोई आवश्यकता नहीं है। जब PHP स्थानीय रूप से उपलब्ध हो तब Usefull
सटीक और आउटपुट प्रारूप को आसानी से ट्विक किया जा सकता है
उसी विचार को PowerShell के लिए पोर्ट किया जा सकता है