Bagaimana mengukur waktu yang diambil oleh suatu fungsi untuk dieksekusi


1192

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.


3
Seringkali pernyataan tentang apa yang Anda coba selesaikan dengan waktu eksekusi dapat terbukti jauh lebih berguna daripada menjawab pertanyaan saja. Saat ini, menggunakan Profil di Firebug atau alat Chrome Dev seringkali merupakan cara yang jauh lebih baik untuk menemukan kode yang menyedot jus cpu Anda.
oligofren

inilah cara Anda dapat melakukannya dengan Datecara klasik , yang memberi Anda msdan cukup untuk sebagian besar kasus saya pikir albertech.blogspot.com/2015/07/ ... ... tapi ya Anda harus benar-benar melihatPerformance.now
jar

5
performance.now()tidak bekerja di Node. new Date().getTime()akan bekerja di Node.
Ryan Walker

1
number 1000 upvote
woop woop

1
@oligofren - Terkadang Anda mungkin ingin mengambil data ini. Saya memiliki situasi di mana saya menulis ini ke indexedDB
ThomasRones

Jawaban:


1757

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)

27
Ini didukung oleh Alat Pengembang Chrome juga sekarang.
julien_c

3
Saat ini cara terbaik untuk mengumpulkan waktu yang akurat dari apa yang saya mengerti.
Ash Blue

6
Apakah Anda tidak perlu menjalankan fungsi antara dua pernyataan itu? Anda sekarang mengukur waktu yang dibutuhkan untuk mendefinisikannya, bukan untuk mengeksekusinya. Perbaiki saya jika saya salah ...
Cristian

2
Tautan ke artikel MDN tentang fitur ini: developer.mozilla.org/en-US/docs/DOM/console.time
nullability

6
ya Anda dapat melakukan `totalTime + = console.timeEnd ('timer') 'dan melakukannya untuk setiap timer
vsync

637

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

9
Perhatikan bahwa Anda dapat mengganti + Date baru () untuk panggilan getTime (): var start = + Date baru (); // lakukan peringatan hal-hal ("Waktu eksekusi:" + (+ Tanggal baru ()) - mulai);
J c

55
Pengaturan waktu tidak akurat karena Tanggal tidak dimaksudkan untuk fungsi ini. Saya akan berani di sini dan mengatakan Anda harus menggunakan contoh vsync jika Anda ingin waktu yang akurat. Meskipun hanya berfungsi di ATM Chrome dan Firefox.
Ash Blue

9
Hati-hati, getMilliseconds () memberi Anda fraksi milidetik detik saat ini. Jika Anda mengganti getTime () dengan getMilliseconds (), Anda bisa mendapatkan hasil negatif jika melewati satu detik.
RickyA

6
Jawaban oleh vsync jauh lebih benar menurut standar todays, dan menggunakan Date () dapat menghasilkan hasil yang sangat keliru ditampilkan, terutama pada platform Windows di mana hasilnya mungkin dibulatkan + lantai ke batas 15 ms terdekat, menghasilkan hal-hal aneh seperti Timing 0ms pada bit kode kecil.
oligofren

29
@ AshBlue, kita harus menggunakan window.performance.now. Lihat stackoverflow.com/a/15641427/632951
Pacerier

405

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.


3
Apa yang saya cari! Saya ingin dapat menambahkan beberapa kali bersama-sama, tidak dapat melakukannya dengan waktu konsol.
Ray

8
perhatikan bahwa ini belum didukung di safari: developer.mozilla.org/en-US/docs/Web/API/Performance.now ()
Akos K

2
Saya menggunakan Firebug Profile dan performance.now (), dan keduanya bekerja dengan baik. Performance.now () mengkonfirmasi hasil saya dari Profil.
Vincent Jia

2
Tidak berfungsi di hangup terbesar saya, yaitu IE7 (pelanggan korporat.) Saya tidak peduli tentang pengukuran kinerja di chrome, selalu cepat kilat.
Nick

2
Ini adalah cara yang lebih baik daripada console.time ().
Sanjeev

52

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


1
Jawaban IMHO yang luar biasa dan terkini :) Akan lebih baik lagi dengan sedikit pengeditan. Saya akan mengatakan bahwa waktu pengguna tidak "salah satu pilihan lain" untuk mengukur, tetapi yang pilihan yang lebih disukai ketika benchmarking tersebut tidak dilakukan pada mesin pembangunan itu sendiri. Dengan polyfill Anda berfungsi di semua browser. Dan menyembunyikan detail dan pelat dari performance.nowdan Dateadalah alasan keberadaannya.
hashchange

34

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.


Jawaban yang sangat bagus Ini sangat membantu saya!
Gabungkan

18

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


8
Saran bagus tapi jelas hanya berfungsi untuk FF. Kami sering ingin membandingkan kecepatan browser ... :-)
PhiLho

3
Pada Firebuq baru mereka menyembunyikan opsi ini ke menu, gunakan CTRL + SHIFT + P atau console.profile (); console..profileEnd ()
user956584

4
Chrome mendukung console.time()dan console.timeEnd()juga sekarang.
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]');
};

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.


12

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

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

1
jika Anda lebih suka mengubahnya ke ms e-3 daripada yang disarankan mikrodetik e-6: hrtime[0] * 1000 + hrtime[1] / 1000000-> ya, saya lebih suka menggunakan var hrtimejuga! : P
cregox

11

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

8

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.


8

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


5

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

5

Ini dapat membantu Anda.

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


1
Sementara potongan kode ini dapat menyelesaikan pertanyaan, termasuk penjelasan sangat membantu untuk meningkatkan kualitas posting Anda. Ingatlah bahwa Anda menjawab pertanyaan untuk pembaca di masa depan, dan orang-orang itu mungkin tidak tahu alasan untuk saran kode Anda. Tolong juga cobalah untuk tidak membuat kerumunan kode Anda dengan komentar penjelasan, ini mengurangi keterbacaan kode dan penjelasan!
Filnor

5

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.


Inilah yang saya cari. Terima kasih!
Andrew Watters

Apakah ada cara untuk membuatnya universal untuk digunakan dengan fungsi async juga?
TotalAMD

4

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;

});

3

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


Saya pikir Anda tidak perlu performance.mark('end')dalam hal ini
kofifus

3

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 +.


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


1

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'

1

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

1

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

1

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


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

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

0
  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).


-2

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

-6

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


9
Itu bukan karena for loop. A for loop akan menunggu hingga loop terakhir hingga akan melanjutkan ke kode sumber Anda. Panggilan AJAX adalah async. Dan ada juga fungsi lain yang menjalankan async. Tetapi for for loop bukan executet async.
Scriptlabs
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.