Benchmark: new Intl.DateTimeFormat vs cached Intl.DateTimeFormat vs custom

new Intl.DateTimeFormat vs cached Intl.DateTimeFormat vs custom (version: 0)

measure the perf impact of caching calls to new Intl.DateTimeFormat

Comparing performance of: new Intl.DateTimeFormat.format() vs cached Intl.DateTimeFormat.format() vs new Intl.DateTimeFormat.formatToParts vs cached Intl.DateTimeFormat.formatToParts() vs Custom

Created: one year ago by: Guest

Jump to the latest result

Script Preparation code:

const TWO_DIGIT = '2-digit';

var options = {
      month: TWO_DIGIT,
      year: 'numeric',
      day: TWO_DIGIT,
      hour: TWO_DIGIT,
      hour12: false,
      minute: TWO_DIGIT,
      second: TWO_DIGIT,
    }

var cached = new Intl.DateTimeFormat('en-US', options);

Tests:

new Intl.DateTimeFormat.format()
new Intl.DateTimeFormat('en-US', options).format(new Date());
cached Intl.DateTimeFormat.format()
cached.format(new Date());
new Intl.DateTimeFormat.formatToParts
new Intl.DateTimeFormat('en-US', options).formatToParts(new Date());
cached Intl.DateTimeFormat.formatToParts()
cached.formatToParts(new Date());
Custom
const date = new Date(); const year = date.getFullYear(); const month = (date.getMonth() + 1).toString().padStart(2, '0'); const day = date.getDate().toString().padStart(2, '0'); const hour = date.getHours().toString().padStart(2, '0'); const minute = date.getMinutes().toString().padStart(2, '0'); const second = date.getSeconds().toString().padStart(2, '0'); const millis = date.getMilliseconds(); const t = `${year}-${month}-${day} ${hour}:${minute}:${second},${millis}`; return t

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Intl.DateTimeFormat.format()
cached Intl.DateTimeFormat.format()
new Intl.DateTimeFormat.formatToParts
cached Intl.DateTimeFormat.formatToParts()
Custom

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36

Browser/OS: Chrome 127 on Windows

View result in a separate tab

Test name	Executions per second
new Intl.DateTimeFormat.format()	10662.6 Ops/sec
cached Intl.DateTimeFormat.format()	302187.7 Ops/sec
new Intl.DateTimeFormat.formatToParts	10600.3 Ops/sec
cached Intl.DateTimeFormat.formatToParts()	156026.7 Ops/sec
Custom	1130751.0 Ops/sec

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!

**Benchmark Overview**

The provided benchmark measures the performance impact of caching calls to `new Intl.DateTimeFormat` in JavaScript.

**Options Compared**

There are three options being compared:

1. **new Intl.DateTimeFormat**: This is the standard way of creating a date formatter without caching.
2. **cached Intl.DateTimeFormat**: This option caches the result of the first call to `new Intl.DateTimeFormat`, so subsequent calls return the cached result instead of recreating it.
3. **Custom**: This option uses manual string construction to format the date, which is not using the `Intl.DateTimeFormat` API at all.

**Pros and Cons**

1. **new Intl.DateTimeFormat**:
	* Pros: Easy to use, widely supported, and efficient for simple formatting needs.
	* Cons: Can be slow due to repeated calls to `new Intl.DateTimeFormat`, especially if caching is not enabled.
2. **cached Intl.DateTimeFormat**:
	* Pros: Reduces the overhead of repeated calls to `new Intl.DateTimeFormat` by caching the result.
	* Cons: May lead to slower performance if the cached result is no longer valid or if the cache is too large.
3. **Custom**:
	* Pros: Can be highly optimized for specific use cases, as it avoids any external dependencies like `Intl.DateTimeFormat`.
	* Cons: Requires manual string construction, which can be error-prone and less efficient than using a standardized API.

**Library and Purpose**

The `Intl.DateTimeFormat` library is part of the ECMAScript Internationalization API (ECMA-402). It provides a way to format dates and numbers in a culturally aware manner. The purpose of this library is to help developers work with dates and numbers across different languages and regions, while also providing a standardized way of formatting them.

**Special JS Feature/Syntax**

There's no specific special JavaScript feature or syntax being used in this benchmark that requires explanation. It's all about comparing the performance of different approaches to formatting dates using `Intl.DateTimeFormat`.

**Other Alternatives**

If you're looking for alternatives to caching and manual string construction, you may want to consider:

1. **Memoization**: A technique where you cache the results of expensive function calls so that they can be reused instead of recalculated.
2. **String pooling**: A technique where you create a pool of pre-constructed strings to reuse instead of creating new ones on each call.

Keep in mind that these alternatives might have different trade-offs and performance characteristics compared to caching and manual string construction.

I hope this explanation helps!

Related benchmarks: