Як виміряти час, який займає функція для виконання

Мені потрібно отримати час виконання в мілісекундах.

Я спочатку задав це питання ще в 2008 році. Тоді прийняту відповідь було використовувати нового Date (). GetTime () Однак ми зараз всі можемо погодитися, що використання стандартного API Performance.now () є більш доцільним. Тому я змінюю прийняту відповідь на цю.

Використання 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: потрібно імпортуватиperformance клас

Використання console.time :(нестандартне)(рівень життя )

console.time('someFunction')

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

console.timeEnd('someFunction')

Примітка :
Рядок істота передача доtime()іtimeEnd()методи повинні збігатися
(для таймера до кінця , як і очікувалося).

console.time() документації:

1. Документація NodeJS щодо
2. MDN (на стороні клієнта) документації

використовувати новий Date (). getTime ()

Метод getTime () повертає кількість мілісекунд з півночі 1 січня 1970 року.

колишній

var start = new Date().getTime();

for (i = 0; i < 50000; ++i) {
// do something
}

var end = new Date().getTime();
var time = end - start;
alert('Execution time: ' + time);

Не використовуйте Date (). Читай нижче.

Використанняperformance.now() :

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

Він працює на:

• IE 10 ++

• FireFox 15 ++

• Chrome 24 ++

• Сафарі 8 ++

• Opera 15 ++

• Android 4.4 ++

• тощо, тощо

console.timeможе бути життєздатним для вас , але це нестандартне § :

Ця функція є нестандартною і не відповідає стандартам. Не використовуйте його на виробничих сайтах, що стоять перед Інтернетом: це працюватиме не для кожного користувача. Також можуть бути великі несумісності між реалізаціями, і поведінка може змінитися в майбутньому.

Окрім підтримки браузера, performance.now схоже, є потенціал надати більш точні терміни, оскільки, здається, це версія з голими кістками console.time.

<rant> Крім того, НІКОЛИ не використовуйте ніDate для чого оскільки це впливає на зміни в "системному часі". Що означає , що ми будемо отримувати некоректні результати -Який «негативне часу» - коли користувач не має точний час системи:

Жовтень 2014 року мій системний годинник перейшов на вулицю і здогадайтесь, що .... Я відкрив Gmail і побачив усе електронні листи свого дня, "надіслані 0 хвилин тому ". І я думаю, що Gmail повинні бути створені інженерами світового класу від Google .......

(Встановіть ваш системний годинник на рік тому і перейдіть до Gmail, щоб ми могли всі добре посміятися. Можливо, колись у нас з’явиться Зал сорому для JS Date.)

Функція електронної таблиці Google now()також страждає від цієї проблеми.

Єдиний час, який ви будете використовувати, Dateце коли ви хочете показати користувачеві його системний годинник. Чи не тоді , коли ви хочете отримати на час або для вимірювання нічого.

Якщо вам потрібно отримати час виконання функції на вашій локальній машині розробки , ви можете скористатися інструментами профілювання вашого браузера або командами консолі, такими як console.time()і console.timeEnd().

Усі сучасні браузери мають вбудовані профілі JavaScript. Ці профілі повинні дати найбільш точне вимірювання, оскільки вам не доведеться змінювати існуючий код, що може вплинути на час виконання функції.

Щоб профіль вашого JavaScript:

• У Chrome натисніть F12 та виберіть вкладку Профілі , а потім Зберіть профіль CPU JavaScript .
• У Firefox встановіть / відкрийте Firebug та натисніть кнопку Профіль .
• У IE 9+ натисніть F12 , клацніть на Script або Profiler (залежно від вашої версії IE).

Крім того, на вашій розроблювальній машині ви можете додати інструментарій у свій код за допомогою console.time()та console.timeEnd(). Ці функції, підтримувані в Firefox11 +, Chrome2 + та IE11 +, повідомляють про таймери, через які ви запускаєте / зупиняєте console.time(). time()приймає визначене користувачем ім'я таймеру в якості аргументу, а timeEnd()потім звітує про час виконання з моменту запуску таймера:

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

Зауважте, що тільки Firefox повертає минулий час у timeEnd()виклику. Інші браузери просто повідомляють результат на консолі розробника: повернене значення timeEnd()не визначено.

