함수가 실행하는 데 걸리는 시간을 측정하는 방법

실행 시간을 밀리 초 단위로 가져와야합니다.

원래 2008 년에이 질문을했습니다. 받아 들여진 대답은 new 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 일 자정 이후의 밀리 초 수를 리턴합니다.

전의.

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

• 파이어 폭스 15 ++

• 크롬 24 ++

• 사파리 8 ++

• 오페라 15 ++

• 안드로이드 4.4 ++

• 등

console.time가능한있을 수 있습니다 당신을 위해 ,하지만 비표준입니다 § :

이 기능은 비표준이며 표준 트랙이 아닙니다. 웹이있는 프로덕션 사이트에서는 사용하지 마십시오. 모든 사용자에게 적용되는 것은 아닙니다. 구현 간에는 큰 비 호환성 이있을 수 있으며 향후 동작이 변경 될 수 있습니다.

브라우저 지원 외에도 의 기본 버전 인 것처럼보다 정확한 타이밍을 제공 할 가능성performance.now 이있는 것 같습니다 .console.time

<rant> 또한 "시스템 시간"의 변경에 영향을 받기 때문에 어떤 용도 Date로 도 사용하지 마십시오 . 즉 , 사용자에게 정확한 시스템 시간이 없으면 "음성 타이밍"과 같은 잘못된 결과 가 나타 납니다 .

2014 년 10 월에 시스템 시계가 엉망이되어서 무엇을 추측 할 수 있을까요 ? ... Gmail을 열어서 " 0 분 전 보낸" 모든 이메일을 보았습니다 . 그리고 구글의 세계적 엔지니어들이 Gmail을 만들어야한다고 생각했습니다 .......

(시스템 시계를 1 년 전으로 설정하고 Gmail로 이동하여 모두 즐거운 시간을 보내십시오. 언젠가는 JS 의 명예의 전당 을 갖게 될 것 Date입니다.)

Google 스프레드 시트의 now()기능도이 문제로 인해 어려움을 겪고 있습니다.

당신이 사용할 유일한 시간 Date은 사용자 에게 자신의 시스템 시계 시간 을 보여주고 싶을 때입니다. 아니 당신이 얻을하려는 경우 시간 또는 측정 아무것도에 있습니다.

로컬 개발 시스템에서 함수 실행 시간을 가져와야하는 경우 브라우저의 프로파일 링 도구 또는 console.time()및과 같은 콘솔 명령을 사용할 수 있습니다 console.timeEnd().

모든 최신 브라우저에는 JavaScript 프로파일 러가 내장되어 있습니다. 이러한 프로파일 러는 기존 코드를 수정할 필요가 없으므로 가장 정확한 측정 값을 제공해야합니다. 이는 기능의 실행 시간에 영향을 줄 수 있습니다.

JavaScript를 프로파일 링하려면 :

• 에서 크롬 키를 눌러 F12 선택 프로파일 탭, 다음 수집 자바 스크립트 CPU 프로필 .
• 에서 파이어 폭스 , 오픈 / 방화범을 설치하고 클릭 프로필 버튼을 클릭합니다.
• 에서 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()은 정의되어 있지 않습니다.

wild에서 함수 실행 시간을 얻으 려면 코드를 계측해야합니다. 몇 가지 옵션이 있습니다. 다음을 쿼리하여 시작 및 종료 시간을 간단히 저장할 수 있습니다 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()입니다. 두 가지 중요한 방식으로 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()있습니다. 단 , 유닉스 시대 (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에서 지원됩니다. 사용 가능한 여러 폴리 필도 있습니다.

야생에서 실행 시간을 측정하기위한 다른 옵션은 UserTiming 입니다. UserTiming은 console.time()and와 비슷하게 작동 console.timeEnd()하지만 사용하는 것과 동일한 고해상도 타임 스탬프를 now()사용하므로 (1 밀리 초 미만의 단조 증가하는 클럭을 얻음) 타임 스탬프와 지속 시간을 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 +에서 사용할 수 있습니다. 내가 쓸 수 있는 polyfill도 있습니다.

정확한 값을 얻으려면 성능 인터페이스 를 사용해야합니다 . 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-60ms 이동 할 수 있습니다.

JavaScript에서 실행 시간 측정에 대한 이 훌륭한 게시물 을 확인하십시오 . 저자는 또한 읽을 가치가있는 JavaScript 시간의 정확성에 관한 몇 가지 링크를 제공합니다.

Firebug를 사용하고 Console과 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');

NodeJS의 값으로 timeEnd를 리턴 할 수 있도록 vsync의 코드를 더 확장하려면이 작은 코드를 사용하십시오.

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 (... args)를 추가 할 수 있으며 그 기능이 작동합니다. 한 데코레이터가 동기화 및 비동기 기능을 모두 처리하도록하려면 더 복잡해집니다.

감사합니다. 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;

});

몇 달 전에 필자는 허용 된 메소드가 performance.now () 인 것처럼 보이지만 Date.now () 사용하여 함수 시간을 계산하는 자체 루틴을 만들었습니다. 성능 개체를 아직 사용할 수 없기 때문에 안정적인 Node.js 릴리스에서 -in).

오늘 나는 더 많은 연구를하고 타이밍에 대한 다른 방법을 찾았습니다. 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 앱에서 객체 를 사용 하려면 다음 요구 사항을 포함해야합니다. 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 인스턴스의 값 가져 오기 Number로 변환

참고 : 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)와 함께 작동하며 PerformanceAPI를 사용합니다 . 예를 들어 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 바이트 압축 (405 바이트 비 압축)
• 컴파일 된 크기 : 109 바이트 압축 (187 바이트 비 압축)
• gzip 크기의 50.23 % 할인 (gzip 제외 53.83 %)

허용 된 답변이 잘못되었습니다 !

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 : 어떻게해야합니까?