ක්‍රියාවට නැංවීම සඳහා ගතවන කාලය මැනිය හැකි ආකාරය

මට ක්‍රියාත්මක වීමේ කාලය මිලි තත්පර වලින් ලබා ගත යුතුයි.

මම මුලින් මෙම ප්‍රශ්නය ඇසුවේ 2008 දී ය. එවකට පිළිගත් පිළිතුර වූයේ භාවිතා කිරීමයි. new Date().getTime()කෙසේ වෙතත්, සම්මත performance.now()API භාවිතා කිරීම වඩාත් යෝග්‍ය බව අප සැමටම එකඟ විය හැකිය . එබැවින් මම මේ සඳහා පිළිගත් පිළිතුර වෙනස් කරමි.

Performance.now () භාවිතා කිරීම :

var t0 = performance.now()

doSomething()   // <---- The function you're measuring time for 

var t1 = performance.now()
console.log("Call to doSomething took " + (t1 - t0) + " milliseconds.")

NodeJs: පන්තිය ආනයනයperformance කිරීම අවශ්‍ය වේ

Console.time භාවිතා කිරීම :(සම්මත නොවන)( ජීවන මට්ටම )

console.time('someFunction')

someFunction() // Whatever is timed goes between the two "console.time"

console.timeEnd('someFunction')

සටහන :
මෙම කිරීමට string පැවැත්ම සමත්time()හාtimeEnd()ක්රම ගැලපිය යුතුයි
(සඳහා බලාපොරොත්තු වූ පරිදි අවසන් කිරීමට එම තත්ත්වය ඇති සේ.)

console.time() ලියකියවිලි:

1. සම්බන්ධ NodeJS ප්‍රලේඛනය
2. MDN (සේවාදායක පාර්ශව) ප්‍රලේඛනය

නව දිනය () භාවිතා කරන්න . getTime ()

GetTime () ක්‍රමය 1970 ජනවාරි 1 මධ්‍යම රාත්‍රියේ සිට මිලි තත්පර ගණන නැවත ලබා දෙයි.

උදා.

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
// do something
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time);

දිනය () භාවිතා නොකරන්න. පහත කියවන්න.

භාවිතා කරන්නperformance.now() :

<script>
var a = performance.now();
alert('do something...');
var b = performance.now();
alert('It took ' + (b - a) + ' ms.');
</script>

එය ක්‍රියාත්මක වන්නේ:

• IE 10 ++

• ෆයර්ෆොක්ස් 15 ++

• Chrome 24 ++

• සෆාරි 8 ++

• ඔපෙරා 15 ++

• Android 4.4 ++

• ආදිය

console.timeඔබට ශක්‍ය විය හැකි නමුත් එය සම්මත නොවන § :

මෙම අංගය සම්මත නොවන අතර එය ප්‍රමිති ධාවන පථයක නොමැත. වෙබයට මුහුණ ලා සිටින නිෂ්පාදන අඩවි වල එය භාවිතා නොකරන්න: එය සෑම පරිශීලකයෙකුටම ක්‍රියා නොකරනු ඇත. ක්‍රියාත්මක කිරීම අතර විශාල නොගැලපීම් ද තිබිය හැකි අතර අනාගතයේ දී හැසිරීම වෙනස් විය හැකිය.

බ්‍රව්සර් ආධාරයට අමතරව, හිස් අස්ථි අනුවාදය ලෙස පෙනෙන බැවින් වඩාත් නිවැරදි වේලාවන් සැපයීමේ හැකියාවක්performance.now ඇති බව පෙනේ .console.time

<මොර ගෑමක්> එසේම, එවර් භාවිතා නොකරන්න Dateසඳහා ඕනෑම දෙයක් , එය "ක්රමය කාලය" වෙනස්කම් නිසා පීඩාවට කරන නිසා. එයින් අදහස් කරන්නේ "negative ණාත්මක වේලාව" වැනි අවලංගු ප්‍රති results ල අපට ලැබෙනු ඇති බවයි - පරිශීලකයාට නිවැරදි පද්ධති කාලයක් නොමැති විට:

2014 ඔක්තෝබර් මත, මගේ පද්ධති ඔරලෝසු haywire ගොස් දේ අනුමාන මම ජීමේල් විවෘත හා කියත් .... සියලු මගේ දවසේ ඊමේල් "යවා 0 විනාඩි පෙර ". ගූගල් හි ලෝක මට්ටමේ ඉංජිනේරුවන් විසින් ජීමේල් ගොඩනගා ගත යුතු යැයි මම සිතුවෙමි .......

(ඔබේ පද්ධති ඔරලෝසුව වසරකට පෙර සකසා ජීමේල් වෙත යන්න එවිට අපට සැවොම සිනාසෙනු ඇත. සමහර විට කවදාහරි අපට ජේඑස් සඳහා ලැජ්ජා ශාලාවක් ලැබෙනු ඇතDate .)

