下面是计时函数的修饰符

它包装函数，以便它们每次运行时都能计时

用法：

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' 

这是装饰者：

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

如果您使用的是异步函数，您可以将其设置为定时异步，并在f（…args）之前添加一个await，这应该适用于这些函数。如果您希望一个装饰器同时处理同步和异步函数，则会变得更加复杂。

几个月前，我用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)
}

注：

如果您打算在Node.js应用程序中使用性能对象，则必须包含以下要求：const｛performance｝=require（'perf_hooks'）

具有累积循环的秒表

与服务器和客户端（节点或DOM）一起工作，使用Performance API。当您有许多小循环时（例如，在处理1000个数据对象的调用1000次的函数中）很好，但您希望了解该函数中的每个操作如何相加。

所以这一个使用了模块全局（singleton）计时器。与类单例模式相同，只是使用起来稍微简单一点，但您需要将其放在一个单独的例如秒表.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];
    }
};

如前所述，检查并使用内置计时器。但如果你想或需要写你自己的，这里是我的两分钱：

//=-=|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字节未压缩）节省了50.23%的gzip大小（53.83%没有gzip

谢谢，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]/10000；在回调中。例如

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

});

注意：纯函数ES6方法的最简单实现，无需额外变量，只需3行代码。处理同步和异步代码，因此不需要外部库，可以在JavaScript和NodeJS中工作，甚至可以用来测试API的延迟

// Create one-liner timer function
let [timer, timingMonitor] = [0, () => timer = !timer ? Date.now() : `${Date.now() - timer}ms`]
        
// Initiate timer
timingMonitor();
        
// Your code here
doSomething();
        
// Capture and store the elapsed time 
const timeElapsed = timingMonitor();

console.log(timeElapsed);
// Console output: "102ms", for example