Якщо ви хочете отримати час виконання функції в природі , вам доведеться зафіксувати свій код. У вас є пара варіантів. Ви можете просто зберегти час початку та кінця за допомогою запиту new Date().getTime():

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

Однак Dateоб’єкт має лише мілісекундну роздільну здатність і на нього впливатимуть будь-які зміни системних годин ОС. У сучасних браузерах є кращий варіант.

Кращий варіант - використовувати час високої роздільної здатності , ака window.performance.now(). now()є кращим від традиційного Date.getTime()двома важливими способами:

1. now()- це подвійний з субмілісекундною роздільною здатністю, який представляє кількість мілісекунд з початку навігації по сторінці. Він повертає кількість дробових мікросекунд (наприклад, значення 1000.123 становить 1 секунду і 123 мікросекунди).

2. now()монотонно зростає. Це важливо , так як Date.getTime()може , можливо , стрибати вперед або назад навіть при наступних викликах. Зокрема, якщо системний час ОС оновлено (наприклад, синхронізація атомних годин), Date.getTime()також оновляється. now()гарантовано завжди буде монотонно зростати, тому на нього не впливає системний час ОС - це завжди буде настінний час (якщо припустити, що ваші настінні годинники не є атомними ...).

now()може використовуватися майже в будь-якому місці new Date().getTime(), + new Dateяке Date.now()є. Винятком є ​​те, що Dateі now()часи не змішуються, як Dateце базується на unix-epoch (кількість мілісекунд з 1970 року), тоді як now()це кількість мілісекунд з моменту початку навігації на вашій сторінці (тому вона буде набагато меншою, ніж Date).

Ось приклад використання now():

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

now()підтримується в стабільній Chrome, Firefox 15+ та IE10. Також є кілька поліфілів .

Ще один варіант вимірювання часу виконання в природі - це UserTiming . UserTiming поводиться аналогічно console.time()та console.timeEnd(), але він використовує ту саму часову марку високої роздільної здатності, яка now()використовується (таким чином, ви отримуєте монтонічно зростаючий годинник на півмільсекунди) і економить часові позначки та тривалість на шкалі PerformanceTimeline .

UserTiming має поняття позначок (часових позначок) та заходів (тривалості). Ви можете визначити стільки, скільки хочете, і вони виставляються на PerformanceTimeline .

Щоб зберегти часову позначку, ви телефонуєте mark(startMarkName). Щоб отримати тривалість з моменту першої оцінки, ви просто телефонуєте measure(measurename, startMarkname). Далі тривалість зберігається в параметрі PerformanceTimeline поряд із вашими позначками.

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

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

UserTiming доступний в IE10 + та Chrome25 +. Також є поліфіл (про який я писав).

Для отримання точних значень слід використовувати інтерфейс продуктивності . Він підтримується в сучасних версіях Firefox, Chrome, Opera та IE. Ось приклад того, як це можна використовувати:

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

Date.getTime()або console.time()не корисні для вимірювання точного часу виконання. Ви можете використовувати їх, якщо швидка приблизна оцінка для вас нормальна. Під приблизною оцінкою я маю на увазі, що ви можете отримати зсув 15-60 мс від реального часу.

Перевірте цей блискучий пост про вимірювання часу виконання у JavaScript. Автор також дає кілька посилань про точність часу JavaScript, який варто прочитати.

Використовуйте Firebug, увімкніть і консоль, і Javascript. Клацніть профіль. Перезавантажити. Клацніть профіль ще раз. Переглянути звіт.

var StopWatch = function (performance) {
    this.startTime = 0;
    this.stopTime = 0;
    this.running = false;
    this.performance = performance === false ? false : !!window.performance;
};

StopWatch.prototype.currentTime = function () {
    return this.performance ? window.performance.now() : new Date().getTime();
};

StopWatch.prototype.start = function () {
    this.startTime = this.currentTime();
    this.running = true;
};

StopWatch.prototype.stop = function () {
    this.stopTime = this.currentTime();
    this.running = false;
};

StopWatch.prototype.getElapsedMilliseconds = function () {
    if (this.running) {
        this.stopTime = this.currentTime();
    }

    return this.stopTime - this.startTime;
};

