함수 실행에 걸리는 시간을 측정하는 방법
실행 시간을 밀리 초 단위로 가져와야합니다.
저는 원래 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()문서 :
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 ()를 사용하지 마십시오. 아래를 읽으십시오.
<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 ++
오페라 15 ++
Android 4.4 ++
console.time가능한있을 수 있습니다 당신을 위해 ,하지만 비표준입니다 § :
이 기능은 비표준이며 표준 트랙에 없습니다. 웹에 접하는 프로덕션 사이트에서는 사용하지 마십시오. 모든 사용자에게 작동하지 않습니다. 구현간에 큰 비 호환성 이있을 수 있으며 향후 동작이 변경 될 수 있습니다.
브라우저 지원 외에도 .NET의 베어 본 버전 인 것처럼 보이므로 더 정확한 타이밍을 제공 performance.now할 수있는 잠재력 이있는 것 같습니다 console.time.
<호언 장담> 또한, 이제까지 사용하지 마십시오 Date위해 무엇이든 이 "시스템 시간"변화에 영향 있기 때문에. 즉 , 사용자에게 정확한 시스템 시간이없는 경우 "부정적인 타이밍"과 같은 잘못된 결과 를 얻게됩니다.
2014 년 10 월, 시스템 시계가 엉망이되어 무엇을 추측 하겠습니까 ? .... Gmail을 열고 " 0 분 전에 보낸"하루 동안의 모든 이메일을 보았습니다 . 그리고 저는 Gmail이 Google의 세계적인 엔지니어에 의해 구축되어야한다고 생각했습니다 .......
(시스템 시계를 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()은 정의되지 않았습니다.
야생에서 함수 실행 시간을 얻으 려면 코드를 계측해야합니다. 몇 가지 옵션이 있습니다. 다음을 쿼리하여 시작 및 종료 시간을 간단히 저장할 수 있습니다 new Date().getTime().
function a() {
var start = new Date().getTime();
... do stuff ...
var end = new Date().getTime();
var dur = end - start;
}
그러나 Date개체는 밀리 초 해상도 만 가지며 OS의 시스템 시계 변경에 영향을받습니다. 최신 브라우저에는 더 나은 옵션이 있습니다.
더 나은 옵션은 일명 High Resolution Time 을 사용하는 것 window.performance.now()입니다. 두 가지 중요한 측면에서 now()기존보다 낫습니다 Date.getTime().
now()페이지 탐색 시작 이후 밀리 초 수를 나타내는 밀리 초 미만 해상도의 double입니다. 분수 단위로 마이크로 초 수를 반환합니다 (예 : 1000.123 값은 1 초이고 123 마이크로 초입니다).now()단조롭게 증가합니다. 이것은 중요하다Date.getTime()할 가능성이 후속 호출에 뒤로 앞으로 또는 이동. 특히 OS의 시스템 시간이 업데이트되면 (예 : 원자 시계 동기화)Date.getTime()업데이트됩니다.now()항상 단조롭게 증가하므로 OS의 시스템 시간에 영향을받지 않습니다. 항상 벽시계 시간입니다 (벽시계가 원 자성이 아니라고 가정하면 ...).
now()new Date().getTime(), + new Dateandt Date.now()가 있는 거의 모든 장소에서 사용할 수 있습니다 . 예외는 점이다 Date과 now()같은 시간, 혼합하지 마십시오 Date기반으로 유닉스 시대 (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에서 지원됩니다. 사용 가능한 여러 polyfill도 있습니다.
실행 시간을 측정하는 또 다른 옵션은 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 +에서 사용할 수 있습니다. 도있다 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를 사용하고 콘솔과 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)
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 start = +new Date();
callYourFunctionHere();
var end = +new Date();
var time = end - start;
console.log('total execution time = '+ time + 'ms');
하나의 변수 만 사용할 수 있습니다.
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.")
감사합니다, 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;
});
타이밍 함수를위한 데코레이터가 있습니다.
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'
비동기 함수를 사용하는 경우 timedasync를 만들고 await앞에 f (... args)를 추가 할 수 있습니다 . 하나의 데코레이터가 동기화 및 비동기 기능을 모두 처리하도록하려면 더 복잡해집니다.
몇 달 전에 Date.now ()를 사용하여 함수를 시간 계산하는 루틴을 작성했습니다. 당시에는 허용 된 메서드가 performance.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 앱에서 객체 를 사용하려는 경우 다음 요구 사항을 포함해야합니다. const { performance } = require('perf_hooks')
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 (Babel 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);
여기에서 시도
이 목표를 달성하는 방법에는 여러 가지가 있습니다.
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');이것이 가장 효율적인 방법입니다 : 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";
+ (연산자 추가) 또는 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 ()은 단항 + 연산자보다 더 나은 성능을 제공합니다.
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');
앞서 언급했듯이 내장 타이머를 확인하고 사용하십시오. 그러나 당신이 원하거나 필요로하는 경우 여기에 나의 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 바이트 비 압축)
- 컴파일 된 크기 : 109 바이트 gzip 압축 (187 바이트 비 압축)
- gzip으로 압축하지 않은 경우 50.23 % 할인 (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
참고 URL : https://stackoverflow.com/questions/313893/how-to-measure-time-taken-by-a-function-to-execute
'Nice programing' 카테고리의 다른 글
| Ruby에서 쉘 명령 호출 (0) | 2020.09.27 |
|---|---|
| SQL IN 절 매개 변수화 (0) | 2020.09.27 |
| 선택 상자의 모든 옵션을 제거한 다음 하나의 옵션을 추가하고 jQuery로 선택하는 방법은 무엇입니까? (0) | 2020.09.27 |
| AngularJS 컨트롤러의 'this'vs $ scope (0) | 2020.09.27 |
| 주어진 커밋을 포함하는 분기를 나열하는 방법은 무엇입니까? (0) | 2020.09.27 |