ගූගල් පැතුරුම්පතේ now()ක්‍රියාකාරිත්වය ද මෙම ගැටලුවෙන් පීඩා විඳිති.

ඔබ භාවිතා කරන එකම කාලය Dateපරිශීලකයාට ඔහුගේ පද්ධති ඔරලෝසු කාලය පෙන්වීමට අවශ්‍ය විට පමණි. ඔබ ලබා ගැනීමට අවශ්ය වන විට නොවේ ද කාලය හෝ කිසිම දෙයක් මැනීමයි.

ඔබට ඔබගේ දේශීය සංවර්ධනය පරිගණකයේ කාර්යය කියාත්මක කාලය ලබා ගැනීමට අවශ්ය නම් , ඔබ එක්කෝ ඔබගේ බ්රව්සරයේ ලක්කිරීම උපකරණ, ෙහෝ කොන්සෝලය විධාන වැනි භාවිතා කළ හැකි console.time()හා console.timeEnd().

සියලුම නවීන බ්‍රව්සර් වල ජාවාස්ක්‍රිප්ට් පැතිකඩ ඇත. ඔබගේ දැනට පවතින කේතය වෙනස් කිරීමට අවශ්‍ය නොවන බැවින් මෙම පැතිකඩකරුවන් වඩාත් නිවැරදි මිනුම් ලබා දිය යුතු අතර එය ශ්‍රිතයේ ක්‍රියාකාරී වේලාවට බලපායි.

ඔබගේ ජාවාස්ක්‍රිප්ට් පැතිකඩ කිරීමට:

• දී ක්රෝම් , මාධ්ය F12 සහ තෝරා පැතිකඩ ටැබ්, පසුව එකතු JavaScript CPU නරඹන්න .
• දී ෆයර්ෆොක්ස් , ස්ථාපනය / විවෘත Firebug, සහ මත ක්ලික් කරන්න නරඹන්න බොත්තම.
• දී IE 9+ , මාධ්ය F12 , මත ක්ලික් කරන්න කේත රචනය හෝ Profiler (IE ඔබගේ සංස්කරණය මත පදනම් වේ).

විකල්පයක් ලෙස, ඔබේ සංවර්ධන යන්ත්‍රය මත , console.time()සහ සමඟ ඔබේ කේතයට උපකරණ එකතු කළ හැකිය console.timeEnd(). Firefox11 +, Chrome2 + සහ IE11 + හි සහය දක්වන මෙම කාර්යයන්, ඔබ ආරම්භ කරන / නවත්වන ටයිමර් පිළිබඳ වාර්තා කරයි console.time(). time()පරිශීලක-නිර්වචනය කළ ටයිමර් නාමයක් තර්කයක් ලෙස ගෙන, timeEnd()ටයිමරය ආරම්භ වූ දින සිට ක්‍රියාත්මක වන වේලාව වාර්තා කරයි:

function a() {
  console.time("mytimer");
  ... do stuff ...
  var dur = console.timeEnd("myTimer"); // NOTE: dur only works in FF
}

timeEnd()ඇමතුමෙහි ගත වූ කාලය ආපසු ලබා දෙන්නේ ෆයර්ෆොක්ස් පමණක් බව සලකන්න . අනෙක් බ්‍රව්සර් ප්‍රති the ලය සංවර්ධක කොන්සෝලය වෙත වාර්තා කරයි: ප්‍රතිලාභ අගය timeEnd()නිර්වචනය කර නැත.

ඔබට ක්‍රියාකාරීත්වය ක්‍රියාත්මක කිරීමේ වේලාව වනාන්තරයේ ලබා ගැනීමට අවශ්‍ය නම් , ඔබට ඔබේ කේතය උපකරණ කිරීමට සිදුවේ. ඔබට විකල්ප කිහිපයක් තිබේ. විමසීමෙන් ඔබට ආරම්භක හා අවසාන වේලාවන් සුරැකිය හැකිය new Date().getTime():

function a() {
  var start = new Date().getTime();
  ... do stuff ...
  var end = new Date().getTime();
  var dur = end - start;
}

කෙසේ වෙතත් Date වස්තුවට ඇත්තේ මිලි තත්පර විභේදනයක් පමණක් වන අතර එය ඕනෑම මෙහෙයුම් පද්ධතියක ඔරලෝසු වෙනස්වීම් වලට බලපානු ඇත. නවීන බ්‍රව්සර් වල වඩා හොඳ විකල්පයක් තිබේ.

