Bagaimana mengukur waktu yang diambil oleh suatu fungsi untuk dieksekusi

Saya perlu mendapatkan waktu eksekusi dalam milidetik.

Saya awalnya mengajukan pertanyaan ini kembali pada tahun 2008. Jawaban yang diterima kemudian adalah menggunakan Date (). GetTime () yang baru. Namun, kita semua dapat setuju sekarang bahwa menggunakan API standard.now () API lebih tepat. Karena itu saya mengubah jawaban yang diterima untuk yang satu ini.

Menggunakan 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: diperlukan untuk mengimporperformance kelas

Menggunakan console.time :(tidak standar)( standar hidup )

console.time('someFunction')

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

console.timeEnd('someFunction')

Catatan :
String yang diteruskan ketime()dantimeEnd()metode harus cocok
(agar penghitung waktu selesai seperti yang diharapkan).

console.time() dokumentasi:

1. Dokumentasi NodeJS tentang
2. Dokumentasi MDN (sisi klien)

gunakan Date baru (). getTime ()

Metode getTime () mengembalikan jumlah milidetik sejak tengah malam 1 Januari 1970.

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

Jangan gunakan Date (). Baca di bawah.

Gunakanperformance.now() :

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

Ini bekerja pada:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• dll

console.timemungkin layak untuk Anda , tetapi itu tidak standar § :

Fitur ini tidak standar dan tidak pada jalur standar. Jangan menggunakannya di situs produksi yang menghadap Web: itu tidak akan berfungsi untuk setiap pengguna. Ada juga mungkin tidak kompatibel besar antara implementasi dan perilaku dapat berubah di masa depan.

Selain dukungan browser, performance.nowtampaknya memiliki potensi untuk memberikan timing yang lebih akurat karena tampaknya versi telanjang console.time.

<kata-kata kasar> Juga, TIDAK PERNAH menggunakan Dateuntuk apa-apa karena itu dipengaruhi oleh perubahan "waktu sistem". Yang berarti kami akan mendapatkan hasil yang tidak valid — seperti "waktu negatif" - ketika pengguna tidak memiliki waktu sistem yang akurat:

Pada Oktober 2014, jam sistem saya menjadi berantakan dan coba tebak .... Saya membuka Gmail dan melihat semua email hari saya "dikirim 0 menit yang lalu ". Dan saya pikir Gmail seharusnya dibangun oleh para insinyur kelas dunia dari Google .......

(Atur jam sistem Anda menjadi satu tahun yang lalu dan buka Gmail agar kita semua dapat tertawa. Mungkin suatu hari nanti kita akan memiliki Hall of Shame for JS Date.)

now()Fungsi Google Spreadsheet juga mengalami masalah ini.

Satu-satunya waktu yang akan Anda gunakan Dateadalah ketika Anda ingin menunjukkan kepada pengguna waktu sistemnya. Bukan ketika Anda ingin mendapatkan yang waktu atau ukuran apapun.

Jika Anda perlu mendapatkan waktu eksekusi fungsi pada mesin pengembangan lokal Anda Anda, Anda dapat menggunakan alat profil browser Anda, atau perintah konsol seperti console.time()dan console.timeEnd().

Semua browser modern memiliki profiler JavaScript bawaan. Profiler ini harus memberikan pengukuran paling akurat karena Anda tidak perlu mengubah kode yang ada, yang dapat memengaruhi waktu eksekusi fungsi.

Untuk profil JavaScript Anda:

• Di Chrome , tekan F12 dan pilih tab Profil , lalu Kumpulkan Profil CPU JavaScript .
• Di Firefox , instal / buka Firebug, dan klik tombol Profile .
• Di IE 9+ , tekan F12 , klik Script atau Profiler (tergantung pada versi IE Anda).

