Cách đo thời gian thực hiện bởi một hàm để thực thi

Tôi cần phải có thời gian thực hiện trong một phần nghìn giây.

Ban đầu tôi đã hỏi câu hỏi này vào năm 2008. Câu trả lời được chấp nhận sau đó là sử dụng Date (). GetTime () mới. Tuy nhiên, tất cả chúng ta đều có thể đồng ý rằng sử dụng API Performance.now () tiêu chuẩn là phù hợp hơn. Do đó tôi đang thay đổi câu trả lời được chấp nhận cho câu hỏi này.

Sử dụng hiệu suất.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: bắt buộc phải nhậpperformance lớp

Sử dụng console.time :(không chuẩn)( mức sống )

console.time('someFunction')

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

console.timeEnd('someFunction')

Lưu ý :
Chuỗi được truyền chotime()vàtimeEnd()các phương thức phải khớp
(để bộ định thời kết thúc như mong đợi).

console.time() tài liệu:

1. Tài liệu của NodeJS về
2. Tài liệu MDN (phía khách hàng)

sử dụng Ngày mới (). getTime ()

Phương thức getTime () trả về số mili giây kể từ nửa đêm ngày 1 tháng 1 năm 1970.

Ví dụ.

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

Đừng sử dụng Ngày (). Đọc dưới đây.

Sử dụngperformance.now() :

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

Nó hoạt động trên:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• Vân vân

console.timecó thể khả thi với bạn , nhưng nó không chuẩn § :

Tính năng này không chuẩn và không theo dõi tiêu chuẩn. Không sử dụng nó trên các trang web sản xuất phải đối mặt với Web: nó sẽ không hoạt động cho mọi người dùng. Cũng có thể có sự không tương thích lớn giữa việc thực hiện và hành vi có thể thay đổi trong tương lai.

Bên cạnh hỗ trợ trình duyệt, performance.nowdường như có khả năng cung cấp thời gian chính xác hơn vì nó dường như là phiên bản cơ bản của console.time.

<rant> Ngoài ra, KHÔNG ĐƯỢC sử dụng Datecho bất cứ điều gì vì nó bị ảnh hưởng bởi những thay đổi trong "thời gian hệ thống". Điều đó có nghĩa là chúng tôi sẽ nhận được kết quả không hợp lệ "Thời gian âm" giống như người dùng - khi người dùng không có thời gian hệ thống chính xác:

Vào tháng 10 năm 2014, đồng hồ hệ thống của tôi gặp trục trặc và đoán xem .... Tôi đã mở Gmail và thấy tất cả các email trong ngày của tôi "được gửi 0 phút trước ". Và tôi nghĩ rằng Gmail được cho là do các kỹ sư đẳng cấp thế giới của Google xây dựng .......

(Đặt đồng hồ hệ thống của bạn thành một năm trước và truy cập Gmail để tất cả chúng ta có thể cười vui vẻ. Có lẽ một ngày nào đó chúng ta sẽ có Hội trường xấu hổ cho JS Date.)

now()Chức năng của Bảng tính Google cũng gặp phải vấn đề này.

Thời gian duy nhất bạn sẽ sử dụng Datelà khi bạn muốn hiển thị cho người dùng thời gian đồng hồ hệ thống của mình . Không phải khi bạn muốn nhận được những thời gian hoặc biện pháp gì cả.

Nếu bạn cần lấy thời gian thực hiện chức năng trên máy phát triển cục bộ của mình , bạn có thể sử dụng các công cụ định hình của trình duyệt hoặc các lệnh điều khiển như console.time()và console.timeEnd().

Tất cả các trình duyệt hiện đại đều có trình biên dịch JavaScript tích hợp. Các trình biên dịch này sẽ đưa ra phép đo chính xác nhất vì bạn không phải sửa đổi mã hiện tại của mình, điều này có thể ảnh hưởng đến thời gian thực hiện của hàm.

Để hồ sơ JavaScript của bạn:

• Trong Chrome , nhấn F12 và chọn tab Cấu hình , sau đó Thu thập hồ sơ CPU JavaScript .
• Trong Firefox , cài đặt / mở Fireorms và nhấp vào nút Hồ sơ .
• Trong IE 9+ , nhấn F12 , nhấp vào Script hoặc Profiler (tùy thuộc vào phiên bản IE của bạn).