වඩා හොඳ විකල්පය භාවිතා කිරීමයි මහ යෝජනාව කාල හෙවත්, window.performance.now(). now()සාම්ප්‍රදායික ක්‍රමයට වඩා Date.getTime()වැදගත් ආකාර දෙකකින් වඩා හොඳය :

1. now()පිටුවේ සංචාලනයේ ආරම්භයේ සිට මිලි තත්පර ගණන නිරූපණය කරන සබ්මිලිසෙකන්ඩ් විභේදනය සහිත ද්විත්ව වේ. එය භාගයේ ඇති මයික්‍රෝ තත්පර ගණන නැවත ලබා දෙයි (උදා: 1000.123 ක අගය තත්පර 1 ක් සහ මයික්‍රෝ තත්පර 123 ක්).

2. now()ඒකාකාරී ලෙස වැඩි වෙමින් පවතී. ලෙස මෙය ඉතා වැදගත් වන්නේ Date.getTime()හැකි හැකි පසුව ඇමතුම් ඉදිරියට හෝ පසුපසට පනින්න. මෙහෙයුම් පද්ධතියේ පද්ධති කාලය යාවත්කාලීන කරන්නේ නම් (උදා: පරමාණුක ඔරලෝසු සමමුහුර්තකරණය) Date.getTime()ද යාවත්කාලීන වේ. now()සෑම විටම ඒකාකාරී ලෙස වැඩි වන බවට සහතික වී ඇත, එබැවින් එය මෙහෙයුම් පද්ධතියේ පද්ධති වේලාවට බලපාන්නේ නැත - එය සැමවිටම බිත්ති-ඔරලෝසු කාලය වනු ඇත (ඔබේ බිත්ති ඔරලෝසුව පරමාණුක නොවේ යැයි උපකල්පනය කරමු ...).

now()ස්ථානය සෑම භාවිතා කළ හැක බව new Date().getTime(), + new Dateandt Date.now()වේ. හැර බව ය Dateසහ now(), වරක් මිශ්ර නොවන ලෙස Dateමත පදනම් වේ , unix යුගයේ (1970 සිට මිලි තත්පර සංඛ්යාව), අතර now()වෙනස තත්පර දශම සංඛ්යාව ඔබේ පිටුවේ සංචලනය ආරම්භ සිට (එය වඩා කුඩා වනු ඇත එසේ වන්නේ Date).

භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් මෙන්න now():

function a() {
  var start = window.performance.now();
   ... do stuff ...
  var end = window.performance.now();
  var dur = end - start;
}

now()Chrome ස්ථාවර, ෆයර්ෆොක්ස් 15+ සහ IE10 සඳහා සහය දක්වයි. පොලිෆිල් කිහිපයක් ද තිබේ.

වනයේ ක්‍රියාත්මක කිරීමේ වේලාව මැනීම සඳහා තවත් විකල්පයක් වන්නේ UserTiming ය . UserTiming එක console.time()හා සමානව ක්‍රියා console.timeEnd()කරයි, නමුත් එය භාවිතා කරන එකම අධි විභේදන කාලරාමුව now()භාවිතා කරයි (එබැවින් ඔබට උප මිලි තත්පරයකින් ඒකාකාරී ලෙස වැඩිවන ඔරලෝසුවක් ලැබේ), සහ කාලරාමු සහ කාලසීමාවන් PerformanceTimeline වෙත සුරකිනු ඇත. .

UserTiming හි ලකුණු ( කාලරාමු ) සහ මිනුම් (කාලසීමාවන්) යන සංකල්ප ඇත . ඔබට අවශ්‍ය තරම් ප්‍රමාණයක් ඔබට අර්ථ දැක්විය හැකි අතර ඒවා කාර්ය සාධන ටයිම්ලයින් මත නිරාවරණය වේ .

කාලරාමුව සුරැකීමට, ඔබ අමතන්න mark(startMarkName). ඔබගේ පළමු සලකුණේ සිට කාලය ලබා ගැනීම සඳහා, ඔබ අමතන්න measure(measurename, startMarkname). කාල සීමාව පසුව ඔබේ ලකුණු සමඟ කාර්ය සාධන ටයිම්ලයින් හි සුරකිනු ඇත.

function a() {
  window.performance.mark("start");
  ... do stuff ...
  window.performance.measure("myfunctionduration", "start");
}

// duration is window.performance.getEntriesByName("myfunctionduration", "measure")[0];

UserTiming IE10 + සහ Chrome25 + වලින් ලබා ගත හැකිය. පොලිෆිල් එකක් ද ඇත (මා ලියූ).

නිවැරදි අගයන් ලබා ගැනීම සඳහා ඔබ කාර්ය සාධන අතුරුමුහුණත භාවිතා කළ යුතුය . ෆයර්ෆොක්ස්, ක්‍රෝම්, ඔපෙරා සහ අයිඊ හි නවීන සංස්කරණ සඳහා එය සහය දක්වයි. එය භාවිතා කළ හැකි ආකාරය පිළිබඳ උදාහරණයක් මෙන්න:

var performance = window.performance;
var t0 = performance.now();
doWork();
var t1 = performance.now();
console.log("Call to doWork took " + (t1 - t0) + " milliseconds.")

Date.getTime()හෝ console.time()නිවැරදිව ක්‍රියාත්මක කිරීමේ කාලය මැනීමට හොඳ නැත. ඉක්මන් දළ ඇස්තමේන්තුවක් ඔබට සුදුසු නම් ඔබට ඒවා භාවිතා කළ හැකිය. දළ ඇස්තමේන්තුව අනුව මම ඔබට තථ්‍ය කාලයෙන් 15-60 එම්එස් මාරුවක් ලබා ගත හැකිය.

මෙම දීප්තිමත් පරීක්ෂා පශ්චාත් JavaScript දී කියාත්මක කාලය මනින මත. කතුවරයා ජාවාස්ක්‍රිප්ට් වේලාවේ නිරවද්‍යතාවය පිළිබඳ සබැඳි කිහිපයක් ද ලබා දෙයි.

ෆයර්බග් භාවිතා කරන්න, කොන්සෝලය සහ ජාවාස්ක්‍රිප්ට් යන දෙකම සක්‍රීය කරන්න. පැතිකඩ ක්ලික් කරන්න. නැවත පූරණය කරන්න. නැවත පැතිකඩ ක්ලික් කරන්න. වාර්තාව බලන්න.

var StopWatch = function (performance) {
    this.startTime = 0;
    this.stopTime = 0;
    this.running = false;
    this.performance = performance === false ? false : !!window.performance;
};

StopWatch.prototype.currentTime = function () {
    return this.performance ? window.performance.now() : new Date().getTime();
};

StopWatch.prototype.start = function () {
    this.startTime = this.currentTime();
    this.running = true;
};

StopWatch.prototype.stop = function () {
    this.stopTime = this.currentTime();
    this.running = false;
};

StopWatch.prototype.getElapsedMilliseconds = function () {
    if (this.running) {
        this.stopTime = this.currentTime();
    }

    return this.stopTime - this.startTime;
};

StopWatch.prototype.getElapsedSeconds = function () {
    return this.getElapsedMilliseconds() / 1000;
};

StopWatch.prototype.printElapsed = function (name) {
    var currentName = name || 'Elapsed:';

    console.log(currentName, '[' + this.getElapsedMilliseconds() + 'ms]', '[' + this.getElapsedSeconds() + 's]');
};

මිණුම් ලකුණ

var stopwatch = new StopWatch();
stopwatch.start();

for (var index = 0; index < 100; index++) {
    stopwatch.printElapsed('Instance[' + index + ']');
}

stopwatch.stop();

stopwatch.printElapsed();

ප්‍රතිදානය

Instance[0] [0ms] [0s]
Instance[1] [2.999999967869371ms] [0.002999999967869371s]
Instance[2] [2.999999967869371ms] [0.002999999967869371s]
/* ... */
Instance[99] [10.999999998603016ms] [0.010999999998603016s]
Elapsed: [10.999999998603016ms] [0.010999999998603016s]

performance.now () අත්‍යවශ්‍ය නොවේ - StopWatch කන්ස්ට්‍රක්ටර් ශ්‍රිතයට ව්‍යාජ ලෙස යොමු කරන්න.

process.hrtime () Node.js තුළ ඇත - එය නැනෝ තත්පර වලින් අගයක් ලබා දෙයි

var hrTime = process.hrtime()
console.log(hrTime[0] * 1000000 + hrTime[1] / 1000)

ඔබට මෙහි අමතර ක්‍රියාකරු භාවිතා කළ හැකිය

 var start = +new Date();
 callYourFunctionHere();
 var end = +new Date();
 var time = end - start;
 console.log('total execution time = '+ time + 'ms');

NodeJS හි අගයක් ලෙස වේලාව ආපසු ලබා දීමේ හැකියාව ලබා ගැනීම සඳහා vsync කේතය තවදුරටත් දීර් extend කිරීම සඳහා මෙම කුඩා කේතය භාවිතා කරන්න.

console.timeEndValue = function(label) { // Add console.timeEndValue, to add a return value
   var time = this._times[label];
   if (!time) {
     throw new Error('No such label: ' + label);
   }
   var duration = Date.now() - time;
   return duration;
};

දැන් කේතය එසේ භාවිතා කරන්න:

console.time('someFunction timer');

someFunction();

var executionTime = console.timeEndValue('someFunction timer');
console.log("The execution time is " + executionTime);

