関数の実行にかかる時間を測定する方法

実行時間をミリ秒単位で取得する必要があります。

私が最初にこの質問をしたのは2008年でした。受け入れられた答えは、新しいDate（）。getTime（）を使用することでしたが、今では標準のperformance.now（） API を使用する方が適切であることに同意できます。したがって、私はこれに対する受け入れられた回答を変更します。

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（クライアント側）のドキュメント

使用新しい日付を（）。getTime（）

getTime（）メソッドは、1970年1月1日の午前0時からのミリ秒数を返します。

例：

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

• Safari 8 ++

• Opera 15 ++

• Android 4.4 ++

• などなど

console.timeあなたにとっては実行可能かもしれませんが、それは非標準です§：

この機能は非標準であり、標準化されていません。Webに面している本番サイトでは使用しないでください。すべてのユーザーが使用できるわけではありません。また、実装間に大きな非互換性があり、動作が将来変更される可能性があります。

ブラウザのサポートに加えperformance.nowて、の最低限のバージョンであると思われるため、より正確なタイミングを提供する可能性があるようですconsole.time。

<rant>また、「システム時刻」の変更の影響を受けるため、決して何にも使用Dateしないでください。つまり、ユーザーが正確なシステム時刻を取得していない場合、「負のタイミング」などの無効な結果が返されます。

2014年10月に、システムクロックがおかしくなり、何が起こったのかを推測しました。Gmail を開いて、「0分前に送信された」という1日のメールをすべて確認しました。そして、GmailはGoogleの世界トップクラスのエンジニアによって構築されることになっていると思いました。

（システムクロックを1年前に設定し、Gmailに移動して、みんなが大笑いできるようにします。たぶん、いつかはJSの殿堂入りDate。）

Googleスプレッドシート now()機能にもこの問題があります。

使用する唯一の時間Dateは、ユーザーにシステムクロック時間を表示する場合です。あなたが取得したいしない場合は、時間をか何かを測定します。

あなたがお住まいの地域開発マシン上で機能の実行時間を取得する必要がある場合、あなたはどちらかのブラウザのプロファイリングツール、またはコンソールコマンドなどを使用することができるconsole.time()とconsole.timeEnd()。

すべての最新のブラウザーには、JavaScriptプロファイラーが組み込まれています。関数の実行時間に影響を与える可能性のある既存のコードを変更する必要がないため、これらのプロファイラーは最も正確な測定を提供する必要があります。

JavaScriptをプロファイルするには：

• ではクロム、プレスF12と選択プロファイル、そしてタブを収集するJavaScript CPUプロフィール。
• でFirefoxを、/オープンFirebugのをインストールして、をクリックしてプロフィールボタンを押します。
• ではIE 9+、プレスF12、をクリックしてスクリプトまたはプロファイラ（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オブジェクトの解像度はミリ秒のみであり、OSのシステムクロックの変更の影響を受けます。最近のブラウザーでは、より良いオプションがあります。

より良いオプションは、別名高解像度時間を使用することwindow.performance.now()です。 2つの重要な点でnow()従来のものより優れていDate.getTime()ます。

1. now()ページのナビゲーションが開始されてからのミリ秒数を表す、サブミリ秒の解像度を持つdoubleです。マイクロ秒数を小数で返します（たとえば、1000.123の値は1秒で123マイクロ秒です）。

2. now()単調増加しています。これは、後続の呼び出しで前方または後方にジャンプDate.getTime()する可能性があるため、重要です。特に、OSのシステム時刻が更新された場合（原子時計の同期など）Date.getTime()も更新されます。 now()は常に単調に増加することが保証されているため、OSのシステム時間の影響を受けません。常に壁時計時間になります（壁時計がアトミックでないと仮定した場合...）。

now()ほぼすべての場所で使用することができnew Date().getTime()、+ new Dateandt Date.now()です。例外は、Unixエポック（1970年からのミリ秒数）に基づいているようにDate、now()時刻が混在しないことですが、ページナビゲーションが開始されてからのミリ秒数です（したがって、ははるかに小さくなります）。Datenow()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でサポートされています。いくつかのポリフィルも利用できます。

実際に実行時間を測定するもう1つのオプションは、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 msのシフトが得られるということです。

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コンストラクター関数にfalseを渡すだけです。

process.hrtime（）はNode.js内で使用できます-ナノ秒単位の値を返します

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

ここでもadd演算子を使用できます

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

vsyncのコードをさらに拡張して、timeJSを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);

これにより、可能性が広がります。実行時間を保存して、方程式で使用したり、データベースに保存したり、WebSocket経由でリモートクライアントに送信したり、Webページで提供したりするなど、より多くの目的に使用できます。

変数は1つしか使用できません。

var timer = -performance.now();

// Do something

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

timer/1000 -ミリ秒を秒に変換する

.toFixed(5) -余分な数字をトリミングする

一部の主要ブラウザ（IE10など）ではサポートされていないためconsole.time、performance.now利用可能な最良の方法を利用するスリムなユーティリティを作成しました。ただし、誤った使用法（呼び出し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非同期にしてawaitbefore f（... args）を追加することができます。1つのデコレーターで同期機能と非同期機能の両方を処理する場合は、さらに複雑になります。

おかげで、Achim Koellnerはあなたの答えを少し広げます：

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（）を使用して関数の時間を計測する独自のルーチンを作成しました。 -in）安定した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)
}

注意：

performanceNode.jsアプリでオブジェクトを使用する場合は、次のrequireを含める必要があります。 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);

単項プラス演算子を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"
    ]
 }

累積サイクルを備えたストップウォッチ

サーバーとクライアント（ノードまたはDOM）で動作し、 Performance APIをます。たとえば、1000回のデータオブジェクトを処理する1000回と呼ばれる関数に小さなサイクルが多数あるが、この関数の各演算が合計にどのように加算されるかを確認する場合に適しています。

したがって、これはモジュールグローバル（シングルトン）タイマーを使用します。クラスシングルトンパターンと同じですが、使用は少し簡単ですが、これを別のeg 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、コードの特定の領域とマークされた領域measureのduration間を指定できます。

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にはありません）。

前述のように、組み込みのタイマーを確認して使用します。しかし、あなたがここにあなた自身を書くことを望むか、または必要とするならば、私の2セントです：

//=-=|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バイトgzip圧縮（405バイト非圧縮）
• コンパイル済みサイズ：gzip圧縮された109バイト（非圧縮187バイト）
• gzip圧縮されたサイズから50.23％節約（gzipなしで53.83％

受け入れられた答えは間違っています！

JavaScriptは非同期であるため、受け入れられた回答の変数endの値は間違っています。

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