StopWatch.prototype.getElapsedSeconds = function () {
    return this.getElapsedMilliseconds() / 1000;
};

StopWatch.prototype.printElapsed = function (name) {
    var currentName = name || 'Elapsed:';

    console.log(currentName, '[' + this.getElapsedMilliseconds() + 'ms]', '[' + this.getElapsedSeconds() + 's]');
};

Орієнтир

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

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

stopwatch.stop();

stopwatch.printElapsed();

Вихідні дані

Instance[0] [0ms] [0s]
Instance[1] [2.999999967869371ms] [0.002999999967869371s]
Instance[2] [2.999999967869371ms] [0.002999999967869371s]
/* ... */
Instance[99] [10.999999998603016ms] [0.010999999998603016s]
Elapsed: [10.999999998603016ms] [0.010999999998603016s]

performance.now () необов’язковий - просто передайте помилку в функцію конструктора StopWatch.

process.hrtime () доступний в Node.js - він повертає значення в наносекундах

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

ви можете використовувати оператор додавання також тут

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

Для подальшого розширення коду vsync, щоб мати можливість повертати timeEnd як значення в NodeJS, використовуйте цей невеликий фрагмент коду.

console.timeEndValue = function(label) { // Add console.timeEndValue, to add a return value
   var time = this._times[label];
   if (!time) {
     throw new Error('No such label: ' + label);
   }
   var duration = Date.now() - time;
   return duration;
};

Тепер використовуйте код так:

console.time('someFunction timer');

someFunction();

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

Це дає більше можливостей. Ви можете зберігати час виконання, який буде використаний для таких цілей, як його використання в рівняннях, або збережений у базі даних, надсилається віддаленому клієнту через веб-розетки, подається на веб-сторінці тощо.

Можна використовувати лише одну змінну:

var timer = -performance.now();

// Do something

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

timer/1000 - конвертувати мілісекунди в секунди

.toFixed(5) - обрізати зайві цифри

Оскільки console.timeі performance.nowне підтримуються в деяких основних браузерах (тобто IE10), я створив тонку утиліту, яка використовує найкращі доступні методи. Однак йому не вистачає обробки помилок для помилкових звичаїв (дзвінкиEnd() неініціалізованого таймера).

Використовуйте його та вдосконалюйте, як хочете.

Performance: {
    Timer: {},
    Start: function (name) {
        if (console && console.time) {
            console.time(name);
        } else if (window.performance.now) {
            this.Timer[name] = window.performance.now();
        } else {
            this.Timer[name] = new Date().getTime();
        }
    },
    End: function (name) {
        if (console && console.time) {
            console.timeEnd(name);
        } else {
            var result;
            if (window.performance.now) {
                result = window.performance.now() - this.Timer[name];
            } else {
                result = new Date().getTime() - this.Timer[name];
            }
            console.log(name + ": " + result);
        }
    }
}

Це може вам допомогти.

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

Ось декоратор для функцій синхронізації

let timed = (f) => (...args)=>{
    let start = performance.now();
    let ret = f(...args);
    console.log(`function ${f.name} took ${(performance.now()-start).toFixed(3)}ms`)
    return ret;   
}

Використання:

let test = ()=>{/*does something*/}
test = timed(test)   // turns the function into a timed function in one line
test()               // run your code as normal, logs 'function test took 1001.900ms' 

Якщо ви використовуєте функції асинхронізації, ви можете зробити timedасинхронізацію та додати awaitперед f (... аргументи), і це повинно працювати для них. Це стає складніше, якщо ви хочете, щоб один декоратор обробляв функції синхронізації та асинхронізації.

Дякую, Ахім Коллнер, трохи розширить вашу відповідь:

var t0 = process.hrtime();
//Start of code to measure

//End of code
var timeInMilliseconds = process.hrtime(t0)[1]/1000000; // dividing by 1000000 gives milliseconds from nanoseconds

Зауважте, що ви не повинні робити нічого, крім того, що хочете виміряти (наприклад, console.log також буде потрібно час для виконання та вплине на тести на ефективність).

Зауважте, що для вимірювання часу виконання асинхронних функцій слід вставити var timeInMilliseconds = process.hrtime(t0)[1]/1000000;всередину зворотного дзвінка. Наприклад,

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

});

