ฉันจะวัดเวลาดำเนินการของคำสั่งบนบรรทัดคำสั่ง Windows ได้อย่างไร

มีวิธีการวัดเวลาดำเนินการของคำสั่งในตัวในบรรทัดคำสั่งของ Windows หรือไม่?

หากคุณใช้ Windows 2003 (โปรดทราบว่าไม่รองรับ Windows Server 2008 และใหม่กว่า) คุณสามารถใช้ชุดทรัพยากร Windows Server 2003 ซึ่งมี timeit.exe ซึ่งแสดงสถิติการทำงานโดยละเอียด นี่คือตัวอย่างการจับเวลาคำสั่ง "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

คุณสามารถรับ TimeIt ได้ในชุดทรัพยากร Windows 2003 ดาวน์โหลดได้ ที่นี่

หรืออีกวิธีหนึ่ง Windows PowerShell มีคำสั่งในตัวที่คล้ายกับคำสั่ง "เวลา" ของ Bash มันเรียกว่า "การวัดคำสั่ง" คุณจะต้องตรวจสอบให้แน่ใจว่าได้ติดตั้ง 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

ถ้าคุณต้องการ

1. หากต้องการวัดเวลาดำเนินการลงไปที่ร้อยในวินาที (รูปแบบ hh: mm: ss.ff)
2. ไม่ต้องดาวน์โหลดและติดตั้งชุดทรัพยากร
3. หากต้องการดูเหมือน DOS nerd ขนาดใหญ่ (ที่ไม่ได้)

ลองคัดลอกสคริปต์ต่อไปนี้ไปยังไฟล์แบตช์ใหม่ (เช่น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 ชั่วโมงขึ้นไป

ฮิฮิทางออกที่ง่ายที่สุดอาจเป็นเช่นนี้:

echo %time%
YourApp.exe
echo %time%

สิ่งนี้ใช้ได้กับ Windows ทุกตัวที่อยู่นอกกรอบ

ในกรณีของแอปพลิเคชันที่ใช้เอาต์พุตคอนโซลอาจสะดวกในการเก็บเวลาเริ่มต้นในตัวแปรชั่วคราว:

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

เพียงเล็กน้อยคำตอบจาก Casey.Kเกี่ยวกับการใช้Measure-CommandจากPowerShell :

1. คุณสามารถเรียก PowerShell จากพรอมต์คำสั่งมาตรฐานเช่นนี้

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

2. สิ่งนี้จะกินเอาต์พุตมาตรฐาน แต่คุณสามารถป้องกันได้โดยเพิ่ม| Out-Defaultเช่นนี้จาก PowerShell:

   Measure-Command {echo hi | Out-Default}
   

   หรือจากพรอมต์คำสั่ง:

   powershell -Command "Measure-Command {echo hi | Out-Default}"
   

แน่นอนคุณจะมีอิสระในการห่อนี้ในแฟ้มสคริปต์หรือ*.ps1*.bat

หนึ่งซับที่ฉันใช้ใน Windows Server 2008 R2 คือ:

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

ตราบใดที่mycommandไม่ต้องใช้คำพูด (ซึ่งสกรูกับการประมวลผลคำพูดคำสั่งของ) /v:onคือเพื่อให้เวลาสองค่าที่แตกต่างกันที่จะได้รับการประเมินอย่างเป็นอิสระมากกว่าหนึ่งครั้งในการดำเนินการของคำสั่ง

หากคุณมีหน้าต่างคำสั่งเปิดอยู่และเรียกใช้คำสั่งด้วยตนเองคุณสามารถแสดงการประทับเวลาในแต่ละพรอมต์เช่น

prompt $d $t $_$P$G

มันให้สิ่งที่คุณชอบ:

23.03.2009 15:45:50,77

C:\>

หากคุณมีแบทช์สคริปต์ขนาดเล็กที่ดำเนินการคำสั่งของคุณให้มีบรรทัดว่างไว้ข้างหน้าแต่ละคำสั่งเช่น

(บรรทัดว่าง)

myCommand.exe

(บรรทัดว่างถัดไป)

myCommand2.exe

คุณสามารถคำนวณเวลาดำเนินการสำหรับแต่ละคำสั่งตามข้อมูลเวลาในพรอมต์ สิ่งที่ดีที่สุดอาจจะเป็นไปป์เอ้าท์พุทกับ textfile สำหรับการวิเคราะห์เพิ่มเติม:

MyBatchFile.bat > output.txt

เนื่องจากคนอื่นแนะนำให้ติดตั้งสิ่งต่าง ๆ เช่นฟรีแวร์และ PowerShell คุณสามารถติดตั้งCygwinซึ่งจะทำให้คุณสามารถเข้าถึงคำสั่ง Unix ขั้นพื้นฐานได้หลายแบบเช่นเวลา :

abe@abe-PC:~$ time sleep 5

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

ไม่แน่ใจว่า Cygwin จะเพิ่มค่าใช้จ่ายเท่าใด

ไม่หรูหราเท่าฟังก์ชั่นบางอย่างของ Unix แต่สร้างไฟล์ 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:

ฉันใช้ฟรีแวร์ที่เรียกว่า "GS Timer"

เพียงสร้างแบตช์ไฟล์ดังนี้:

timer
yourapp.exe
timer /s

หากคุณต้องการชุดของเวลาเพียงไพพ์เอาท์พุทของตัวจับเวลา / s ลงในไฟล์. txt

คุณสามารถรับได้ที่นี่: โปรแกรมอรรถประโยชน์ DOS ฟรีของ Gammadyne

ความละเอียดคือ 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):