මෙය ඔබට වැඩි හැකියාවන් ලබා දෙයි. ක්‍රියාත්මක කිරීමේ වේලාව සමීකරණවල භාවිතා කිරීම, හෝ දත්ත සමුදායක් තුළ ගබඩා කිරීම, දුරස්ථ සේවාදායකයෙකුට වෙබ්සොකට් හරහා යවා, වෙබ් පිටුවක සේවය කිරීම වැනි තවත් අරමුණු සඳහා භාවිතා කිරීමට ඔබට කාලය ගබඩා කළ හැකිය.

එක් විචල්‍යයක් පමණක් භාවිතා කළ හැකිය:

var timer = -performance.now();

// Do something

timer += performance.now();
console.log("Time: " + (timer/1000).toFixed(5) + " sec.")

timer/1000 - මිලි තත්පර තත්පර බවට පරිවර්තනය කිරීමට

.toFixed(5) - අමතර ඉලක්කම් කැපීමට

සිට console.timeහා performance.nowසමහර ප්රධාන බ්රවුසර (එනම් IE10) හි සපයන්නේ නැත, මම හොඳම ලබා ගත හැකි ක්රම උපයෝගී කර සිහින් උපයෝගිතා නිර්මාණය. කෙසේ වෙතත්, එයට ව්‍යාජ භාවිතයන් සඳහා දෝෂ හැසිරවීමක් නොමැත ( End()ආරම්භක නොවන ටයිමරයක් ඉල්ලා සිටීම).

එය භාවිතා කර ඔබට අවශ්‍ය පරිදි එය වැඩි දියුණු කරන්න.

Performance: {
    Timer: {},
    Start: function (name) {
        if (console && console.time) {
            console.time(name);
        } else if (window.performance.now) {
            this.Timer[name] = window.performance.now();
        } else {
            this.Timer[name] = new Date().getTime();
        }
    },
    End: function (name) {
        if (console && console.time) {
            console.timeEnd(name);
        } else {
            var result;
            if (window.performance.now) {
                result = window.performance.now() - this.Timer[name];
            } else {
                result = new Date().getTime() - this.Timer[name];
            }
            console.log(name + ": " + result);
        }
    }
}

එය ඔබට උදව් විය හැකිය.

var t0 = date.now(); doSomething(); var t1 = date.now(); console.log("Call to doSomething took approximate" + (t1 - t0)/1000 + " seconds.")

කාල කාර්යයන් සඳහා සැරසිලි කරුවෙකු මෙන්න

let timed = (f) => (...args)=>{
    let start = performance.now();
    let ret = f(...args);
    console.log(`function ${f.name} took ${(performance.now()-start).toFixed(3)}ms`)
    return ret;   
}

භාවිතය:

let test = ()=>{/*does something*/}
test = timed(test)   // turns the function into a timed function in one line
test()               // run your code as normal, logs 'function test took 1001.900ms' 

ඔබ අසින්ක් ශ්‍රිත භාවිතා කරන්නේ නම්, ඔබට අසින්ක් සෑදිය හැකි timedඅතර awaitඑෆ් (... ආර්ග්ස්) ට පෙර එකතු කළ හැකි අතර , ඒවා ක්‍රියාත්මක විය යුතුය. එක් සැරසිලි කරුවෙකුට සමමුහුර්ත හා අසින්ක් කාර්යයන් හැසිරවීමට අවශ්‍ය නම් එය වඩාත් සංකීර්ණ වේ.

ස්තූතියි, අචීම් කොයෙල්නර්, ඔබේ පිළිතුර ටිකක් පුළුල් කරයි:

var t0 = process.hrtime();
//Start of code to measure

//End of code
var timeInMilliseconds = process.hrtime(t0)[1]/1000000; // dividing by 1000000 gives milliseconds from nanoseconds

කරුණාකර, ඔබ මැනීමට අවශ්‍ය දේ හැර වෙනත් කිසිවක් නොකළ යුතු බව සලකන්න (උදාහරණයක් ලෙස console.log ක්‍රියාත්මක කිරීමට කාලය ගතවනු ඇති අතර කාර්ය සාධන පරීක්ෂණවලට එය බලපානු ඇත).

සටහන, අසමමුහුර්ත කාර්යයන් ක්‍රියාත්මක කිරීමේ වේලාව මැනීම සඳහා, ඔබ var timeInMilliseconds = process.hrtime(t0)[1]/1000000;ඇමතුම තුළට ඇතුළු කළ යුතුය . උදාහරණයක් වශයෙන්,

var t0 = process.hrtime();
someAsyncFunction(function(err, results) {
var timeInMilliseconds = process.hrtime(t0)[1]/1000000;

});