Пару місяців тому я зібрав власний розпорядок, який часто функціонував за допомогою Date.now () - навіть якщо на той час прийнятим методом здавалося performance.now () - тому що об'єкт продуктивності ще не доступний (побудований -в) у стабільному випуску Node.js.

Сьогодні я робив ще кілька досліджень і знайшов інший метод встановлення часу. Оскільки я також знайшов, як це використовувати в коді Node.js, я подумав, що поділюсь цим тут.

Далі поєднано із прикладів, наданих w3c та Node.js :

function functionTimer() {
    performance.mark('start')
    functionToBeTimed()
    performance.mark('end')
    performance.measure('Start to End', 'start', 'end')
    const measure = performance.getEntriesByName('Start to End')[0]
    console.log(measure.duration)
}

ПРИМІТКА:

Якщо ви збираєтесь використовувати performanceоб'єкт у додатку Node.js, ви повинні включити наступне: const { performance } = require('perf_hooks')

Є кілька способів досягнення цієї мети:

1. за допомогою 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. це найефективніший спосіб: використання performance.now () , наприклад

   var v1 = performance.now();
   //run the function here for which you have top measure the time 
   var v2 = performance.now();
   console.log("total time  taken = "+(v2-v1)+"milliseconds");

3. використання + (додавання оператора) або getTime ()

   var h2 = +new Date(); //or
   var h2 = new Date().getTime();
   for(i=0;i<500;i++) { /* do something */}
   var h3 = +new Date();   //or 
   var h3 = new Date().getTime();
   var timeTaken = h3-h2;
   console.log("time ====", timeTaken);

Ось що відбувається, коли ви застосуєте оператор unary плюс до екземпляра Date: Отримайте значення відповідного екземпляра Date Перетворіть його у число

ПРИМІТКА: getTime()дає кращі показники, ніж унар + оператор.

export default class Singleton {

  static myInstance: Singleton = null;

  _timers: any = {};

  /**
   * @returns {Singleton}
   */
  static getInstance() {
    if (Singleton.myInstance == null) {
      Singleton.myInstance = new Singleton();
    }

    return this.myInstance;
  }

  initTime(label: string) {
    this._timers[label] = Date.now();
    return this._timers[label];
  }

  endTime(label: string) {
    const endTime = Date.now();
    if (this._timers[label]) {
      const delta = endTime - this._timers[label];
      const finalTime = `${label}: ${delta}ms`;
      delete this._timers[label];
      return finalTime;
    } else {
      return null;
    }
  }
}

InitTime, пов’язаний із string.

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

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

Якщо ви хочете виміряти час між кількома речами, які не вкладені, ви можете скористатися цим:

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

Подібно до console.time (), але простіше у використанні, якщо вам не потрібно слідкувати за попередніми таймерами.

Якщо вам подобається синій колір від console.time (), ви можете використовувати цей рядок замість цього

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'

У моєму випадку я вважаю за краще використовувати @ grammar suger і компілювати його з babel.
Проблема цього методу полягає в тому, що функція повинна знаходитися всередині об'єкта.

Зразок коду JS

function timer() {
    return (target, propertyKey, descriptor) => {
        const start = Date.now();
        let oldFunc = descriptor.value;

        descriptor.value = async function (){
            var result = await oldFunc.apply(this, arguments);
            console.log(Date.now() - start);
            return result;
        }
    }
}

// Util function 
function delay(timeout) {
    return new Promise((resolve) => setTimeout(() => {
        resolve();
    }, timeout));
}

class Test {
    @timer()
    async test(timout) {
        await delay(timout)
        console.log("delay 1");
        await delay(timout)
        console.log("delay 2");
    }
}

const t = new Test();
t.test(1000)
t.test(100)

.babelrc (для дитини 6)

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

Секундомір із кумулятивними циклами

Працює з сервером і клієнтом (Node або DOM), використовує Performance API. Добре, коли у вас багато невеликих циклів, наприклад, у функції, яка називається 1000 разів, яка обробляє 1000 об'єктів даних, але ви хочете побачити, як кожна операція в цій функції додає до загального.

