javascript निष्पादित करने के लिए किसी फ़ंक्शन द्वारा किए गए समय को मापने के लिए कैसे करें




profiling (13)

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() वैकल्पिक है - बस स्टॉपवॉच कन्स्ट्रक्टर फ़ंक्शन में झूठी पास करें।

मुझे मिलीसेकंड में निष्पादन समय प्राप्त करने की आवश्यकता है।

मैंने मूल रूप से 2008 में इस सवाल से पूछा था। स्वीकार्य उत्तर तब नई तारीख ()। GetTime () का उपयोग करना था, हालांकि, हम सभी अब सहमत हो सकते हैं कि मानक performance.now() का उपयोग करना .now performance.now() API अधिक उपयुक्त है। इसलिए मैं इस के लिए स्वीकृत उत्तर बदल रहा हूं।


स्वीकृत उत्तर गलत है !

चूंकि जावास्क्रिप्ट एसिंक्रोनस है, स्वीकृत उत्तर के परिवर्तनीय अंत के मान गलत होंगे।

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

के लिए निष्पादन बहुत तेज़ हो सकता है ताकि आप यह न देख सकें कि परिणाम गलत है। आप कुछ अनुरोध करने वाले कोड के साथ इसका परीक्षण कर सकते हैं:

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

तो अलर्ट बहुत जल्दी संकेत देगा लेकिन कंसोल में आप देखेंगे कि AJAX अनुरोध जारी हैं।

यहां बताया गया है कि आपको यह कैसे करना चाहिए: performance.now()


फायरबग का प्रयोग करें, कंसोल और जावास्क्रिप्ट दोनों सक्षम करें। प्रोफ़ाइल पर क्लिक करें। पुनः लोड करें। प्रोफ़ाइल फिर से क्लिक करें। रिपोर्ट देखें।


नई तिथि () का उपयोग करें । getTime ()

GetTime () विधि 1 जनवरी, 1 9 70 के मध्यरात्रि से मिलीसेकंड की संख्या लौटाती है।

पूर्व।

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

बनामिनक कोड को आगे बढ़ाने की क्षमता रखने के लिए आगे बढ़ने की क्षमता के लिए नोडजेएस में एक मान के रूप में कोड के इस छोटे टुकड़े का उपयोग करें।

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


यह आपको और अधिक संभावनाएं देता है। आप अधिक उद्देश्यों के लिए उपयोग किए जाने वाले निष्पादन समय को संग्रहीत कर सकते हैं जैसे समीकरणों में इसका उपयोग करना, या किसी डेटाबेस में संग्रहीत, वेबसाईट पर रिमोट क्लाइंट को भेजा गया, वेबपृष्ठ पर कार्य किया गया आदि।


चूंकि 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 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 मीटर की शिफ्ट प्राप्त कर सकते हैं।

जावास्क्रिप्ट में निष्पादन समय को मापने के लिए इस शानदार post को देखें। लेखक जावास्क्रिप्ट समय की सटीकता के बारे में कुछ लिंक भी देता है, पढ़ने के लायक है।


आप console.time उपयोग कर सकते हैं: (गैर-मानक)

console.time('someFunction');

someFunction(); // run whatever needs to be timed in between the statements

console.timeEnd('someFunction');

नोट :
स्ट्रिंग time() और timeEnd() विधियों से मेल खाती है
( टाइमर के रूप में पूरा होने के लिए खत्म करने के लिए)।


अद्यतन करें

आप मानक performance.now() एपीआई का उपयोग कर सकते हैं, जैसे:

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

यदि आपको अपनी स्थानीय विकास मशीन पर फ़ंक्शन निष्पादन समय प्राप्त करने की आवश्यकता है , तो आप या तो अपने ब्राउज़र के प्रोफाइलिंग टूल या कंसोल कमांड जैसे console.time() और console.timeEnd()

सभी आधुनिक ब्राउज़रों में अंतर्निहित जावास्क्रिप्ट प्रोफाइलर हैं। इन प्रोफाइलरों को सबसे सटीक माप देना चाहिए क्योंकि आपको अपने मौजूदा कोड को संशोधित करने की आवश्यकता नहीं है, जो फ़ंक्शन के निष्पादन समय को प्रभावित कर सकता है।