Ngoài ra, trên máy phát triển của bạn , bạn có thể thêm thiết bị vào mã của mình bằng console.time()và console.timeEnd(). Các chức năng này, được hỗ trợ trong Firefox11 +, Chrome2 + và IE11 +, báo cáo về bộ hẹn giờ mà bạn bắt đầu / dừng qua console.time(). time()lấy tên bộ định thời do người dùng định nghĩa làm đối số và timeEnd()sau đó báo cáo về thời gian thực hiện kể từ khi bộ định thời bắt đầu:

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

Lưu ý rằng chỉ Firefox trả về thời gian đã trôi qua trong timeEnd()cuộc gọi. Các trình duyệt khác chỉ cần báo cáo kết quả cho bảng điều khiển dành cho nhà phát triển: giá trị trả về của timeEnd()không xác định.

Nếu bạn muốn có được thời gian thực hiện chức năng trong tự nhiên , bạn sẽ phải sử dụng mã của mình. Bạn có một vài lựa chọn. Bạn chỉ có thể lưu thời gian bắt đầu và kết thúc bằng cách truy vấn new Date().getTime():

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

Tuy nhiên, Date đối tượng chỉ có độ phân giải mili giây và sẽ bị ảnh hưởng bởi bất kỳ thay đổi đồng hồ hệ thống nào của HĐH. Trong các trình duyệt hiện đại, có một lựa chọn tốt hơn.

Tùy chọn tốt hơn là sử dụng Thời gian phân giải cao , aka window.performance.now(). now()tốt hơn truyền thống Date.getTime()theo hai cách quan trọng:

1. now()là gấp đôi với độ phân giải dưới giây, đại diện cho số mili giây kể từ khi bắt đầu điều hướng của trang. Nó trả về số lượng micro giây trong phân số (ví dụ: giá trị 1000.123 là 1 giây và 123 micro giây).

2. now()đang tăng đơn điệu. Điều này rất quan trọng vì Date.getTime()có thể có thể nhảy về phía trước hoặc thậm chí lùi lại trong các cuộc gọi tiếp theo. Đáng chú ý, nếu thời gian hệ thống của HĐH được cập nhật (ví dụ: đồng bộ hóa đồng hồ nguyên tử), Date.getTime()cũng được cập nhật. now()được đảm bảo luôn luôn tăng đơn điệu, do đó nó không bị ảnh hưởng bởi thời gian hệ thống của HĐH - nó sẽ luôn luôn là đồng hồ treo tường (giả sử đồng hồ treo tường của bạn không phải là nguyên tử ...).

now()có thể được sử dụng ở hầu hết mọi nơi new Date().getTime(), + new Dateandt Date.now(). Ngoại lệ là Datevà now()thời gian không trộn lẫn, Datedựa trên unix-epoch (số mili giây kể từ năm 1970), trong khi đó now()là số mili giây kể từ khi điều hướng trang của bạn bắt đầu (vì vậy nó sẽ nhỏ hơn nhiều Date).

Đây là một ví dụ về cách sử dụng now():

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

now()được hỗ trợ trong Chrome ổn định, Firefox 15+ và IE10. Ngoài ra còn có một số polyfill có sẵn.

Một tùy chọn khác để đo thời gian thực hiện trong tự nhiên là UserTiming . UserTiming hoạt động tương tự console.time()và console.timeEnd(), nhưng nó sử dụng cùng Dấu thời gian Độ phân giải cao now()sử dụng (để bạn có được đồng hồ tăng thêm một phần nghìn giây) và lưu dấu thời gian và thời lượng cho PerformanceTimeline .

UserTiming có các khái niệm về nhãn hiệu (dấu thời gian) và các biện pháp (thời lượng). Bạn có thể xác định bao nhiêu tùy ý và chúng được hiển thị trên PerformanceTimeline .

Để lưu dấu thời gian, bạn gọi mark(startMarkName). Để có được thời lượng kể từ lần đánh dấu đầu tiên của bạn, bạn chỉ cần gọi measure(measurename, startMarkname). Thời lượng sau đó được lưu trong PerformanceTimeline cùng với điểm của bạn.

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

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

UserTiming khả dụng trong IE10 + và Chrome25 +. Ngoài ra còn có một polyfill có sẵn (mà tôi đã viết).

