Bir fonksiyonun yürütülmesi için harcanan zaman nasıl ölçülür

Milisaniye cinsinden yürütme süresine ihtiyacım var.

Başlangıçta bu soruyu 2008'de sordum. Kabul edilen cevap daha sonra yeni Date () kullanmaktı . GetTime () Ancak, şimdi hepimiz standart performance.now () API'sini kullanmanın daha uygun olduğunu kabul edebiliriz . Dolayısıyla kabul edilen cevabı değiştiriyorum.

Kullanılması ) (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: sınıfı içe aktarmakperformance gerekir

Console.time kullanma :(Standart dışı)( yaşam standardı )

console.time('someFunction')

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

console.timeEnd('someFunction')

Not : veyöntemlerine
geçirilen dizeeşleşmelidir( zamanlayıcının beklendiği gibi bitmesi için).time()timeEnd()

console.time() dökümanlar:

1. İle ilgili NodeJS belgeleri
2. MDN (istemci tarafı) belgeleri

kullanmak new Date (). getTime ()

GetTime () yöntemi, 1 Ocak 1970 gece yarısından bu yana geçen milisaniye sayısını döndürür.

ex.

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

Tarih () kullanmayın. Alttarafı oku.

Kullanımperformance.now() :

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

Şunlar üzerinde çalışır:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• vesaire vesaire

console.timesizin için uygun olabilir , ancak standart değildir § :

Bu özellik standart değildir ve standartlar üzerinde değildir. Web'e bakan üretim sitelerinde kullanmayın: her kullanıcı için çalışmaz. Orada da uygulamalar arasında büyük uyumsuzluklar olabilir ve davranış gelecekte değişebilir.

Tarayıcı desteğinin yanı sıra , çıplak kemiklerin versiyonu gibi göründüğü için daha doğru zamanlamalar sağlama potansiyelineperformance.now sahip gibi görünüyor .console.time

<rant> Ayrıca, "sistem zamanı" ndaki değişikliklerden etkilendiği için hiçbir şey için KULLANMAYINDate . Hangi yöntemi bizim olacak : kullanıcı doğru bir sistem saatini olmadığında - "negatif zamanlama" gibi bir geçersiz sonuçlar elde

Eki 2014 tarihinde benim sistem saatinin bozuldu ve ne tahmin Gmail'e açtı ve gördü .... tüm "gönderilen my günün e-postaların 0 dakika önce ". Gmail’in Google’ın birinci sınıf mühendisleri tarafından yapılması gerektiğini düşünmüştüm.

(Sistem saatinizi bir yıl önce ayarlayın ve Gmail'e gidin, böylece hepimiz iyi bir kahkaha atabiliriz. Belki bir gün JS için bir Utanç Salonumuz olacak Date.)

Google E- now()Tablo'nun işlevi de bu sorundan muzdariptir.

Kullandığınız olacak sadece zaman Datesize kullanıcıya göstermek istediğinizde ise onun sistem saatini. Sen değil almak istediğinizde zamanı veya ölçmek şey.

Yerel geliştirme makinenizde işlev yürütme süresi almanız gerekiyorsa , tarayıcınızın profil oluşturma araçlarını veya console.time()ve gibi konsol komutlarını kullanabilirsiniz console.timeEnd().

Tüm modern tarayıcılarda yerleşik JavaScript profiler bulunur. Bu profil kullanıcıları, mevcut kodunuzu değiştirmek zorunda olmadığınız için en doğru ölçümü vermelidir, bu da işlevin yürütme süresini etkileyebilir.

JavaScript'inizin profilini oluşturmak için:

• In Chrome basın F12 basıp Profilleri sekmesi, daha sonra toplayın JavaScript CPU Profili .
• In Firefox , açık / Firebug yükleyin ve tıklayın Profili düğmesi.
• IE 9+ sürümünde F12 tuşuna basın , Komut Dosyası veya Profil Oluşturucu'ya tıklayın (IE sürümünüze bağlı olarak).

Alternatif olarak, geliştirme makinenizdeconsole.time() ve ile kodunuza enstrümantasyon ekleyebilirsiniz console.timeEnd(). Firefox11 +, Chrome2 + ve IE11 + 'da desteklenen bu işlevler, başlattığınız / durdurduğunuz zamanlayıcıları bildirir console.time(). time()kullanıcı tanımlı bir zamanlayıcı adını bağımsız değişken olarak alır timeEnd()ve zamanlayıcının başlamasından bu yana yürütme süresini bildirir:

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

timeEnd()Çağrıda yalnızca Firefox'un geçen süreyi döndürdüğünü unutmayın . Diğer tarayıcılar sonucu geliştirici konsoluna rapor eder: dönüş değeri timeEnd()tanımsızdır.

Eğer vahşi doğada işlev yürütme süresi almak istiyorsanız , kodunuzu enstrüman gerekir. Birkaç seçeneğiniz var. Sorgulayarak başlangıç ​​ve bitiş zamanlarını kaydedebilirsiniz new Date().getTime():

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

Ancak, Datenesne yalnızca milisaniyelik bir çözünürlüğe sahiptir ve herhangi bir işletim sisteminin sistem saati değişikliklerinden etkilenecektir. Modern tarayıcılarda daha iyi bir seçenek var.

Daha iyi bir seçenek, Yüksek Çözünürlüklü Zaman'ı kullanmaktır window.performance.now(). iki önemli yolla now()geleneksel olandan daha iyidir Date.getTime():

1. now(), sayfa gezinmesinin başlangıcından bu yana geçen milisaniye sayısını temsil eden, milisaniye altı çözünürlüğe sahip bir çifttir. Kesirli kısımdaki mikrosaniye sayısını döndürür (örneğin, 1000.123 değeri 1 saniye ve 123 mikrosaniyedir).

2. now()monoton olarak artmaktadır. Olarak, bu önemlidir Date.getTime()olabilir muhtemelen izleyen çağrılarda ileri geri ya da atlamak. Özellikle, işletim sisteminin sistem saati güncellenirse (örn. Atom saati senkronizasyonu) Date.getTime()da güncellenir. now()her zaman monoton olarak artması garanti edilir, bu nedenle işletim sisteminin sistem saatinden etkilenmez - her zaman duvar saati zamanı olacaktır (duvar saatinizin atomik olmadığı varsayılarak ...).

now()Hemen hemen her yerde kullanılabilir new Date().getTime(), + new Dateandt Date.now()vardır. Bunun tek istisnası, unix-epoch'a (1970'den bu yana milisaniye sayısı) dayalı olarak Dateve now()zamanların karışmaması , sayfa gezinmeniz başladığından bu yana geçen milisaniye sayısıdır (bu yüzden çok daha küçük olacaktır ).Datenow()Date

İşte nasıl kullanılacağına dair bir örnek now():

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

now()Chrome kararlı, Firefox 15+ ve IE10'da desteklenir. Ayrıca çeşitli çoklu dolgular da mevcuttur.

Doğada yürütme süresini ölçmek için bir diğer seçenek UserTiming'dir . UserTiming, benzer şekilde davranır console.time()ve console.timeEnd()kullanır, ancak aynı Yüksek Çözünürlüklü Zaman Damgasını now()kullanır (böylece milisaniyenin altında bir monoton olarak artan bir saat alırsınız) ve zaman damgalarını ve sürelerini PerformanceTimeline'a kaydeder .

UserTiming, işaretler (zaman damgaları) ve ölçümler (süreler) kavramlarına sahiptir . İstediğiniz kadar tanesini tanımlayabilirsiniz ve bunlar PerformanceTimeline üzerinde gösterilir .

Zaman damgasını kaydetmek için arayın mark(startMarkName). İlk işaretinizden bu yana geçen süreyi elde etmek için aramanız yeterlidir measure(measurename, startMarkname). Daha sonra süre, işaretlerinizin yanı sıra PerformanceTimeline'a kaydedilir.

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

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

UserTiming, IE10 + ve Chrome25 + 'da kullanılabilir. Ayrıca bir poli dolgu da var (yazdım).

Kesin değerleri elde etmek için Performans arayüzünü kullanmalısınız . Firefox, Chrome, Opera ve IE'nin modern sürümlerinde desteklenir. İşte nasıl kullanılabileceğine dair bir örnek:

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

Date.getTime()veya console.time()kesin yürütme süresini ölçmek için iyi değildir. Hızlı kaba tahmin sizin için uygunsa bunları kullanabilirsiniz. Kaba tahmin ile gerçek zamanlı 15-60 ms vardiya alabilirsiniz demek.

JavaScript'te yürütme süresini ölçmek için bu parlak gönderiyi kontrol edin . Yazar ayrıca, okumaya değer JavaScript zamanının doğruluğu hakkında birkaç bağlantı verir.

Firebug kullanın, hem Konsol hem de Javascript'i etkinleştirin. Profil'i tıklayın. Tekrar yükle. Profil'i tekrar tıklayın. Raporu görüntüleyin.

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

Karşılaştırma

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

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

stopwatch.stop();

stopwatch.printElapsed();

Çıktı

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 () isteğe bağlıdır - StopWatch yapıcı işlevine false değerini iletmeniz yeterlidir.

process.hrtime (), Node.js içinde kullanılabilir - nanosaniye cinsinden bir değer döndürür

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

burada eklenti operatörünü de kullanabilirsiniz

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

Vsync kodunu daha fazla genişletmek için NodeJS'de timeEnd değerini bir değer olarak döndürme yeteneğine sahip olmak için bu küçük kod parçasını kullanın.

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

Şimdi kodu şöyle kullanın:

console.time('someFunction timer');

someFunction();

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

Bu size daha fazla olanak sağlar. Denklemlerde kullanmak veya veritabanında saklanmak, web istemcileri üzerinden uzak istemciye gönderilen, bir web sayfasında sunulan vb. Gibi daha fazla amaç için kullanılacak yürütme süresini saklayabilirsiniz.

Sadece bir değişken kullanmak mümkündür:

var timer = -performance.now();

// Do something

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

timer/1000 - milisaniyeyi saniyeye dönüştürmek için

.toFixed(5) - fazladan basamakları kırpmak için

Yana console.timeve performance.now(yani IE10) bazı önemli tarayıcılarda desteklenmez, ben mevcut en iyi yöntemleri kullanan ince yarar yarattı. Ancak, yanlış kullanımlar için hata işleme End()yok (başlatılmamış bir zamanlayıcı çağrılıyor).

Kullanın ve istediğiniz gibi geliştirin.

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

Size yardımcı olabilir.

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

İşte zamanlama fonksiyonları için bir dekoratör

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

Kullanımı:

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' 

Eşzamansız işlevler kullanıyorsanız, eşzamansız hale getirebilir timedve awaitönce f (... args) ekleyebilirsiniz ve bunlar için çalışmalıdır. Bir dekoratörün hem senkronizasyon hem de zaman uyumsuz işlevleri işlemesini istiyorsanız daha karmaşık hale gelir.

Teşekkürler Achim Koellner, cevabınızı biraz genişletecek:

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

Lütfen, ölçmek istediğiniz şey dışında bir şey yapmamanız gerektiğini unutmayın (örneğin, console.logyürütülmesi de zaman alacak ve performans testlerini etkileyecektir).

Eşzamansız işlevlerin yürütme süresini ölçerek sırayla var timeInMilliseconds = process.hrtime(t0)[1]/1000000;, geri aramanın içine eklemeniz gerektiğini unutmayın . Örneğin,

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

});