මාස කිහිපයකට පෙර මම මගේ පුරුද්දක් ලෙස Date.now () භාවිතා කරන වේලාවක් සකස් කළෙමි - ඒ වන විට පිළිගත් ක්‍රමය performance.now () ලෙස පෙනුනද - කාර්ය සාධන වස්තුව තවමත් නොමැති නිසා (ඉදිකර ඇත -in) ස්ථාවර Node.js නිකුතුවේ.

අද මම තවත් පර්යේෂණ කිහිපයක් කරමින් සිටි අතර කාලය සඳහා තවත් ක්‍රමයක් සොයා ගතිමි. Node.js කේතයෙන් මෙය භාවිතා කරන්නේ කෙසේදැයි මම සොයාගත් හෙයින්, මම එය මෙහි බෙදාගනු ඇතැයි සිතුවෙමි.

පහත දැක්වෙන්නේ w3c සහ Node.js විසින් සපයන ලද උදාහරණ වලින් ය .

function functionTimer() {
    performance.mark('start')
    functionToBeTimed()
    performance.mark('end')
    performance.measure('Start to End', 'start', 'end')
    const measure = performance.getEntriesByName('Start to End')[0]
    console.log(measure.duration)
}

සටහන:

ඔබ performanceNode.js යෙදුමක වස්තුව භාවිතා කිරීමට අදහස් කරන්නේ නම් , ඔබ පහත සඳහන් අවශ්‍යතා ඇතුළත් කළ යුතුය: const { performance } = require('perf_hooks')

මෙම පරමාර්ථය සාක්ෂාත් කර ගැනීම සඳහා විවිධ ක්‍රම තිබේ:

1. console.time භාවිතා කිරීම

   console.time('function');
   //run the function in between these two lines for that you need to 
   //measure time taken by the function. ("ex. function();")
   console.timeEnd('function');

2. මෙය වඩාත් කාර්යක්ෂම ක්‍රමයයි: performance.now () භාවිතා කිරීම , උදා

   var v1 = performance.now();
   //run the function here for which you have top measure the time 
   var v2 = performance.now();
   console.log("total time  taken = "+(v2-v1)+"milliseconds");

3. + (ක්‍රියාකරු එක් කරන්න) හෝ getTime () භාවිතා කරන්න

   var h2 = +new Date(); //or
   var h2 = new Date().getTime();
   for(i=0;i<500;i++) { /* do something */}
   var h3 = +new Date();   //or 
   var h3 = new Date().getTime();
   var timeTaken = h3-h2;
   console.log("time ====", timeTaken);

ඔබ ඒකීය ප්ලස් ක්‍රියාකරු දිනය නිදසුනකට යොදන විට සිදු වන්නේ කුමක්ද: ප්‍රශ්නාර්ථයේ දිනය නිදසුනෙහි අගය ලබා ගන්න එය අංකයකට පරිවර්තනය කරන්න

සටහන: getTime()unary + operator වලට වඩා හොඳ කාර්ය සාධනයක් ලබා දෙයි.

export default class Singleton {

  static myInstance: Singleton = null;

  _timers: any = {};

  /**
   * @returns {Singleton}
   */
  static getInstance() {
    if (Singleton.myInstance == null) {
      Singleton.myInstance = new Singleton();
    }

    return this.myInstance;
  }

  initTime(label: string) {
    this._timers[label] = Date.now();
    return this._timers[label];
  }

  endTime(label: string) {
    const endTime = Date.now();
    if (this._timers[label]) {
      const delta = endTime - this._timers[label];
      const finalTime = `${label}: ${delta}ms`;
      delete this._timers[label];
      return finalTime;
    } else {
      return null;
    }
  }
}

ආරම්භක ටයිම් සම්බන්ධයි string.

return Singleton.getInstance().initTime(label); // Returns the time init

return Singleton.getInstance().endTime(label); // Returns the total time between init and end

කැදැලි රහිත දේවල් අතර කාලය මැනීමට ඔබට අවශ්‍ය නම් ඔබට මෙය භාවිතා කළ හැකිය:

function timer(lap){ 
    if(lap) console.log(`${lap} in: ${(performance.now()-timer.prev).toFixed(3)}ms`); 
    timer.prev = performance.now();
}

Console.time () ට සමාන නමුත් පෙර ටයිමරයන් පිළිබඳ තොරතුරු තබා ගැනීමට ඔබට අවශ්‍ය නැතිනම් පහසු භාවිතය.

ඔබ console.time () වෙතින් නිල් වර්ණයට කැමති නම්, ඒ වෙනුවට ඔබට මෙම රේඛාව භාවිතා කළ හැකිය

console.log(`${lap} in: %c${(performance.now()-timer.prev).toFixed(3)}ms`, 'color:blue');