นี่คือยูทิลิตี้ของ Windows ซึ่งดำเนินการโปรแกรมและแสดงเวลาดำเนินการการใช้หน่วยความจำและสถิติ IO มันคล้ายกับการทำงานกับยูทิลิตี้เวลา Unix

ตราบใดที่มันไม่นานกว่า 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.

นี่คือ

รุ่นจับเวลา Postfix:

ตัวอย่างการใช้งาน:

หมดเวลา 1 | TimeIt.cmd

Execution took  ~969 milliseconds.

คัดลอกและวางสิ่งนี้ลงในโปรแกรมแก้ไขเช่นNotepad ++และบันทึกเป็น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

^ - อ้างอิงจากเวอร์ชัน 'Daniel Sparks'

ทางเลือกในการวัดเวลาคือ "รับวันที่" คุณไม่ต้องยุ่งยากกับการส่งต่อการส่งออกและอื่น ๆ

$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คำสั่ง

ขึ้นอยู่กับรุ่นของ Windows ที่คุณใช้งานอยู่การเรียกใช้bashจะทำให้คุณเข้าสู่โหมด Bash สิ่งนี้จะช่วยให้คุณสามารถใช้คำสั่งต่าง ๆ ที่ไม่สามารถใช้ได้ใน PowerShell โดยตรง (เช่นtimeคำสั่ง) การกำหนดเวลาคำสั่งของคุณเป็นเรื่องง่ายเหมือนกับการดำเนินการ:

# The clause <your-command> (without the angle brackets) denotes the command you want to run.
$ time <your-command>

หมายเหตุ:คุณสามารถออกจากโหมด Bash และกลับสู่เชลล์หลักของคุณได้อย่างง่ายดายโดยทำงานexitในโหมด Bash

สิ่งนี้ทำงานได้อย่างสมบูรณ์แบบสำหรับฉัน (Windows 10) หลังจากลองใช้วิธีอื่น ๆ (เช่นMeasure-Command) ซึ่งบางครั้งก็สร้างสถิติที่ไม่ต้องการ หวังว่าสิ่งนี้จะได้ผลกับคุณเช่นกัน

ในกรณีที่คนอื่นได้มาที่นี่มองหาคำตอบให้กับคำถามนี้มีฟังก์ชั่นของ Windows API GetProcessTimes()ที่เรียกว่า ดูเหมือนว่าจะไม่ทำงานมากนักในการเขียนโปรแกรม C เล็ก ๆ น้อย ๆ ที่จะเริ่มคำสั่งโทรออกนี้และส่งคืนเวลาดำเนินการ

นี่คือความเห็น / แก้ไขเพื่อลุค Sampson ที่ดีtimecmd.batและตอบกลับ

ด้วยเหตุผลบางอย่างนี้ให้ฉันออกในวินาทีทั้งหมด ... ซึ่งสำหรับฉันไม่มีประโยชน์ ฉันหมายความว่าฉันใช้ timecmd หยุดชั่วคราวและมันจะส่งผลใน 1.00 วินาที, 2.00 วินาที, 4.00 วินาที ... แม้กระทั่ง 0.00 วินาที! Windows 7 - Camilo Martin 25 กันยายน '13 เวลา 16:00 น. "

ในการกำหนดค่าบางอย่างตัวคั่นอาจแตกต่างกัน การเปลี่ยนแปลงต่อไปนี้ควรครอบคลุมอย่างน้อยที่สุดประเทศตะวันตกส่วนใหญ่

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

%time%มิลลิวินาทีทำงานในระบบของฉันหลังจากที่เพิ่มว่า ''

(* เนื่องจากเว็บไซต์ไม่อนุญาตให้มีการแสดงความคิดเห็นและไม่ได้ติดตามตัวตนที่ดีแม้ว่าฉันจะใช้อีเมลผู้เยี่ยมชมเดียวกันซึ่งรวมกับ ipv6 ip และลายนิ้วมือเบราว์เซอร์ควรจะเพียงพอที่จะระบุตัวตนโดยไม่ต้องใช้รหัสผ่าน)

