Benchmark: Intl.DateTimeFormat vs ReduceReplace Date Format 2

Script Preparation code:

var date = 'Mar 24, 2021'

var formatDateByIntlDateTimeFormat = (dateOrString) => {
  return new Intl.DateTimeFormat('pt-BR').format(new Date(dateOrString))
}

var tokens = {
  // Padded day       = 01, 02, ..., 31
  DD: (date) => date.getDate().toString().padStart(2, '0'),
  // Padded month     = 01, 02, ..., 12
  MM: (date) => (date.getMonth() + 1).toString().padStart(2, '0'),
  // Padded year      = 0001, 0002, ..., 1995, ..., 2020, 2021
  YYYY: (date) => date.getFullYear().toString().padStart(4, '0'),
};

var formatDateByReduceReplace = (dateOrString, format = 'DD/MM/YYYY') => {
  const date = new Date(dateOrString)
  return Object.entries(tokens).reduce(
    (result, [pattern, fn]) => result.replace(new RegExp(pattern, 'g'), fn(date)),
    format
  );
};

var formatDateByReduceReplaceMultipleNewDate = (dateOrString, format = 'DD/MM/YYYY') => {
  return Object.entries(tokens).reduce(
    (result, [pattern, fn]) => result.replace(new RegExp(pattern, 'g'), fn(new Date(dateOrString))),
    format
  );
};

Tests:

Intl.DateTimeFormat
formatDateByIntlDateTimeFormat(date)
Reduce/Replace Format
formatDateByReduceReplace(date, 'DD/MM/YYYY')
Reduce/Replace Format multiple new Date calls
formatDateByReduceReplaceMultipleNewDate(date)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Intl.DateTimeFormat
Reduce/Replace Format
Reduce/Replace Format multiple new Date calls

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared, and the pros/cons of each approach.

**Benchmark Definition**

The benchmark compares three different ways to format dates in JavaScript:

1. **Intl.DateTimeFormat**: Uses the `Intl` API (Internationalization) to format dates.
2. **Reduce/Replace Format**: A custom implementation using regular expressions and a set of predefined formatting tokens.
3. **Reduce/Replace Format multiple new Date calls**: The same as above, but with an additional step that creates a new `Date` object for each format call.

**Options Compared**

* **Intl.DateTimeFormat**: Uses the built-in JavaScript API to format dates. Pros: efficient and accurate, but may have limitations depending on the browser/OS.
* **Reduce/Replace Format**: A custom implementation using regular expressions and tokens. Pros: flexible and easy to understand, but may be slower due to the overhead of creating a new `Date` object for each call.
* **Reduce/Replace Format multiple new Date calls**: Adds an extra step that creates a new `Date` object for each format call. This approach is likely slower than the other two options.

**Pros and Cons**

* **Intl.DateTimeFormat**:
	+ Pros: efficient, accurate, and widely supported.
	+ Cons: may not work as expected in older browsers or with certain locales.
* **Reduce/Replace Format**:
	+ Pros: flexible, easy to understand, and works well for simple date formats.
	+ Cons: slower due to the overhead of creating a new `Date` object for each call.
* **Reduce/Replace Format multiple new Date calls**:
	+ Pros: potentially faster than Reduce/Replace Format by avoiding the need to create a new `Date` object for each format call.
	+ Cons: likely slower than Intl.DateTimeFormat due to the extra step of creating new `Date` objects.

**Library Used**

None is explicitly mentioned, but the use of regular expressions and tokens suggests that a basic understanding of JavaScript regex and string manipulation is required.

**Special JS Features or Syntax**

The benchmark uses the following features:

* **Intl API**: The Intl.DateTimeFormat function uses the Internationalization API to format dates.
* **Regular Expressions**: The Reduce/Replace Format implementation uses regular expressions to replace formatting tokens with actual values.

**Other Alternatives**

Some alternative approaches could be explored, such as using a dedicated date formatting library like Moment.js or Luxon. However, these libraries may add additional overhead and dependencies compared to the Intl API and custom regex-based implementation.

In general, the benchmark provides a useful comparison of different date formatting approaches in JavaScript, highlighting the trade-offs between efficiency, accuracy, and flexibility.

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36

Browser/OS: Chrome 81 on Linux

View result in a separate tab

Test name	Executions per second
Intl.DateTimeFormat	12801.2 Ops/sec
Reduce/Replace Format	312137.7 Ops/sec
Reduce/Replace Format multiple new Date calls	15433915.0 Ops/sec

Related benchmarks:

Intl.DateTimeFormat vs ReduceReplace Date Format 2 (version: 1)

Comparing performance of: Intl.DateTimeFormat vs Reduce/Replace Format vs Reduce/Replace Format multiple new Date calls

Created: 3 years ago by: Registered User

Jump to the latest result

Intl.DateTimeFormat

Reduce/Replace Format

Reduce/Replace Format multiple new Date calls

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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