// Usage: 
timer()              // set the start
// do something 
timer('built')       // logs 'built in: 591.815ms'
// do something
timer('copied')      // logs 'copied in: 0.065ms'
// do something
timer('compared')    // logs 'compared in: 36.41ms'

මගේ නඩුවේදී, මම ව්‍යාකරණ සීනි භාවිතා කර එය බාබෙල් සමඟ සම්පාදනය කිරීමට කැමැත්තෙමි.
මෙම ක්‍රමයේ ඇති ගැටළුව නම් ශ්‍රිතය වස්තුව තුළ තිබිය යුතුය.

නියැදි JS කේතය

function timer() {
    return (target, propertyKey, descriptor) => {
        const start = Date.now();
        let oldFunc = descriptor.value;

        descriptor.value = async function (){
            var result = await oldFunc.apply(this, arguments);
            console.log(Date.now() - start);
            return result;
        }
    }
}

// Util function 
function delay(timeout) {
    return new Promise((resolve) => setTimeout(() => {
        resolve();
    }, timeout));
}

class Test {
    @timer()
    async test(timout) {
        await delay(timout)
        console.log("delay 1");
        await delay(timout)
        console.log("delay 2");
    }
}

const t = new Test();
t.test(1000)
t.test(100)

.babelrc (බාබල් 6 සඳහා)

 {
    "plugins": [
        "transform-decorators-legacy"
    ]
 }

සමුච්චිත චක්‍ර සමඟ නැවතුම් ඔරලෝසුව

සේවාදායකය සහ සේවාදායකයා සමඟ ක්‍රියා කරයි (Node හෝ DOM), PerformanceAPI භාවිතා කරයි . ඔබට කුඩා චක්‍ර රාශියක් ඇති විට හොඳයි, උදා: දත්ත වස්තු 1000 ක් ක්‍රියාවට නංවන 1000 ගුණයක් නම් ශ්‍රිතයක නමුත් මෙම ශ්‍රිතයේ එක් එක් ක්‍රියාකාරිත්වය සමස්තයට එකතු වන්නේ කෙසේදැයි බැලීමට ඔබට අවශ්‍යය.

එබැවින් මෙය මොඩියුලය ගෝලීය (සිංගල්ටන්) ටයිමරයක් භාවිතා කරයි. පංතියේ සිංගල්ටන් රටාවකට සමානයි, භාවිතා කිරීමට ටිකක් සරලයි, නමුත් ඔබ මෙය වෙනම උදා stopwatch.js. ගොනුවකට දැමිය යුතුයි .

const perf = typeof performance !== "undefined" ? performance : require('perf_hooks').performance;
const DIGITS = 2;

let _timers = {};

const _log = (label, delta?) => {
    if (_timers[label]) {
        console.log(`${label}: ` + (delta ? `${delta.toFixed(DIGITS)} ms last, ` : '') +
            `${_timers[label].total.toFixed(DIGITS)} ms total, ${_timers[label].cycles} cycles`);
    }
};

export const Stopwatch = {
    start(label) {
        const now = perf.now();
        if (_timers[label]) {
            if (!_timers[label].started) {
                _timers[label].started = now;
            }
        } else {
            _timers[label] = {
                started: now,
                total: 0,
                cycles: 0
            };
        }
    },
    /** Returns total elapsed milliseconds, or null if stopwatch doesn't exist. */
    stop(label, log = false) {
        const now = perf.now();
        if (_timers[label]) {
            let delta;
            if(_timers[label].started) {
                delta = now - _timers[label].started;
                _timers[label].started = null;
                _timers[label].total += delta;
                _timers[label].cycles++;
            }
            log && _log(label, delta);
            return _timers[label].total;
        } else {
            return null;
        }
    },
    /** Logs total time */
    log: _log,
    delete(label) {
        delete _timers[label];
    }
};

හොඳම ක්‍රමය වනුයේ performance hooksමොඩියුලය භාවිතා කිරීමයි . අස්ථාවර නමුත්, ඔබට හැකි markඔබගේ කේතය විශේෂිත ප්රදේශ හා measureඑම durationඅතර කැපී පෙනෙන ප්රදේශ.

const { performance, PerformanceObserver } = require('perf_hooks');

const measures = []

const obs = new PerformanceObserver(list => measures.push(...list.getEntries()));
obs.observe({ entryTypes: ['measure'] });
const getEntriesByType = cb => cb(measures);

const doSomething = val => {
  performance.mark('beginning of the process');

  val *= 2;

  performance.mark('after multiplication');

  performance.measure('time taken', 'beginning of the process', 'after multiplication');

  getEntriesByType(entries => {
    entries.forEach(entry => console.log(entry));
  })

  return val;
}

doSomething(4);

මෙහි උත්සාහ කරන්න

const { performance } = require('perf_hooks');