Таким чином, цей використовує модуль глобальний (однотонний) таймер. Те саме, що шаблон одиночного класу, просто простіший у використанні, але вам потрібно помістити це в окремий, наприклад, stopwatch.jsфайл.

const perf = typeof performance !== "undefined" ? performance : require('perf_hooks').performance;
const DIGITS = 2;

let _timers = {};

const _log = (label, delta?) => {
    if (_timers[label]) {
        console.log(`${label}: ` + (delta ? `${delta.toFixed(DIGITS)} ms last, ` : '') +
            `${_timers[label].total.toFixed(DIGITS)} ms total, ${_timers[label].cycles} cycles`);
    }
};

export const Stopwatch = {
    start(label) {
        const now = perf.now();
        if (_timers[label]) {
            if (!_timers[label].started) {
                _timers[label].started = now;
            }
        } else {
            _timers[label] = {
                started: now,
                total: 0,
                cycles: 0
            };
        }
    },
    /** Returns total elapsed milliseconds, or null if stopwatch doesn't exist. */
    stop(label, log = false) {
        const now = perf.now();
        if (_timers[label]) {
            let delta;
            if(_timers[label].started) {
                delta = now - _timers[label].started;
                _timers[label].started = null;
                _timers[label].total += delta;
                _timers[label].cycles++;
            }
            log && _log(label, delta);
            return _timers[label].total;
        } else {
            return null;
        }
    },
    /** Logs total time */
    log: _log,
    delete(label) {
        delete _timers[label];
    }
};

Найкращим способом було б використання performance hooksмодуля. Хоча нестабільний, ви можете markконкретна області коду і між зазначеними областями.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);

Спробуйте тут

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

З продуктивністю

NodeJs: Потрібно імпортувати клас продуктивності

var time0 = performance.now(); // Store the time at this point into time0

yourFunction();   // The function you're measuring time for 

var time1 = performance.now(); // Store the time at this point into time1

console.log("youFunction took " + (time1 - time0) + " milliseconds to execute");

Використання console.time

console.time('someFunction');

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

console.timeEnd('someFunction');

1. Щоб почати використання таймераconsole.time("myTimer");
2. Необов’язково: Щоб надрукувати минулий час, використовуйте console.timeLog("myTimer");
3. Нарешті, щоб зупинити таймер та надрукувати останній час:console.timeEnd("myTimer");

Ви можете прочитати про це на MDN і в документації Node.js .

Доступний у Chrome, Firefox, Opera та NodeJS. (не в Edge чи Internet Explorer).

Як було зазначено раніше, перевіряйте та використовуйте вбудований таймер. Але якщо ви хочете або вам потрібно написати своє, ось два мої центи:

//=-=|Source|=-=//
/**
 * JavaScript Timer Object
 *
 *      var now=timer['elapsed'](); 
 *      timer['stop']();
 *      timer['start']();
 *      timer['reset']();
 * 
 * @expose
 * @method timer
 * @return {number}
 */
timer=function(){
    var a=Date.now();
    b=0;
    return{
        /** @expose */
        elapsed:function(){return b=Date.now()-a},
        start:function(){return a=Date.now()},
        stop:function(){return Date.now()},
        reset:function(){return a=0}
    }
}();

//=-=|Google Advanced Optimized|=-=//
timer=function(){var a=Date.now();b=0;return{a:function(){return b=Date.now()-a},start:function(){return a=Date.now()},stop:function(){return Date.now()},reset:function(){return a=0}}}();

Компіляція мала успіх!

• Оригінальний розмір: 219 байтів gzipped (405 байт нестиснуто)
• Розмір у компіляції: 109 байтів gzipped (187 байт нестиснене)
• Збережено 50,23% від зменшеного розміру (53,83% без gzip

Прийнята відповідь неправильна !

Оскільки JavaScript є асинхронним, значення змінного кінця прийнятої відповіді було б неправильним.

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 може бути дуже швидким, тому ви не можете побачити, що результат неправильний. Ви можете перевірити його за допомогою коду, виконавши якийсь запит:

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

Тож сповіщення підкаже дуже швидко, але на консолі ви побачите, що запити ajax тривають.

Ось як слід це зробити: https://developer.mozilla.org/en-US/docs/Web/API/Performance.now