Atau, pada mesin pengembangan Anda, Anda dapat menambahkan instrumentasi ke kode Anda dengan console.time()dan console.timeEnd(). Fungsi-fungsi ini, didukung di Firefox11 +, Chrome2 + dan IE11 +, melaporkan penghitung waktu yang Anda mulai / hentikan console.time(). time()mengambil nama penghitung waktu yang ditentukan pengguna sebagai argumen, dantimeEnd() kemudian melaporkan waktu eksekusi sejak penghitung waktu dimulai:

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

Perhatikan bahwa hanya Firefox yang mengembalikan waktu yang telah berlalu di timeEnd() panggilan. Browser lain hanya melaporkan hasilnya ke konsol pengembang: nilai kembalinya timeEnd()tidak terdefinisi.

Jika Anda ingin mendapatkan waktu eksekusi fungsi di alam , Anda harus memasukkan kode Anda. Anda memiliki beberapa opsi. Anda cukup menyimpan waktu mulai dan berakhir dengan menanyakan new Date().getTime():

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

Namun, Dateobjek hanya memiliki resolusi milidetik dan akan dipengaruhi oleh perubahan jam sistem OS. Di browser modern, ada opsi yang lebih baik.

Pilihan yang lebih baik adalah menggunakan Waktu Resolusi Tinggi , alias window.performance.now(). now()lebih baik daripada tradisional Date.getTime()dalam dua cara penting:

1. now()adalah ganda dengan resolusi submillisecond yang mewakili jumlah milidetik sejak awal navigasi halaman. Ini mengembalikan jumlah mikrodetik dalam fraksional (misalnya nilai 1000,123 adalah 1 detik dan 123 mikrodetik).

2. now()meningkat secara monoton. Hal ini penting karena Date.getTime()dapat mungkin melompat ke depan atau bahkan mundur pada panggilan berikutnya. Khususnya, jika waktu sistem OS diperbarui (mis. Sinkronisasi jam atom), Date.getTime()juga diperbarui. now()dijamin akan selalu meningkat secara monoton, sehingga tidak terpengaruh oleh waktu sistem OS - itu akan selalu menjadi waktu jam dinding (dengan asumsi jam dinding Anda bukan atom ...).

now()dapat digunakan di hampir setiap tempat itu new Date().getTime(), dan + new Datesebagainya Date.now(). Pengecualiannya adalah bahwa Datedan now()waktu tidak tercampur, karena Datedidasarkan pada unix-epoch (jumlah milidetik sejak 1970), sedangkan now()jumlah milidetik sejak navigasi halaman Anda dimulai (sehingga akan jauh lebih kecil daripada Date).

Berikut ini contoh cara penggunaan now():

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

now()didukung di Chrome stable, Firefox 15+, dan IE10. Ada juga beberapa polyfill yang tersedia.

Satu opsi lain untuk mengukur waktu eksekusi di alam liar adalah UserTiming . UserTiming berperilaku serupa dengan console.time()dan console.timeEnd(), tetapi menggunakan Stempel Waktu Resolusi Tinggi yang sama yang now()menggunakan (sehingga Anda mendapatkan jam sub-milidetik yang meningkat secara monoton), dan menyimpan cap waktu dan durasi ke PerformanceTimeline .

UserTiming memiliki konsep tanda (cap waktu) dan ukuran (durasi). Anda dapat menentukan sebanyak mungkin yang Anda inginkan, dan mereka ditampilkan di PerformanceTimeline .

Untuk menyimpan cap waktu, Anda menelepon mark(startMarkName). Untuk mendapatkan durasi sejak tanda pertama Anda, Anda cukup menelepon measure(measurename, startMarkname). Durasi tersebut kemudian disimpan di PerformanceTimeline di samping tanda Anda.

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

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

UserTiming tersedia di IE10 + dan Chrome25 +. Ada juga polyfill yang tersedia (yang saya tulis).

Untuk mendapatkan nilai yang tepat, Anda harus menggunakan antarmuka Kinerja . Ini didukung dalam versi modern Firefox, Chrome, Opera dan IE. Berikut ini adalah contoh cara penggunaannya:

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