function addUpTo(n) {
  let total = 0;
  for (let i = 1; i <= n; i++) {
    total += i;
  }
  return total;
}


let t1 = performance.now();
addUpTo(1000000000);
let t2 = performance.now();
console.log(`Time elapsed: ${(t2 - t1) / 1000} seconds`);
// Time elapsed: 1.1261566010713577 seconds

කාර්ය සාධනය සමඟ

NodeJs: කාර්ය සාධන පන්තිය ආනයනය කිරීම අවශ්‍ය වේ

var time0 = performance.now(); // Store the time at this point into time0

yourFunction();   // The function you're measuring time for 

var time1 = performance.now(); // Store the time at this point into time1

console.log("youFunction took " + (time1 - time0) + " milliseconds to execute");

Console.time භාවිතා කිරීම

console.time('someFunction');

someFunction(); // Whatever is timed goes between the two "console.time"

console.timeEnd('someFunction');

1. කිරීමට ආරම්භ ටයිමරයට ගැලපෙන ලෙස භාවිතාconsole.time("myTimer");
2. විකල්ප: සඳහා මුද්රණය වන ගතවු කාලය, භාවිතය console.timeLog("myTimer");
3. අවසාන වශයෙන්, ටයිමරය නැවැත්වීමට සහ අවසාන වරට මුද්‍රණය කිරීමට:console.timeEnd("myTimer");

MDN සහ Node.js ප්‍රලේඛනයෙන් ඔබට මේ ගැන වැඩිදුර කියවිය හැකිය .

Chrome, Firefox, Opera සහ NodeJS වෙතින් ලබා ගත හැකිය. (එජ් හෝ ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් මත නොවේ).

console.time('startID') // inbuilt function

myFunction() 

console.timeEnd('startID') // inbuilt function

'startID' -> විෂය පථය හඳුනා ගැනීම අද්විතීය හැඳුනුම්පතකි

ඉහත කේතය ක්‍රියාත්මක කිරීමට 'myFunction' විසින් ගතවන කාලය ලබා දෙයි.

කලින් සඳහන් කළ පරිදි ටයිමරයෙන් සාදන ලද පරික්ෂා කර භාවිතා කරන්න. නමුත් ඔබට ඔබේම දෑ ලිවීමට අවශ්‍ය නම් හෝ අවශ්‍ය නම් මගේ ශත දෙක මෙයයි:

//=-=|Source|=-=//
/**
 * JavaScript Timer Object
 *
 *      var now=timer['elapsed'](); 
 *      timer['stop']();
 *      timer['start']();
 *      timer['reset']();
 * 
 * @expose
 * @method timer
 * @return {number}
 */
timer=function(){
    var a=Date.now();
    b=0;
    return{
        /** @expose */
        elapsed:function(){return b=Date.now()-a},
        start:function(){return a=Date.now()},
        stop:function(){return Date.now()},
        reset:function(){return a=0}
    }
}();

//=-=|Google Advanced Optimized|=-=//
timer=function(){var a=Date.now();b=0;return{a:function(){return b=Date.now()-a},start:function(){return a=Date.now()},stop:function(){return Date.now()},reset:function(){return a=0}}}();

සම්පාදනය සාර්ථක විය!

• මුල් ප්‍රමාණය: බයිට් 219 gzpped (බයිට් 405 සම්පීඩිත නොවේ)
• සම්පාදනය කළ ප්‍රමාණය: බයිට් 109 gzpped (බයිට් 187 සම්පීඩිත නොවේ)
• Gzipped ප්‍රමාණයෙන් 50.23% ක් ඉතිරි කර ඇත (gzip නොමැතිව 53.83%)

පිළිගත් පිළිතුර වැරදියි !

ජාවාස්ක්‍රිප්ට් අසමමුහුර්ත බැවින්, පිළිගත් පිළිතුරේ විචල්‍ය අන්තයේ අගයන් වැරදිය.

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
// JavaScript is not waiting until the for is finished !!
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time); 

සඳහා ක්‍රියාත්මක කිරීම ඉතා වේගවත් විය හැකි බැවින් ප්‍රති result ලය වැරදි බව ඔබට නොපෙනේ. යම් ඉල්ලීමක් කරන කේතයකින් ඔබට එය පරීක්ෂා කළ හැකිය:

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
  $.ajax({
    url: 'www.oneOfYourWebsites.com',
    success: function(){
       console.log("success");
    }
  });
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time); 

එබැවින් අනතුරු ඇඟවීම ඉතා ඉක්මණින් විමසනු ඇත, නමුත් කොන්සෝලය තුළ ඔබට අජැක්ස් ඉල්ලීම් අඛණ්ඩව සිදුවන බව පෙනෙනු ඇත.

ඔබ එය කළ යුතු ආකාරය මෙන්න: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now