Benchmark: Date.now() vs new Date().getTime() vs performance.now() vs console.time("")

Script Preparation code:

var timestamp = null;

Tests:

Date.now()
timestamp = Date.now();
new Date().getTime();
timestamp = new Date().getTime();
performance.now();
timestamp = performance.now()
console.time();
timestamp = console.time("")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Date.now()
new Date().getTime();
performance.now();
console.time();

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 days ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 131 on Android

View result in a separate tab

Test name	Executions per second
Date.now()	3349938.0 Ops/sec
new Date().getTime();	3079007.8 Ops/sec
performance.now();	2555236.0 Ops/sec
console.time();	53862.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what each test case is measuring, along with their pros and cons.

**Benchmark Definition**

The benchmark definition represents a single test case. In this case, it measures the performance of different methods to get the current time in milliseconds:

* `Date.now()`
* `new Date().getTime()`
* `performance.now()`
* `console.time("")`

These methods are compared to determine which one is the fastest.

**Library/Functionality**

Here's a brief overview of each library/functionality used:

* `Date`: This object provides methods for working with dates and times. In this case, it uses the `now()` method to get the current time in milliseconds.
* `new Date()`: This creates a new date object that represents the current date and time. The `getTime()` method is then called on this object to get the current time in milliseconds.
* `performance`: This object provides methods for measuring performance-related metrics, such as the current time in milliseconds (using `now()`). It's designed to be more accurate than other methods like `Date`.
* `console.time()`: This function records the start of a timer and returns a string that can be used to record the end of the timer. The difference between the start and end times is displayed as an execution time.

**Pros and Cons**

Here's a brief summary of the pros and cons for each method:

* `Date.now()`: Pros: Simple, widely supported. Cons: May not be as accurate as other methods due to potential timing issues.
* `new Date().getTime()`: Pros: Similar to `Date.now()` but provides more precise control over formatting dates. Cons: Requires creating a new date object, which can lead to additional overhead.
* `performance.now()`: Pros: Highly accurate and optimized for performance-related measurements. Cons: May be less widely supported than other methods.
* `console.time()`: Pros: Easy to use and displays execution times in the console. Cons: Not designed specifically for measuring performance; its accuracy may vary depending on browser implementation.

**Special Features**

The benchmark uses some special features:

* The `timestamp` variable is used to store the current time, which allows each test case to start from a consistent point.
* The `RawUAString`, `Browser`, `DevicePlatform`, and `OperatingSystem` fields provide metadata about the user agent string (UA) returned by the browser. This can be useful for understanding how different browsers interact with the benchmark.

**Alternatives**

If you were to implement this benchmark from scratch, here are some alternatives:

* Use a more robust timing library like `ms/timer` or `performance-measure`.
* Consider using a framework-specific timing API (e.g., React's `useEffect()` hook).
* If not using JavaScript, explore alternative languages with built-in timing APIs (e.g., C++'s `std::chrono`).

Keep in mind that the specific implementation will depend on your use case and requirements.

Related benchmarks:

Date.now() vs new Date().getTime() vs performance.now() vs console.time("") (version: 0)

Comparing performance of: Date.now() vs new Date().getTime(); vs performance.now(); vs console.time();

Created: one year ago by: Guest

Jump to the latest result

Date.now()

new Date().getTime();

performance.now();

console.time();

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):