Birkaç ay önce Date.now () kullanarak bir fonksiyonun kendi rutini bir araya getirdim - o zaman kabul edilen yöntem performans.now () gibi görünse de - performans nesnesi henüz mevcut değil (inşa edildi) -in) sabit Node.js sürümünde.

Bugün biraz daha araştırma yapıyordum ve zamanlama için başka bir yöntem buldum. Ben de Node.js kodunda nasıl kullanılacağını buldum, ben burada paylaşmak düşündüm.

Aşağıdakiler w3c ve Node.js tarafından verilen örneklerden birleştirilmiştir :

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

NOT:

performanceNesneyi bir Node.js uygulamasında kullanmayı düşünüyorsanız , aşağıdakileri eklemeniz gerekir: const { performance } = require('perf_hooks')

bu hedefe ulaşmanın birden fazla yolu vardır:

1. console.time kullanarak

   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. bu en etkili yoldur: performance.now () kullanmak , ör.

   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. + (operatör ekle) veya getTime () kullan

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

Unary artı işlecini bir Date örneğine uyguladığınızda aşağıdakiler gerçekleşir: Söz konusu Date örneğinin değerini alın Bir Sayıya Dönüştürün

NOT: getTime()tekli operatörden daha iyi performans verir.

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

İle ilgili string.

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

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