Để có được giá trị chính xác, bạn nên sử dụng giao diện Hiệu suất . Nó được hỗ trợ trong các phiên bản hiện đại của Firefox, Chrome, Opera và IE. Đây là một ví dụ về cách nó có thể được sử dụng:

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

Date.getTime()hoặc console.time()không tốt để đo thời gian thực hiện chính xác. Bạn có thể sử dụng chúng nếu ước tính sơ bộ nhanh chóng phù hợp với bạn. Theo ước tính sơ bộ, ý tôi là bạn có thể nhận được 15-60 ms thay đổi so với thời gian thực.

Kiểm tra rực rỡ này bài về đo lường thời gian thực hiện trong JavaScript. Tác giả cũng đưa ra một vài liên kết về độ chính xác của thời gian JavaScript, đáng đọc.

Sử dụng Fireorms, kích hoạt cả Console và Javascript. Nhấp vào Hồ sơ. Tải lại. Nhấp vào Hồ sơ một lần nữa. Xem báo cáo.

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

Điểm chuẩn

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

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

stopwatch.stop();

stopwatch.printElapsed();

Đầu ra

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 () là tùy chọn - chỉ cần chuyển sai vào hàm xây dựng StopWatch.

process.hrtime () có sẵn trong Node.js - nó trả về giá trị tính bằng nano giây

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

bạn có thể sử dụng toán tử add tại đây

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

Để mở rộng mã của vsync hơn nữa để có khả năng trả về timeEnd như một giá trị trong NodeJS, hãy sử dụng đoạn mã nhỏ này.

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

Bây giờ sử dụng mã như vậy:

console.time('someFunction timer');

someFunction();

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

Điều này cung cấp cho bạn nhiều khả năng hơn. Bạn có thể lưu trữ thời gian thực hiện sẽ được sử dụng cho nhiều mục đích hơn như sử dụng nó trong các phương trình hoặc được lưu trữ trong cơ sở dữ liệu, được gửi đến máy khách từ xa qua websockets, được phục vụ trên trang web, v.v.

Chỉ có thể sử dụng một biến:

var timer = -performance.now();

// Do something

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

timer/1000 - để chuyển đổi mili giây thành giây

.toFixed(5) - để cắt các chữ số phụ

Vì console.timevà performance.nowkhông được hỗ trợ trong một số trình duyệt chính (ví dụ IE10), tôi đã tạo ra một tiện ích mỏng sử dụng các phương thức tốt nhất hiện có. Tuy nhiên, nó thiếu xử lý lỗi cho việc sử dụng sai (gọiEnd() vào bộ hẹn giờ không được khởi tạo).

Sử dụng nó và cải thiện nó như bạn muốn.

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

Nó có thể giúp bạn.

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

Đây là một trang trí cho các chức năng thời gian

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

Sử dụng:

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' 

Nếu bạn đang sử dụng các hàm async, bạn có thể tạo timedasync và thêm awaittrước f (... args), và điều đó sẽ phù hợp với những chức năng đó. Sẽ phức tạp hơn nếu bạn muốn một trình trang trí xử lý cả chức năng đồng bộ hóa và không đồng bộ.

Cảm ơn, Achim Koellner, sẽ mở rộng câu trả lời của bạn một chút:

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

Xin lưu ý rằng bạn không nên làm bất cứ điều gì ngoài những gì bạn muốn đo (ví dụ: console.log cũng sẽ mất thời gian để thực hiện và sẽ ảnh hưởng đến các bài kiểm tra hiệu suất).

Lưu ý rằng theo thứ tự thời gian thực hiện chức năng không đồng bộ, bạn nên chèn var timeInMilliseconds = process.hrtime(t0)[1]/1000000;bên trong hàm gọi lại. Ví dụ,

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

});

Một vài tháng trước, tôi đã kết hợp thói quen của riêng mình với chức năng sử dụng Date.now () - mặc dù tại thời điểm đó phương thức được chấp nhận có vẻ là Performance.now () - vì đối tượng hiệu năng chưa khả dụng (được xây dựng -in) trong bản phát hành Node.js ổn định.

Hôm nay tôi đã làm một số nghiên cứu thêm và tìm thấy một phương pháp khác cho thời gian. Vì tôi cũng tìm thấy cách sử dụng mã này trong mã Node.js, tôi nghĩ rằng tôi sẽ chia sẻ nó ở đây.