นี่คือวิธีการของฉันไม่มีการแปลงและไม่มี ms มันมีประโยชน์ในการกำหนดระยะเวลาการเข้ารหัส (จำกัด ถึง 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 | runtime.cmd" ควรให้ผลเช่น "2990" หากคุณต้องการทั้งเอาต์พุตรันไทม์และเอาต์พุต stdin ให้เปลี่ยนเส้นทาง stdin ก่อนไพพ์ - เช่น: "dir / s 1> temp.txt | runtime.cmd" จะดัมพ์เอาต์พุตของคำสั่ง "dir" เป็น "temp.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

คำตอบของdriblioนั้นสั้นกว่าเล็กน้อย (แม้ว่าจะอ่านไม่ได้)

@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

สำหรับคำกล่าวของ Luke Sampson รุ่นนี้มีความปลอดภัยแปดด้านถึงแม้ว่างานจะแล้วเสร็จใน 24 ชั่วโมง

1. ในไดเรกทอรีที่โปรแกรมของคุณพิมพ์notepad mytimer.batให้คลิก 'ใช่' เพื่อสร้างไฟล์ใหม่

2. วางรหัสด้านล่างแทนที่YourApp.exeด้วยโปรแกรมของคุณแล้วบันทึก

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

3. พิมพ์mytimer.batในบรรทัดคำสั่งแล้วกด Enter

รหัสของฉันให้เวลาในการทำงานเป็นมิลลิวินาทีนานถึง 24 ชั่วโมงมันไม่ไวต่อสถานที่และบัญชีสำหรับค่าลบหากโค้ดทำงานถึงเที่ยงคืน มันใช้การขยายตัวล่าช้าและควรได้รับการบันทึกในไฟล์ cmd / bat

ก่อนรหัสของคุณ:

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%จะแสดง

มี Perl ติดตั้งโซลูชันการว่าจ้างพร้อมใช้งาน:

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;

ใช้ sub เพื่อส่งคืนเวลาเป็นร้อยในวินาที

::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 พร้อมรูปแบบภูมิภาคสนับสนุน 24 ชั่วโมงและอินพุตผสมการ
ปรับตัววิธีการทดแทนของ Aaciniไม่ใช่ IF's เพียงหนึ่งเดียวสำหรับ (การแก้ไขภูมิภาคของฉัน)

1: ไฟล์timer.batวางไว้ที่ไหนสักแห่งใน% 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

การใช้งาน:
ตัวจับเวลา & echo start_cmds & timeout / t 3 & echo end_cmds & ตัว
จับเวลา & ตัวจับเวลา "23: 23: 23,00"
ตัวจับเวลา "23: 23: 23,00" และตัว
จับเวลา "13.23.23,00" & ตัวจับเวลา "03: 03: 03.00"
ตัวจับเวลา & ตัวจับเวลา "0: 00: 00.00" ไม่ & cmd / v: เปิด / c echo จนถึงเที่ยงคืน =! timer_end!
ขณะนี้อินพุตสามารถผสมกันได้สำหรับการเปลี่ยนแปลงรูปแบบเวลาที่ไม่น่าเป็นไปได้ แต่ระหว่างการดำเนินการ

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

CE, DE และ CS, DS ย่อมาจากจุดปลายลำไส้ใหญ่, จุดปลายและชุดลำไส้ใหญ่, จุดตั้ง - ใช้สำหรับการสนับสนุนรูปแบบผสม

สคริปต์ต่อไปนี้จำลองเวลา * nix epoch แต่เป็นแบบโลคัลและระดับภูมิภาค มันควรจัดการกับกรณีขอบปฏิทินรวมถึงปีอธิกสุรทิน หากCygwinพร้อมใช้งานค่ายุคสามารถเปรียบเทียบได้โดยระบุตัวเลือกCygwin

ฉันอยู่ใน EST และรายงานความแตกต่างคือ 4 ชั่วโมงซึ่งค่อนข้างถูกต้อง มีวิธีแก้ปัญหาที่น่าสนใจในการลบ TZ และการพึ่งพาในระดับภูมิภาค แต่ไม่มีอะไรน่ารำคาญที่ฉันสังเกตเห็น

@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

วิธีการแก้ปัญหาโดยใช้ PHP บริสุทธิ์สำหรับ cmd และหนึ่ง env ตัวแปร:

@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');"

• ไม่จำเป็นต้องใช้ cygwin หรือยูทิลิตี้ที่ไม่น่าเชื่อถือ มีประโยชน์เมื่อ PHP พร้อมใช้งานในเครื่อง

• ความแม่นยำและรูปแบบเอาต์พุตสามารถปรับแต่งได้อย่างง่ายดาย

• แนวคิดเดียวกันสามารถพอร์ตสำหรับ PowerShell