İç içe olmayan birden çok şey arasındaki süreyi ölçmek istiyorsanız bunu kullanabilirsiniz:

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

Console.time () işlevine benzer, ancak önceki zamanlayıcıları izlemenize gerek yoksa daha kolay kullanım.

Console.time () öğesinden mavi rengi beğendiyseniz bunun yerine bu satırı kullanabilirsiniz

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'

Benim durumumda, @ gramer şekeri kullanmayı ve babil ile derlemeyi düşünüyorum.
Bu yöntemin sorunu, işlevin nesnenin içinde olması gerektiğidir.

Örnek JS Kodu

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 (babel 6 için)

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

Kümülatif döngülerle kronometre

Sunucu ve istemci (Düğüm veya DOM) ile çalışır, Performance API'yı . Örneğin 1000 veri nesnesini işleyen 1000 kez adlı bir işlevde çok sayıda küçük döngünüz varsa, ancak bu işlevdeki her işlemin toplamı nasıl topladığını görmek istiyorsunuz.

Bu bir modül global (singleton) zamanlayıcı kullanır. Sınıf tekli deseniyle aynı, kullanımı biraz daha basit, ancak bunu ayrı bir örneğin stopwatch.jsdosyaya koymanız gerekiyor .

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

En iyi yol performance hooksmodülü kullanmak olacaktır . Kararsız olsa da, olabildiğince markspesifik kodunuzun alanları ve işaretli alanlar arasında.measureduration

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

