window.performance.now() equivalent in nodejs?

Question

I think the question is straight forward.

I'm looking for something that's similar to window.performance.now() in nodejs V8 engine.

Right now I'm just using:-

var now = Date.now();
//do some processing..
console.log("time elapsed:", Date.now() - now);

But, I read that window.performance.now() is lot more accurate than using the date because of the what's defined here.

Answer 1

Node v8.5.0 has added Performance Timing API, which includes the performance#now(), e.g.

const {
  performance
} = require('perf_hooks');

console.log('performance', performance.now());

Answer 2

I would only mention that three of the reasons the author gives for the preference of the timing API in the browser wouldn't seem to apply directly to a node situation, and the fourth, the inaccuracy of Javscript time, cites an article from 2008, and I would strongly caution against relying on older material regarding Javascript performance specifics, particularly given the recent round of performance improvements all the engines have made to support "HTML5" apps.

However, in answer to your question, you should look at process.hrtime()

UPDATE: The present package (available via npm install present) provides some sugar around hrtime if you'd like it.

Note: Since the version 8.5.0 of Node, you can use performance.now()

Answer 3

Here's a shortcut for process.hrtime() that returns milliseconds instead of microseconds:

function clock(start) {
    if ( !start ) return process.hrtime();
    var end = process.hrtime(start);
    return Math.round((end[0]*1000) + (end[1]/1000000));
}

Usage:

var start = clock();
// do some processing that takes time
var duration = clock(start);
console.log("Took "+duration+"ms");

Will output something like "Took 200ms"

Answer 4

What about?

console.time('FooTimer');
// do the work
console.timeEnd('FooTimer');

Answer 5

process.uptime()

---

• Official Node Documentation

"The process.uptime() method returns the number of seconds the current Node.js process has been running.

The return value includes fractions of a second. Use Math.floor() to get whole seconds."

Example: Measure For Loop Execution Time

---

const nemo = ['nemo'];

function findNemo(array) {
  
  let start_time = process.uptime();

  for (let iteration = 0; iteration < array.length; iteration++) {
     if (array[iteration] === 'nemo') {
        console.log("Found Nemo");
     }
  }

  let end_time = process.uptime();

  console.log("For loop took this much time: ", end_time - start_time);
}

findNemo(nemo);

Example Output

---

Answer 6

Here's a Typescript version with process.hrtime(), based on NextLocal's answer:

class Benchmark {

    private start = process.hrtime();

    public elapsed(): number {
        const end = process.hrtime(this.start);
        return Math.round((end[0] * 1000) + (end[1] / 1000000));
    }
}

export = Benchmark;

Usage:

import Benchmark = require("./benchmark");

const benchmark = new Benchmark();

console.log(benchmark.elapsed());

Answer 7

To sum up and avoiding using perf_hooks

const performance = {
        now: function(start) {
            if ( !start ) return process.hrtime();
            var end = process.hrtime(start);
            return Math.round((end[0]*1000) + (end[1]/1000000));
        }
    }
console.log('performance', performance.now());

Answer 8

This method came into existence in version 8.5.0 of nodejs https://nodejs.org/api/perf_hooks.html#perf_hooks_performance_measurement_apis

Answer 9

compare solutions with and without loop.

Note down, which makes a difference performance wise ?

Try it out in JS snippets in developer tools or any JS editor.

function sum(n) {
  let total = 0;
  for (let i = 0; i <= n; i++) {
    total += i;
  }
  return total;
}

var t1 = performance.now();

sum(100000000);

var t2 = performance.now();

console.log(`time elapsed: ${(t2-t1)/1000} seconds.`);

function addupto(n) {
  return n * (n + 1) / 2;
}

var t3 = performance.now();

addupto(100000000);

var t4 = performance.now();

console.log(`time elapsed: ${(t4-t3)/1000} seconds.`);