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


1188

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

मैंने मूल रूप से 2008 में इस सवाल को वापस पूछा। स्वीकृत उत्तर तब नई तिथि () का उपयोग करना था । गेटटाइम () हालांकि, हम सभी अब सहमत हो सकते हैं कि मानक प्रदर्शन का उपयोग करें। () एपीआई अधिक उपयुक्त है। इसलिए मैं इस एक को स्वीकार जवाब बदल रहा हूँ।


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

यहाँ आप इसे क्लासिक Dateतरीके से कैसे कर सकते हैं , जो आपको देता है msऔर अधिकांश मामलों के लिए पर्याप्त है जो मुझे लगता है कि albertech.blogspot.com/2015/07/… ... ... लेकिन हाँ आपको वास्तव में देखना चाहिएPerformance.now
jar

5
performance.now()नोड में काम नहीं करता है। new Date().getTime()नोड में काम करेंगे।
रयान वॉकर


1
@oligofren - कभी-कभी आप इस डेटा को कैप्चर करना चाहते हैं। मेरे पास एक स्थिति है जहां मैं इसे indexedDB
ThomasRones

जवाबों:


1753

प्रदर्शन का उपयोग करना। अज्ञात () :

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('someFunction')

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

console.timeEnd('someFunction')

नोट :
स्ट्रिंग को पास किया जा रहा हैtime()औरtimeEnd()तरीकों का मिलान होना चाहिए
( उम्मीद के मुताबिक टाइमर समाप्त होने के लिए)।

console.time() दस्तावेजों:

  1. NodeJS प्रलेखन के बारे में
  2. MDN (क्लाइंट-साइड) प्रलेखन

27
यह अब क्रोम डेवलपर टूल द्वारा समर्थित है।
julien_c

3
यह वर्तमान में मेरे द्वारा समझे जाने वाले सटीक समय को इकट्ठा करने का सबसे अच्छा तरीका है।
ऐश ब्लू

6
क्या आपको उन दो कथनों के बीच कार्य को निष्पादित करने की आवश्यकता नहीं है? अब आप इसे परिभाषित करने के लिए नहीं बल्कि इसे निष्पादित करने के लिए लगने वाले समय को मापते हैं। अगर मैं गलत हूं तो मुझे सुधारें ...
क्रिस्टियन

2
इस सुविधा के बारे में MDN लेख का लिंक: developer.mozilla.org/en-US/docs/DOM/console.time
nullability

6
हां आप 'TotalTime + = कंसोल.टाइम ईंड' ('टाइमर') कर सकते हैं और प्रत्येक टाइमर के लिए कर सकते हैं
vsync

637

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

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

पूर्व।

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

9
ध्यान दें कि आप getTime के लिए + नई तिथि () कॉल कर सकते हैं () कॉल: var start = + new Date (); // सामान चेतावनी ("निष्पादन समय:" + (+ नई तिथि ()) - प्रारंभ);
जे सी

55
समय सही नहीं है क्योंकि तिथि इस कार्यशीलता के लिए अभिप्रेत नहीं है। मैं यहां बोल्ड होने जा रहा हूं और कहता हूं कि अगर आपको सटीक समय चाहिए तो आपको vsync के उदाहरण का उपयोग करना चाहिए। हालांकि यह केवल क्रोम और फायरफॉक्स एटीएम में काम करता है।
ऐश ब्लू

9
खबरदार, getMilliseconds () आपको वर्तमान सेकंड का मिलीसेकंड अंश देता है। यदि आप getMilliseconds () के साथ getTime () को प्रतिस्थापित करते हैं तो यदि आप एक सेकंड को पार करते हैं तो आप नकारात्मक परिणाम प्राप्त कर सकते हैं।
रिका

