如何测量函数执行所需的时间


1188

我需要获取执行时间(以毫秒为单位)。

我最初是在2008年问这个问题的。当时接受的答案是使用new Date()。getTime()。但是,我们现在都同意使用标准performance.now() API更合适。因此,我正在更改对此答案的公认答案。


3
通常,证明您要在执行时间上完成的任务比单独回答问题要有用得多。如今,在Firebug或Chrome Dev工具中使用性能分析通常是查找吸收CPU汁液的代码的好得多的方法。
oligofren

这是经典的Date方法,它可以为您提供服务,ms并且足以应付大多数情况,我认为albertech.blogspot.com/2015/07/… ...但是,是的,您应该看看Performance.now
jar

5
performance.now()在Node中不起作用。 new Date().getTime()将在Node中工作。
瑞安·沃克

1
数字1000 upvote woop woop:D
Kiksen

1
@oligofren-有时您可能想要捕获此数据。我遇到了将其写到indexedDB的情况
ThomasRones

Answers:


1753

使用 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(客户端)文档

27
Chrome开发者工具现在也支持该功能。
julien_c 2012年

3
根据我的理解,这是目前收集准确时间的最佳方法。
灰蓝色

6
您是否不需要在这两个语句之间执行函数?现在,您需要测量定义它而不是执行它所花费的时间。如果我错了,请纠正我……
Cristian

2
链接到有关此功能的MDN文章:developer.mozilla.org/en-US/docs/DOM/console.time
空性

6
是的,您可以执行“ totalTime + = console.timeEnd('timer')'并为每个计时器执行此操作
vsync 2013年

637

使用新的Date()。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);

9
请注意,您可以用+ new Date()代替getTime()调用:var start = + new Date(); //做东西警报(“执行时间:” +(+新的Date())-开始);
J c

55
时间不准确,因为日期不适用于此功能。我在这里要大胆地说,如果您想要准确的计时,则应该使用vsync的示例。尽管仅在Chrome和Firefox ATM中有效。
灰蓝色

9
当心,getMilliseconds()为您提供当前秒的毫秒分数。如果将getTime()替换为getMilliseconds(),则超过一秒钟会得到负面结果。
RickyA 2013年

6
按当今的标准,vsync的答案要正确得多,并且使用Date()可能会导致显示非常错误的结果,尤其是在Windows平台上,在该平台上,结果可能会四舍五入并变为最接近的15ms边界,从而导致诸如微小代码位的时序为0ms。
oligofren

29
@AshBlue,我们应该使用window.performance.now。参见stackoverflow.com/a/15641427/632951
Pacerier,

405

不要使用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 ++

  • Safari 8 ++

  • Opera 15 ++

  • Android 4.4 ++

  • 等等

console.time可能对您来说可行,但这是非标准的§

此功能是非标准的,不在标准轨道上。请勿在面向Web的生产站点上使用它:它不适用于每个用户。实现之间可能存在很大的不兼容性,并且将来的行为可能会更改。

除了支持浏览器外,它performance.now似乎还有可能提供更准确的时间安排,因为它似乎是的准系统版本console.time


<咆哮>此外,永远不要使用Date什么,因为它受到在“系统时间”的变化。这意味着当用户没有准确的系统时间时,我们得到无效的结果,例如“负计时”:

2014年10月,我的系统时钟转入混乱状态,猜测是什么 ...。我打开Gmail并看到“ 0分钟前发送”的当天所有电子邮件。而且我认为Gmail应该由Google的世界级工程师构建。

(将您的系统时钟设置为一年前,然后转到Gmail,这样我们大家都可以大笑。也许有一天,我们将为JS创建一个耻辱堂Date。)

Google Spreadsheet的now()功能也遭受此问题的困扰。

您唯一要使用的时间Date是要向用户显示系统时钟时间。不是当你想要得到时间或测量任何东西。


3
正是我想要的!我希望能够一起添加几次,而实际上不能用控制台时间做到这一点。

8
请注意,Safari浏览器尚不支持此功能:developer.mozilla.org/en-US/docs/Web/API/Performance.now()
Akos K

2
我使用Firebug Profile和performance.now(),它们都可以正常工作。Performance.now()从Profile确认我的结果。

2
IE7(公司客户)无法解决我最大的麻烦。我不在乎测量chrome的性能,它总是快如闪电。
尼克

2
比console.time()更好。
桑耶夫2015年

52

如果需要在本地开发机器上获得函数执行时间,则可以使用浏览器的概要分析工具,也可以使用控制台命令,例如console.time()console.timeEnd()

所有现代浏览器都内置了JavaScript分析器。这些分析器应该提供最准确的测量结果,因为您不必修改现有代码,这可能会影响函数的执行时间。

剖析JavaScript:

  • Chrome中,按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对象只有毫秒级的分辨率,并且会受到任何操作系统的系统时钟更改的影响。在现代浏览器中,有一个更好的选择。