अपनी जावास्क्रिप्ट को प्रोफाइल करने के लिए:

  • क्रोम में , F12 दबाएं और प्रोफाइल टैब का चयन करें, फिर जावास्क्रिप्ट सीपीयू प्रोफाइल एकत्र करें
  • फ़ायरफ़ॉक्स में , फ़ायरबग इंस्टॉल / खोलें, और प्रोफाइल बटन पर क्लिक करें।
  • आईई 9 + में , एफ 12 दबाएं, स्क्रिप्ट या प्रोफाइलर पर क्लिक करें (आईई के आपके संस्करण के आधार पर)।

वैकल्पिक रूप से, आपकी विकास मशीन पर , आप console.time() और console.timeEnd() के साथ अपने कोड में वाद्ययंत्र जोड़ सकते हैं। फ़ायरफ़ॉक्स 11 +, क्रोम 2 + और आईई 11 + में समर्थित ये फ़ंक्शंस, टाइमर पर रिपोर्ट करें जो आप console.time() माध्यम से प्रारंभ / बंद करते हैं। time() उपयोगकर्ता द्वारा परिभाषित टाइमर नाम को तर्क के रूप में लेता है, और timeEnd() तब टाइमर शुरू होने के बाद निष्पादन समय पर रिपोर्ट करता है:

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

ध्यान दें कि केवल फ़ायरफ़ॉक्स समय timeEnd() कॉल में timeEnd() समय लौटाता है। अन्य ब्राउज़र्स बस डेवलपर कंसोल के परिणाम की रिपोर्ट करते हैं: timeEnd() का वापसी मूल्य अपरिभाषित है।

यदि आप जंगली में फ़ंक्शन निष्पादन समय प्राप्त करना चाहते हैं , तो आपको अपना कोड वाद्य करना होगा। आपके पास कुछ विकल्प हैं। आप new Date().getTime() करके प्रारंभ और समाप्ति समय को आसानी से सहेज सकते हैं 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() submillisecond संकल्प के साथ एक डबल है जो पेज के नेविगेशन की शुरुआत के बाद मिलीसेकंड की संख्या का प्रतिनिधित्व करता है। यह fractional में microseconds की संख्या देता है (उदाहरण के लिए 1000.123 का मान 1 सेकंड और 123 microseconds है)।

  2. now() एकान्त रूप से बढ़ रहा है। यह महत्वपूर्ण है क्योंकि Date.getTime() संभवतया आगे की कॉल पर आगे या पीछे भी कूद सकता है । विशेष रूप से, यदि ओएस का सिस्टम समय अपडेट किया गया है (उदाहरण के लिए परमाणु घड़ी सिंक्रनाइज़ेशन), Date.getTime() भी अपडेट किया गया है। now() हमेशा एकान्त रूप से बढ़ने की गारंटी है, इसलिए यह ओएस के सिस्टम समय से प्रभावित नहीं होता है - यह हमेशा दीवार घड़ी का समय होगा (माना जाता है कि आपकी दीवार घड़ी परमाणु नहीं है ...)।

now() का उपयोग लगभग हर जगह किया जा सकता है कि new Date().getTime() , + new Date Date.now() हैं। अपवाद यह है कि Date और now() समय मिश्रण नहीं करते हैं, क्योंकि Date unix-epoch (1 9 70 से मिलीसेकंड की संख्या) पर आधारित है, जबकि now() आपके पेज नेविगेशन शुरू होने के बाद मिलीसेकंड की संख्या है (इसलिए यह होगा Date से बहुत छोटा हो)।

यहां उपयोग करने का उदाहरण यहां दिया गया है now() :

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

now() क्रोम स्थिर, फ़ायरफ़ॉक्स 15+, और आईई 10 में समर्थित है। कई polyfills भी उपलब्ध हैं।

जंगली में निष्पादन समय को मापने के लिए एक अन्य विकल्प UserTiming । UserTiming कंसोल.टाइम console.time() और console.timeEnd() समान व्यवहार करता है, लेकिन यह उसी उच्च रिज़ॉल्यूशन टाइमस्टैम्प का उपयोग करता है जो now() उपयोग करता है (इसलिए आपको उप-मिलीसेकंद monotonically बढ़ती घड़ी मिलती है), और टाइमस्टैम्प और अवधि को बचाता है PerformanceTimeline

उपयोगकर्ता टिमिंग में अंक (टाइमस्टैम्प) और उपायों (अवधि) की अवधारणाएं हैं। आप जितनी चाहें उतनी बार परिभाषित कर सकते हैं, और वे PerformanceTimeline पर उजागर हो गए हैं।

