Benchmark: Date.now()/new Date().getTime()/performance.now()/perf.now() - caching test

Script Preparation code:

var timestamp = null;
var nowFetcher = Date.now
var perf = performance
var perfNowFetcher = performance.now.bind(performance)

Tests:

Date.now()
timestamp = Date.now();
new Date().getTime();
timestamp = new Date().getTime();
performance.now()
timestamp = performance.now()
perf.now()
timestamp = perf.now()
Date.now() -- direct method call
nowFetcher()
perf.now() -- direct method call
perfNowFetcher()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Date.now()
new Date().getTime();
performance.now()
perf.now()
Date.now() -- direct method call
perf.now() -- direct method call

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The benchmark measures the performance difference between various methods for fetching the current time in JavaScript:

1. `Date.now()` and its variants (`new Date().getTime()`, `performance.now()`, and `perf.now()`)
2. Direct method calls (e.g., `nowFetcher()`, where `nowFetcher` is assigned to either of these methods)

**Options compared**

The benchmark compares the performance of each method:

1. **Direct method call**: Calling a method directly, without any caching or optimization.
	* Pros: Simple and easy to implement.
	* Cons: May be slower due to overhead of method invocation.
2. **Cached method call**: Caching the result of `Date.now()` or its variants using variables (`timestamp`, `nowFetcher`, etc.) before calling the method again.
	* Pros: Can improve performance by reducing function calls and caching results.
	* Cons: May require more memory to store cached values, and caching may not be efficient for all use cases.
3. **Bound methods**: Bounding a function with `bind()` or similar methods (e.g., `perf.now.bind(performance)`).
	* Pros: Can improve performance by reducing the overhead of method invocation.
	* Cons: May require more memory to store bound functions, and binding may not be necessary for all use cases.

**Other considerations**

* **JavaScript engine**: The benchmark is run on Chrome 94 with a Windows desktop platform.
* **Timing functions**: `Date.now()` and its variants are timing functions that return the number of milliseconds since the Unix epoch. `performance.now()` returns a high-resolution timer value in fractional seconds, while `perf.now()` (not a standard function) likely returns a similar value.

**Library usage**

None of the test cases use any external libraries or dependencies.

**Special JS features**

There are no special JavaScript features or syntaxes mentioned in this benchmark. However, it's worth noting that some methods may have performance implications due to their implementation or interaction with other parts of the browser (e.g., how `performance.now()` interacts with the browser's timer).

**Alternatives**

For measuring performance in JavaScript, developers can use various tools and libraries, such as:

1. Benchmarking libraries like Microbenchmark.js or Benchmark.
2. Built-in timing functions, like `Date.now()` and `performance.now()`.
3. Browser-specific APIs, like Web Performance API.

Keep in mind that the best approach will depend on the specific requirements of your project, including factors like performance goals, complexity, and compatibility with different browsers and platforms.

Related benchmarks:

Date.now()/new Date().getTime()/performance.now()/perf.now() - caching test (version: 1)

Comparing performance of: Date.now() vs new Date().getTime(); vs performance.now() vs perf.now() vs Date.now() -- direct method call vs perf.now() -- direct method call

Created: 4 years ago by: Registered User

Jump to the latest result

Date.now()

new Date().getTime();

performance.now()

perf.now()

Date.now() -- direct method call

perf.now() -- direct method call

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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