Sau đây được kết hợp từ các ví dụ được đưa ra bởi w3c và 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)
}

GHI CHÚ:

Nếu bạn định sử dụng performanceđối tượng trong ứng dụng Node.js, bạn phải bao gồm các yêu cầu sau: const { performance } = require('perf_hooks')

có nhiều cách để đạt được mục tiêu này:

1. sử dụng 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. đây là cách hiệu quả nhất: sử dụng Performance.now () , vd

   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. sử dụng + (thêm toán tử) hoặc 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);

Đây là những gì xảy ra khi bạn áp dụng toán tử cộng đơn cho một thể hiện Ngày: Lấy giá trị của thể hiện Ngày được đề cập Chuyển đổi nó thành Số

LƯU Ý: getTime()cho hiệu suất tốt hơn so với toán tử 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;
    }
  }
}

Thời gian liên quan đến string.

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

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

Nếu bạn muốn đo thời gian giữa nhiều thứ không được lồng nhau, bạn có thể sử dụng điều này:

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

Tương tự như console.time (), nhưng sử dụng dễ dàng hơn nếu bạn không cần theo dõi các bộ tính giờ trước đó.

Nếu bạn thích màu xanh lam từ console.time (), bạn có thể sử dụng dòng này thay thế

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'

Trong trường hợp của tôi, tôi thích sử dụng @ gram gram suger và biên dịch nó với babel.
Vấn đề của phương thức này là hàm phải nằm trong đối tượng.

Mã JS mẫu

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 (cho babel 6)

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

Đồng hồ bấm giờ với chu kỳ tích lũy

Hoạt động với máy chủ và máy khách (Nút hoặc DOM), sử dụng Performance API. Tốt khi bạn có nhiều chu kỳ nhỏ, ví dụ như trong một hàm được gọi là 1000 lần xử lý 1000 đối tượng dữ liệu nhưng bạn muốn xem mỗi thao tác trong hàm này cộng tổng số như thế nào.

Vì vậy, cái này sử dụng một bộ định thời toàn cầu mô-đun (singleton). Giống như một mẫu singleton lớp, chỉ đơn giản hơn một chút để sử dụng, nhưng bạn cần đặt nó trong một stopwatch.jstệp ví dụ riêng biệt .

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

Cách tốt nhất sẽ là sử dụng performance hooksmô-đun. Mặc dù không ổn định, bạn có thể markkhu vực cụ thể của mã của bạn và measurecác durationgiữa các khu vực được đánh dấu.

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

Thử ở đây

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

Với hiệu suất

NodeJs: Bắt buộc phải nhập lớp hiệu suất

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

Sử dụng console.time

console.time('someFunction');

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

console.timeEnd('someFunction');

1. Để bắt đầu sử dụng bộ đếm thời gianconsole.time("myTimer");
2. Tùy chọn: Để in thời gian đã trôi qua, hãy sử dụng console.timeLog("myTimer");
3. Cuối cùng, để dừng bộ hẹn giờ và in thời gian cuối cùng:console.timeEnd("myTimer");

Bạn có thể đọc thêm về điều này trên MDN và trong tài liệu hướng dẫn Node.js .

Có sẵn trên Chrome, Firefox, Opera và NodeJS. (không phải trên Edge hoặc Internet Explorer).

Như đã nêu trước đây kiểm tra và sử dụng tích hợp trong bộ đếm thời gian. Nhưng nếu bạn muốn hoặc cần tự viết ở đây là hai xu của tôi:

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

Biên soạn là một thành công!

• Kích thước gốc: 219 byte được nén (405 byte không nén)
• Kích thước biên dịch: 109 byte được nén (187 byte không nén)
• Tiết kiệm 50,23% kích thước được nén (53,83% không có gzip

Câu trả lời được chấp nhận là sai !

Vì JavaScript không đồng bộ, nên các giá trị ở đầu biến của câu trả lời được chấp nhận sẽ sai.

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

Việc thực hiện for có thể rất nhanh nên bạn không thể thấy rằng kết quả là sai. Bạn có thể kiểm tra nó với một mã thực hiện một số yêu cầu:

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

Vì vậy, cảnh báo sẽ nhắc rất nhanh nhưng trong bảng điều khiển bạn sẽ thấy rằng các yêu cầu ajax đang tiếp tục.

Đây là cách bạn nên làm: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now