Benchmark: Date.now() vs new Date().getTime() vs performance.measure() vs anchoredClock2

Script Preparation code:

let start = null;
let end = null;

let epochMs = Date.now();
let perfMs = performance.now();

Tests:

Date.now()
start = Date.now(); end = Date.now();
new Date().getTime();
start = new Date().getTime(); end = new Date().getTime();
performance.now()
start = performance.now() end = performance.now()
performance.measure
performance.mark('start') start = Date.now() const { duration } = performance.measure('span', 'start') end = start + duration
Date.now() & performance.now
// 1000.2534221 = offset delta const startDelta = performance.mark('start').startTime - 1000.2534221 startTime = 1000.2534221 + startDelta const endDelta = performance.measure('span_duration', 'start').duration endTime = 1000.2534221 + endDelta

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Date.now()
new Date().getTime();
performance.now()
performance.measure
Date.now() & performance.now

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The provided benchmark definition is:

`"Date.now() vs new Date().getTime() vs performance.measure() vs anchoredClock2"`

This benchmark compares the performance of four different approaches to measure time in JavaScript:

1. `Date.now()`
2. `new Date().getTime()`
3. `performance.measure()`
4. `anchoredClock2` (not explicitly explained, but we'll get to that later)

**Options Compared**

The options being compared are essentially methods for measuring time or creating a timing anchor in JavaScript.

* `Date.now()` and `new Date().getTime()` both return the number of milliseconds since the Unix epoch (January 1, 1970, 00:00:00 UTC). While they appear similar, `Date.now()` is generally considered faster because it's more optimized.
* `performance.measure()` is a newer method introduced in Chrome 112. It allows for more accurate timing measurements and can be used to create a timing anchor.
* `anchoredClock2` is not explicitly explained in the benchmark definition, but based on the code snippets provided, it appears to be a custom implementation that uses a similar approach as `performance.measure()`.

**Pros and Cons**

Here's a brief overview of the pros and cons of each option:

* `Date.now()`:
	+ Pros: Fast, widely supported.
	+ Cons: May not be accurate for very short time intervals (due to browser-specific optimizations).
* `new Date().getTime()`:
	+ Pros: More readable than `Date.now()`, can be useful in certain scenarios.
	+ Cons: Generally slower than `Date.now()`.
* `performance.measure()`:
	+ Pros: More accurate, allows for creating a timing anchor.
	+ Cons: Requires Chrome 112 or later, may have performance overhead.
* `anchoredClock2` (not explicitly explained):
	+ Pros: Not specified, but likely offers some benefits similar to `performance.measure()`.
	+ Cons: Not widely supported, custom implementation.

**Library and Syntax**

In this benchmark, the following libraries/syntax are used:

* None explicitly mentioned. However, it's worth noting that `performance.now()` uses a specialized method in modern browsers for measuring time.
* Custom implementation (`anchoredClock2`).

**Special JS Features or Syntax**

There isn't any special JavaScript feature or syntax being tested here.

**Other Considerations**

When choosing a timing mechanism, consider the following factors:

* Accuracy: How precise do you need your measurements to be?
* Readability: Will your code be more readable with `Date.now()` or `new Date().getTime()`?
* Performance overhead: Are the additional operations introduced by `performance.measure()` worth the benefits?

**Alternatives**

If you're looking for alternatives to these options, consider:

* Using a dedicated timing library like `microtime` (Node.js) or `moment-timezone` (browser-based).
* Utilizing browser-specific APIs, such as `requestAnimationFrame()` for measuring time intervals.
* Implementing your own custom timing mechanism using Web Workers or WebAssembly.

Keep in mind that these alternatives may offer different trade-offs in terms of accuracy, performance, and readability.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36

Browser/OS: Chrome 112 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Date.now()	3056928.8 Ops/sec
new Date().getTime();	2800275.5 Ops/sec
performance.now()	2114252.5 Ops/sec
performance.measure	572087.9 Ops/sec
Date.now() & performance.now	628031.2 Ops/sec

Related benchmarks:

Date.now() vs new Date().getTime() vs performance.measure() vs anchoredClock2 (version: 0)

Comparing performance of: Date.now() vs new Date().getTime(); vs performance.now() vs performance.measure vs Date.now() & performance.now

Created: one year ago by: Guest

Jump to the latest result

Date.now()

new Date().getTime();

performance.now()

performance.measure

Date.now() & performance.now

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):