更好的选择是使用高分辨率时间(又名)window.performance.now()。 在两个重要方面now()优于传统Date.getTime()

  1. now()是具有毫秒级分辨率的双精度型,表示自页面导航开始以来的毫秒数。它以分数形式返回微秒数(例如,值1000.123为1秒和123微秒)。

  2. now()在单调增加。因为这是重要的Date.getTime()可能是跳跃式前进或后退,甚至在随后的调用。值得注意的是,如果OS的系统时间已更新(例如原子时钟同步),Date.getTime()则也会更新。 now()保证总是单调增加,因此它不受操作系统系统时间的影响-始终是挂钟时间(假设挂钟不是原子钟...)。

now()几乎可以在任何地方使用new Date().getTime()+ new Date和T Date.now()是。唯一的例外是,时间Datenow()时间不会混合在一起,这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];

在IE10 +和Chrome25 +中提供UserTiming。还有一个polyfill可用(我写过)。


1
优秀的,最新的答案恕我直言:)进行一些编辑后会更好。我想说的是用户时间不是“一个其他选项”进行测量,但当标杆不开发机器本身上完成较好的选择。使用您的polyfill,它可以在所有浏览器中使用。而躲着走的细节和样板performance.now,并Date为它存在的理由。
hashchange

34

要获得精确的值,您应该使用Performance接口。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时间准确性的链接,值得阅读。


很好的答案!这对我很有帮助!
结合

18

使用Firebug,启用控制台和Javascript。单击配置文件。重新加载。再次单击配置文件。查看报告。


8
好的建议,但显然仅适用于FF。我们经常想比较浏览器的速度... :-)
PhiLho

3
在新的Firebuq上,他们将此选项隐藏到菜单中,使用CTRL + SHIFT + P或console.profile(); console..profileEnd()
user956584'2

4
Chrome支持console.time()console.timeEnd()现在也。
julien_c 2012年

12
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()是可选的-只需将false传递给StopWatch构造函数即可。


12

process.hrtime()在Node.js中可用-它返回一个以纳秒为单位的值

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

1
如果您宁愿将其转换为ms e-3而不是建议的微秒e-6:hrtime[0] * 1000 + hrtime[1] / 1000000->是的,我也希望使用var hrtime!:P
cregox

11

您也可以在这里使用添加运算符

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

8

为了进一步扩展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);


这给您更多的可能性。您可以存储执行时间以用于更多目的,例如在公式中使用它,或存储在数据库中,通过websocket发送到远程客户端,在网页上提供服务等。


8

只能使用一个变量:

var timer = -performance.now();

// Do something

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

timer/1000 -将毫秒转换为秒

.toFixed(5) -修剪多余的数字


5

由于在某些主要浏览器(例如IE10)中不支持console.timeperformance.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);
        }
    }
}

5

它可能会帮助您。

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


1
尽管此代码段可以解决问题,但提供说明确实有助于提高您的帖子质量。请记住,您将来会为读者回答这个问题,而这些人可能不知道您提出代码建议的原因。也请尽量不要在代码中加入解释性注释,这会降低代码和解释的可读性!
菲诺18'Mar

5

这是计时功能的装饰器

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)之前添加一个,这应该适用于那些异步函数。如果您希望一个装饰器同时处理同步和异步功能,它将变得更加复杂。


这正是我想要的。谢谢!
Andrew Watters

有没有什么方法可以使其与异步函数一起通用?
TotalAMD

4

谢谢,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;

});

3

几个月前,我整理了自己的例程,使用Date.now()对函数进行计时-即使当时接受的方法似乎是performance.now()-因为性能对象尚不可用(已建立-in)在稳定的Node.js版本中。

今天,我进行了更多研究,发现了另一种计时方法。由于我也在Node.js代码中找到了如何使用它,因此我想在这里分享它。

以下是w3cNode.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')


我认为您performance.mark('end')在这种情况下不需要
kofifus

2

有多种方法可以实现此目标:

  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()比一元+运算符提供更好的性能。


1
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


1

如果要测量多个未嵌套事物之间的时间,可以使用以下方法:

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'

1

就我而言,我倾向于使用@ 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"
    ]
 }

1

具有累积周期的秒表

适用于服务器和客户端(节点或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];
    }
};

1

最好的方法是使用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);

试试这里


0
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

0

有表现

NodeJ:需要导入性能类

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

0
  1. 启动计时器使用console.time("myTimer");
  2. 可选:打印经过的时间,请使用 console.timeLog("myTimer");
  3. 最后,停止计时器并显示最终时间:console.timeEnd("myTimer");

您可以在MDNNode.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字节(未压缩405字节)
  • 编译大小:压缩后的109个字节(未压缩的187个字节)
  • 节省50.23%的压缩大小(不带gzip的53.83%

-6

接受的答案是错误的

由于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


9
这不是因为for循环。for循环将等到最后一个循环,直到继续执行您的源代码。AJAX调用是异步的。还有其他运行异步的功能。但是for循环不会执行异步。
Scriptlabs 2015年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.