6
Vsync द्वारा उत्तर आज के मानकों से कहीं अधिक सही है, और दिनांक () का उपयोग करने के परिणामस्वरूप बहुत ही विवादास्पद परिणाम प्रदर्शित हो सकते हैं, विशेष रूप से विंडोज प्लेटफॉर्म पर जहां परिणाम गोल हो सकता है + निकटतम 15ms की सीमा तक तैर सकता है, जिसके परिणामस्वरूप अजीब सामान हो सकता है छोटे कोड बिट्स पर 0ms का समय।
ऑलिगॉफ्रेन

29
@AshBlue, हमें उपयोग करना चाहिए window.performance.now। देखें stackoverflow.com/a/15641427/632951
पचेरियर

405

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

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

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

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

  • IE 10 ++

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

  • क्रोम 24 ++

  • सफारी 8 ++

  • ओपेरा 15 ++

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

  • आदि आदि

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

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

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


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

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

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

Google स्प्रेडशीट का now()कार्य भी इस समस्या से ग्रस्त है।

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


3
मुझे इसकी ही खोज थी! मैं कई बार एक साथ जोड़ने में सक्षम होना चाहता हूं, वास्तव में सांत्वना समय के साथ ऐसा नहीं कर सकता।
रे

8
ध्यान दें कि यह अभी तक सफारी में समर्थित नहीं है: developer.mozilla.org/en-US/docs/Web/API/Performance.now ()
Akos K

2
मैं फायरबग प्रोफ़ाइल और प्रदर्शन का उपयोग करता हूँ। (), और वे दोनों अच्छी तरह से काम करते हैं। प्रदर्शन। अज्ञात () प्रोफ़ाइल से मेरे परिणाम की पुष्टि करता है।
विंसेंट जिया

2
मेरे सबसे बड़े हैंगअप में काम नहीं करता है, जो IE7 (कॉर्पोरेट ग्राहक है।) मैं क्रोम में प्रदर्शन को मापने के बारे में परवाह नहीं करता हूं, यह हमेशा हल्का होता है।
निक

2
यह एक बेहतर तरीका है फिर कंसोल.टाइम ()।
संजीव

52

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

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

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

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

वैकल्पिक रूप से, आपकी विकास मशीन पर , आप अपने कोड के साथ इंस्ट्रूमेंटेशन जोड़ सकते हैं 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()अपरिभाषित है।

यदि आप जंगल में फ़ंक्शन निष्पादन समय प्राप्त करना चाहते हैं , तो आपको अपना कोड इंस्ट्रूमेंट करना होगा। आपके पास कुछ विकल्प हैं। आप बस क्वेरी द्वारा प्रारंभ और समाप्ति समय बचा सकते हैं new Date().getTime():

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

हालाँकि, Dateऑब्जेक्ट में केवल मिलीसेकंड रिज़ॉल्यूशन है और यह किसी भी OS सिस्टम घड़ी परिवर्तन से प्रभावित होगा। आधुनिक ब्राउज़रों में, एक बेहतर विकल्प है।

बेहतर विकल्प उच्च संकल्प समय , उर्फ का उपयोग करना है window.performance.now()now()पारंपरिक Date.getTime()से दो महत्वपूर्ण तरीकों से बेहतर है:

  1. now()सबमिलिसकॉन्ड रिज़ॉल्यूशन वाला एक डबल है जो पेज के नेविगेशन की शुरुआत के बाद से मिलीसेकंड की संख्या का प्रतिनिधित्व करता है। यह भिन्नात्मक में माइक्रोसेकंड की संख्या लौटाता है (जैसे 1000.123 का मान 1 सेकंड और 123 माइक्रोसेकंड है)।

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

now()लगभग हर जगह इस्तेमाल किया जा सकता है कि new Date().getTime(), और यह + new Dateकर Date.now()रहे हैं। अपवाद यह है कि समय Dateऔर now()मिश्रण नहीं है, जैसा Dateकि यूनिक्स-एपोच (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 में निशान (टाइमस्टैम्प) और उपाय (अवधि) की अवधारणाएं हैं । आप जितने चाहें उतने को परिभाषित कर सकते हैं, और वे PerformanceTimeline पर सामने आ सकते हैं ।

टाइमस्टैम्प को बचाने के लिए, आप कॉल करें mark(startMarkName)। अपने पहले निशान के बाद से अवधि प्राप्त करने के लिए, आप बस कॉल करें measure(measurename, startMarkname)। तब अवधि आपके अंकों के साथ PerformanceTimeline में सहेजी जाती है।

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

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

UserTiming IE10 + और Chrome25 + में उपलब्ध है। एक पॉलीफ़िल भी उपलब्ध है (जो मैंने लिखा था)।


1
उत्कृष्ट और सबसे वर्तमान उत्तर IMHO :) यह संपादन के एक बिट के साथ और भी बेहतर होगा। मैं कहता हूँ चाहते हैं कि उपयोगकर्ता समय को मापने के लिए "एक अन्य विकल्प", लेकिन नहीं है पसंदीदा विकल्प जब बेंच मार्किंग विकास मशीन पर ही नहीं किया जाता है। आपके पॉलीफ़िल के साथ यह सभी ब्राउज़रों में काम करता है। और दूर के विवरण और बॉयलरप्लेट को छिपाना और यही कारण है कि यह मौजूद है। performance.nowDate
हैशचेंज

34

सटीक मान प्राप्त करने के लिए आपको प्रदर्शन इंटरफ़ेस का उपयोग करना चाहिए । यह फ़ायरफ़ॉक्स, क्रोम, ओपेरा और IE के आधुनिक संस्करणों में समर्थित है। यहाँ इसका उपयोग कैसे किया जा सकता है इसका एक उदाहरण दिया गया है:

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

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


बहुत अच्छा जवाब! इसने मेरी बहुत मदद की!
मिलाएं

18

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


8
अच्छी सलाह लेकिन स्पष्ट रूप से केवल एफएफ के लिए काम करता है। हम अक्सर ब्राउज़र गति की तुलना करना चाहते हैं ... :-)
PhiLho

3
नए Firebuq पर वे मेनू में इस विकल्प को छिपाते हैं, CTRL + SHIFT + P या कंसोल.प्रोफाइल () का उपयोग करें;
कंसोल..प्रोफाइलएंड

4
क्रोम अब console.time()और console.timeEnd()भी समर्थन करता है ।
julien_c

12
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 () वैकल्पिक है - बस स्टॉपवॉच निर्माण कार्य में गलत पास करें।


12

process.hrtime () Node.js के भीतर उपलब्ध है - यह नैनोसेकंड में एक मान लौटाता है

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

1
यदि आप इसे सुझाए गए माइक्रोसेकंड ई -6 के बजाय एमएस ई -3 में बदल देते हैं: hrtime[0] * 1000 + hrtime[1] / 1000000-> हाँ, मैं भी उपयोग var hrtimeकरता हूं ! : पी
क्रैगॉक्स

11

आप यहाँ भी ऑपरेटर जोड़ सकते हैं

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

8

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

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


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


8

केवल एक चर का उपयोग करना संभव है:

var timer = -performance.now();

// Do something

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

timer/1000 - मिलीसेकंड को सेकंड में बदलने के लिए

.toFixed(5) - अतिरिक्त अंकों को ट्रिम करने के लिए


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

5

यह आपकी मदद कर सकता है।

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


1
हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है। कृपया अपने कोड को व्याख्यात्मक टिप्पणियों के साथ भीड़ न दें, इससे कोड और स्पष्टीकरण दोनों की पठनीयता कम हो जाती है!
फिल्नोर

5

यहां टाइमिंग फंक्शन्स के लिए डेकोरेटर है

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' 