टाइमस्टैम्प को सहेजने के लिए, आप 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 + में उपलब्ध है। एक polyfill भी उपलब्ध है (जिसे मैंने लिखा था)।


जैसा कि पहले टाइमर में निर्मित और उपयोग के लिए कहा गया था। लेकिन यदि आप चाहते हैं या अपना खुद का लिखना चाहते हैं तो यह मेरे दो सेंट है:

//=-=|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}}}();

संकलन एक सफलता थी!

  • मूल आकार: 21 9 बाइट gzipped (405 बाइट असंपीड़ित)
  • संकलित आकार: 109 बाइट्स gzipped (187 बाइट असंपीड़ित)
  • Gzipped आकार से 50.23% बचाया (gzip के बिना 53.83%

धन्यवाद, अचिम कोएलनर, आपके उत्तर का विस्तार थोड़ा सा करेंगे:

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 timeInMilliseconds = process.hrtime(t0)[1]/1000000; कॉलबैक के अंदर। उदाहरण के लिए,

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

});

कुछ महीने पहले मैंने अपनी खुद की दिनचर्या एक साथ रखी थी, जो कि डेट.now () का उपयोग करके एक समारोह में होती है - भले ही स्वीकार्य विधि प्रदर्शन प्रतीत होती है। अब () - क्योंकि प्रदर्शन ऑब्जेक्ट अभी तक उपलब्ध नहीं है (बनाया गया है -इन) स्थिर 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)
}

ध्यान दें:

यदि आप किसी नोड.जेएस ऐप में performance ऑब्जेक्ट का उपयोग करना चाहते हैं, तो आपको निम्न आवश्यकताएं शामिल करनी होंगी: const { performance } = require('perf_hooks')


तिथि () का उपयोग न करें। नीचे दिया गया पढ़ें।

performance.now() उपयोग करें performance.now() :

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

यह इस पर काम करता है:

  • आईई 10 ++

  • फ़ायरफ़ॉक्स 15 ++

  • क्रोम 24 ++

  • सफारी 8 ++

  • ओपेरा 15 ++

  • एंड्रॉइड 4.4 ++

  • आदि आदि

console.time आपके लिए व्यवहार्य हो सकता है, लेकिन यह गैर-मानक § :

यह सुविधा गैर-मानक है और मानकों के ट्रैक पर नहीं है। वेब का सामना करने वाली उत्पादन साइटों पर इसका उपयोग न करें: यह प्रत्येक उपयोगकर्ता के लिए काम नहीं करेगा। कार्यान्वयन के बीच बड़ी असंगतता भी हो सकती है और भविष्य में व्यवहार बदल सकता है।

ब्राउज़र समर्थन के अलावा, performance.now अब में अधिक सटीक समय प्रदान करने की क्षमता है क्योंकि यह console.time का बेयर-हड्ड संस्करण प्रतीत होता है।

<rant> इसके अलावा, किसी भी चीज़ के लिए Date उपयोग न करें क्योंकि यह "सिस्टम समय" में परिवर्तनों से प्रभावित होता है। जिसका अर्थ है कि हमें अमान्य परिणाम मिलेंगे-जैसे "नकारात्मक समय" - जब उपयोगकर्ता के पास सटीक सिस्टम समय नहीं होता है:

अक्टूबर 2014 को, मेरी सिस्टम घड़ी खराब हो गई और अनुमान लगाया .... मैंने जीमेल खोला और मेरे सभी दिन के ईमेल " 0 मिनट पहले भेजे गए" को देखा। और मैंने सोचा था कि जीमेल को Google से विश्व स्तरीय इंजीनियरों द्वारा बनाया जाना चाहिए .......

(एक साल पहले अपनी सिस्टम घड़ी सेट करें और जीमेल पर जाएं ताकि हम सभी को अच्छी हंसी हो। शायद किसी दिन हमारे पास जेएस Date लिए हॉल ऑफ शेम होगा।)

Google स्प्रेडशीट का now() फ़ंक्शन भी इस समस्या से पीड़ित है।

Date का उपयोग करने का एकमात्र समय तब होता है जब आप उपयोगकर्ता को सिस्टम घड़ी का समय दिखाना चाहते हैं। जब आप समय नहीं लेना चाहते हैं या कुछ भी मापना नहीं चाहते हैं।





profiling