Burada deneyin

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

Performans ile

NodeJ'ler: Performans sınıfını içe aktarmak gerekir

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 kullanma

console.time('someFunction');

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

console.timeEnd('someFunction');

1. To başlamak zamanlayıcı kullanımınıconsole.time("myTimer");
2. İsteğe bağlı: To yazdırmak geçen süre, kullanım console.timeLog("myTimer");
3. Son olarak, zamanlayıcıyı durdurmak ve son kez yazdırmak için:console.timeEnd("myTimer");

Bununla ilgili daha fazla bilgiyi MDN ve Node.js belgelerinde okuyabilirsiniz .

Chrome, Firefox, Opera ve NodeJS'de kullanılabilir. (Edge veya Internet Explorer'da değil).

Daha önce belirtildiği gibi dahili zamanlayıcıyı kontrol edin ve kullanın. Ama burada kendi yazılarınızı yazmak veya ihtiyacınız varsa, iki sentim:

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

Derleme başarılı oldu!

• Orijinal Boyut: 219 bayt gzip (405 bayt sıkıştırılmamış)
• Derlenmiş Boyut: 109 bayt sıkıştırılmış (187 bayt sıkıştırılmamış)
• Gzip boyutunda% 50.23 tasarruf (gzip olmadan% 53.83)

Kabul edilen cevap yanlış !

JavaScript eşzamansız olduğundan, kabul edilen cevabın değişken sonundaki değerler yanlış olur.

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

For'nun yürütülmesi çok hızlı olabilir, bu nedenle sonucun yanlış olduğunu göremezsiniz. Bazı isteklerde bulunan bir kodla test edebilirsiniz:

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

Böylece uyarı çok hızlı bir şekilde sorulur ancak konsolda ajax isteklerinin devam ettiğini görürsünüz.

Bunu nasıl yapmanız gerektiği: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now