यदि आप async फ़ंक्शंस का उपयोग कर रहे हैं, तो आप async कर सकते हैं timedऔर awaitf (... args) से पहले जोड़ सकते हैं , और यह उन लोगों के लिए काम करना चाहिए। यह अधिक जटिल हो जाता है यदि आप चाहते हैं कि एक डेकोरेटर सिंक और एसिंक्स दोनों कार्यों को संभाल सके।


यही वह है जिसकी तलाश में मैं हूं। धन्यवाद!
एंड्रयू वाटर्स

क्या कोई ऐसा तरीका है जिससे इसे async कार्यों के साथ भी उपयोग किया जा सके?
TotalAMD

4

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

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;

});

3

कुछ महीने पहले मैंने अपनी दिनचर्या को एक साथ रखा, जो कि Date.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)
}

ध्यान दें:

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


मुझे लगता है कि आपको performance.mark('end')इस मामले में ज़रूरत नहीं है
kofifus

2

इस उद्देश्य को प्राप्त करने के कई तरीके हैं:

  1. कंसोल का उपयोग कर। समय

    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 + ऑपरेटर की तुलना में बेहतर प्रदर्शन देता है।


1
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;
    }
  }
}

से संबंधित InitTime string

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

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


1

यदि आप कई चीजों के बीच के समय को मापना चाहते हैं जो नेस्टेड नहीं हैं तो आप इसका उपयोग कर सकते हैं:

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

कंसोल के समान। समय (), लेकिन आसान उपयोग यदि आपको पिछली टाइमर का ट्रैक रखने की आवश्यकता नहीं है।

यदि आपको कंसोल.टाइम () से नीला रंग पसंद है, तो आप इसके बजाय इस लाइन का उपयोग कर सकते हैं

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'

1

मेरे मामले में, मैं @ व्याकरण suger का उपयोग करने और इसे बेबल के साथ संकलित करने का प्रयास करता हूं।
इस विधि की समस्या यह है कि फ़ंक्शन ऑब्जेक्ट के अंदर होना चाहिए।

नमूना 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"
    ]
 }

1

संचयी चक्र के साथ स्टॉपवॉच

सर्वर और क्लाइंट (नोड या डोम) के साथ काम करता है, Performanceएपीआई का उपयोग करता है। जब आपके पास कई छोटे चक्र होते हैं जैसे कि एक फ़ंक्शन में 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];
    }
};

1

सबसे अच्छा तरीका 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);

यहाँ कोशिश करो


0
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

0

प्रदर्शन के साथ

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('someFunction');

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

console.timeEnd('someFunction');

0
  1. करने के लिए शुरू टाइमर उपयोगconsole.time("myTimer");
  2. वैकल्पिक: बीता हुआ समय प्रिंट करने के लिए , का उपयोग करें console.timeLog("myTimer");
  3. अंत में, टाइमर को बंद करने और अंतिम समय प्रिंट करने के लिए:console.timeEnd("myTimer");

आप इसके बारे में MDN पर और Node.js प्रलेखन में अधिक पढ़ सकते हैं ।

Chrome, Firefox, Opera और NodeJS पर उपलब्ध है। (एज या इंटरनेट एक्सप्लोरर पर नहीं)।


-2

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

//=-=|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 बाइट्स gzipped (405 बाइट असम्पीडित)
  • संकलित आकार: 109 बाइट्स gzipped (187 बाइट असम्पीडित)
  • सहेजे गए 50.23% gzipped size (53.83% बिना gzip के)

-6

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

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

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

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

यहां बताया गया है कि आपको यह कैसे करना चाहिए: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now


9
यह लूप के कारण नहीं है। एक लूप के लिए आखिरी लूप तक इंतजार करना होगा जब तक कि यह आपके सोर्सकोड के नीचे नहीं जाएगा। AJAX कॉल async हैं। और अन्य कार्य भी हैं जो async चलाते हैं। लेकिन एक लूप के लिए एसिंइट एस्सिनेट नहीं है।
स्क्रिप्टलैब्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.