Date.getTime() atau console.time() tidak baik untuk mengukur waktu eksekusi yang tepat. Anda dapat menggunakannya jika perkiraan kasar cepat OK untuk Anda. Dengan perkiraan kasar saya maksudkan Anda bisa mendapatkan 15-60 ms dari waktu nyata.

Periksa pos brilian ini tentang mengukur waktu eksekusi dalam JavaScript. Penulis juga memberikan beberapa tautan tentang keakuratan waktu JavaScript, layak dibaca.

Gunakan Firebug, aktifkan Konsol dan Javascript. Klik Profil. Muat ulang. Klik Profil lagi. Lihat laporannya.

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

Tolok ukur

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

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

stopwatch.stop();

stopwatch.printElapsed();

Keluaran

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 () adalah opsional - cukup masukkan false ke dalam fungsi konstruktor StopWatch.

process.hrtime () tersedia dalam Node.js - ia mengembalikan nilai dalam nanodetik

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

Anda dapat menggunakan add operator juga di sini

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

Untuk memperluas kode vsync lebih lanjut untuk memiliki kemampuan untuk mengembalikan timeEnd sebagai nilai di NodeJS gunakan potongan kode kecil ini.

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

Sekarang gunakan kode seperti ini:

console.time('someFunction timer');

someFunction();

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

Ini memberi Anda lebih banyak kemungkinan. Anda dapat menyimpan waktu eksekusi untuk digunakan untuk keperluan lain seperti menggunakannya dalam persamaan, atau disimpan dalam database, dikirim ke klien jarak jauh melalui soket web, disajikan pada halaman web, dll.

Dimungkinkan untuk menggunakan hanya satu variabel:

var timer = -performance.now();

// Do something

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

timer/1000 - untuk mengkonversi milidetik ke detik

.toFixed(5) - untuk memotong angka ekstra

Karena console.timedan performance.nowtidak didukung di beberapa peramban utama (yaitu IE10), saya membuat utilitas ramping yang memanfaatkan metode terbaik yang tersedia. Namun, tidak ada penanganan kesalahan untuk penggunaan palsu (panggilanEnd() timer tidak diinisialisasi).

Gunakan dan tingkatkan sesuai keinginan Anda.

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

Ini dapat membantu Anda.

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

Inilah dekorator untuk fungsi pengaturan waktu

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

Pemakaian:

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' 

Jika Anda menggunakan fungsi-fungsi async, Anda dapat membuat timedasync dan menambahkan awaitsebelum f (... args), dan itu akan berfungsi untuk itu. Semakin rumit jika Anda ingin satu dekorator menangani fungsi sinkronisasi dan asinkron.

Terima kasih, Achim Koellner, akan sedikit memperluas jawaban Anda:

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

Harap perhatikan, bahwa Anda tidak boleh melakukan apa pun selain dari apa yang ingin Anda ukur (misalnya, console.log juga akan membutuhkan waktu untuk dijalankan dan akan memengaruhi tes kinerja).

Perhatikan, bahwa untuk mengukur waktu eksekusi fungsi asinkron, Anda harus memasukkan var timeInMilliseconds = process.hrtime(t0)[1]/1000000;di dalam callback. Sebagai contoh,

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

});

Beberapa bulan yang lalu saya mengumpulkan rutinitas saya sendiri yang kali fungsi menggunakan Date.now () - meskipun pada saat itu metode yang diterima tampaknya performance.now () - karena objek kinerja belum tersedia (dibangun -in) dalam rilis Node.js yang stabil.

Hari ini saya melakukan penelitian lebih lanjut dan menemukan metode lain untuk menentukan waktu. Karena saya juga menemukan cara menggunakan ini dalam kode Node.js, saya pikir saya akan membagikannya di sini.

Berikut ini adalah gabungan dari contoh yang diberikan oleh w3c dan 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)
}

CATATAN:

Jika Anda ingin menggunakan performanceobjek di aplikasi Node.js, Anda harus menyertakan persyaratan berikut: const { performance } = require('perf_hooks')

ada beberapa cara untuk mencapai tujuan ini:

1. menggunakan 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. ini adalah cara yang paling efisien: menggunakan performance.now () , mis

   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. gunakan + (tambahkan operator) atau 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);

Inilah yang terjadi ketika Anda menerapkan operator unary plus ke instance Date: Dapatkan nilai instance Date dalam pertanyaan. Konversikan ke Number

CATATAN: getTime()memberikan kinerja yang lebih baik daripada operator unary +.

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 terkait dengan string.

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

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

Jika Anda ingin mengukur waktu antara beberapa hal yang tidak bersarang Anda dapat menggunakan ini:

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

Mirip dengan console.time (), tetapi penggunaannya lebih mudah jika Anda tidak perlu melacak timer sebelumnya.

Jika Anda menyukai warna biru dari console.time (), Anda dapat menggunakan baris ini sebagai gantinya

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'

Dalam kasus saya, saya memilih untuk menggunakan @ grammar suger dan mengompilasinya dengan babel.
Masalah dari metode ini adalah bahwa fungsi harus berada di dalam objek.

Contoh Kode 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 (untuk babel 6)

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

Stopwatch dengan siklus kumulatif

Bekerja dengan server dan klien (Node atau DOM), menggunakan Performance API. Baik ketika Anda memiliki banyak siklus kecil misalnya dalam suatu fungsi yang disebut 1000 kali yang memproses 1000 objek data tetapi Anda ingin melihat bagaimana setiap operasi dalam fungsi ini menambahkan hingga total.

Jadi yang ini menggunakan timer global modul (tunggal). Sama seperti pola singleton kelas, hanya sedikit lebih mudah digunakan, tetapi Anda harus meletakkan ini dalam stopwatch.jsfile mis terpisah .

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

Cara terbaik adalah menggunakan performance hooksmodul. Meskipun tidak stabil, Anda dapat markmenentukan area spesifik kode Anda dan measuredi durationantara area yang ditandai.

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

Coba di sini

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

Dengan kinerja

NodeJs: Diperlukan untuk mengimpor kelas kinerja

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

Menggunakan console.time

console.time('someFunction');

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

console.timeEnd('someFunction');

1. Untuk memulai penggunaan penghitung waktuconsole.time("myTimer");
2. Opsional: Untuk mencetak waktu yang telah berlalu, gunakan console.timeLog("myTimer");
3. Akhirnya, untuk menghentikan timer dan mencetak waktu terakhir:console.timeEnd("myTimer");

Anda dapat membaca lebih lanjut tentang ini di MDN dan di dokumentasi Node.js .

Tersedia di Chrome, Firefox, Opera dan NodeJS. (bukan di Edge atau Internet Explorer).

Seperti yang dinyatakan sebelumnya periksa dan gunakan timer built-in. Tetapi jika Anda ingin atau perlu menulis sendiri di sini adalah dua sen saya:

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

Kompilasi sukses!

• Ukuran Asli: 219 byte gzipped (405 byte tidak terkompresi)
• Ukuran Terkompilasi: 109 byte gzipped (187 byte tidak terkompresi)
• Menyimpan 50,23% dari ukuran gzip (53,83% tanpa gzip

Jawaban yang diterima salah !

Karena JavaScript tidak sinkron, nilai akhir variabel dari jawaban yang diterima akan salah.

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

Eksekusi untuk mungkin sangat cepat sehingga Anda tidak dapat melihat bahwa hasilnya salah. Anda dapat mengujinya dengan kode yang melakukan beberapa permintaan:

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

Jadi peringatan akan meminta dengan sangat cepat tetapi di konsol Anda akan melihat bahwa permintaan ajax terus berlanjut.

Inilah cara yang harus Anda lakukan: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now