Benchmark: parseDateISO vs parseDate vs parseDateInline

Script Preparation code:

var dateTimeISO = '2024-08-21T17:00:00.000Z'

var normalizeToLocalDate = (date) =>
    date.length === 10 && /^\d{4}-\d{2}-\d{2}$/.test(date) ? ` ${date}` : date;

var parseDateISO = (date) => new Date(date);

var parseDate = (date) => new Date(normalizeToLocalDate(date));

var parseDateInline = (date) =>
    date.length === 10 && /^\d{4}-\d{2}-\d{2}$/.test(date) ?
    new Date(` ${date}`) :
    new Date(date);

Tests:

new Date
new Date(dateTimeISO)
parseDateISO
parseDateISO(dateTimeISO)
parseDate
parseDate(dateTimeISO)
parseDateInline
parseDateInline(dateTimeISO)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Date
parseDateISO
parseDate
parseDateInline

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark compares the performance of three different approaches for parsing ISO dates in JavaScript.

**What's being tested?**

The benchmark tests the execution time of each approach on parsing an ISO date string (`dateTimeISO`) into a Date object:

1. `new Date(dateTimeISO)`: This is the built-in JavaScript method for parsing a date string.
2. `parseDateISO(dateTimeISO)`: This function uses the `new Date()` constructor to parse the date string.
3. `parseDate(dateTimeISO)`: This function first normalizes the date string using a custom function (`normalizeToLocalDate`) and then passes it to the built-in `new Date()` constructor.
4. `parseDateInline(dateTimeISO)`: This function uses a custom expression to check if the date string is in the correct format (10 characters long with a specific format) and then parses it using the `new Date()` constructor.

**Options comparison**

The benchmark compares the performance of these four approaches:

* **Pros and Cons:**
	+ Built-in `new Date()` method:
		- Pros: Simple, well-documented, and widely supported.
		- Cons: May be slower than custom implementations due to overhead from JavaScript's string parsing and conversion mechanisms.
	+ `parseDateISO()` function:
		- Pros: Directly uses the `new Date()` constructor, which is fast and efficient.
		- Cons: Does not perform any input validation or normalization, which can lead to errors if the input date string is malformed.
	+ `parseDate()` function:
		- Pros: Performs input validation and normalization, making it more robust than `parseDateISO()`.
		- Cons: May be slower than `parseDateISO()` due to the overhead of the custom functions.
	+ `parseDateInline()` function:
		- Pros: Combines the benefits of `parseDate()`'s input validation and normalization with the efficiency of `new Date()` constructor.
		- Cons: The custom expression may be slower than a simple input validation check, as it uses regular expressions.
* **Other considerations:** The benchmark does not consider factors like browser version compatibility or potential security vulnerabilities.

**Library usage**

There is no explicit library usage in this benchmark. However, the `normalizeToLocalDate` function used in the `parseDate()` approach likely relies on built-in JavaScript functions or libraries for string manipulation and date parsing.

**Special JS feature/syntax**

This benchmark does not use any special JavaScript features or syntax that would require specific knowledge of those features to understand the benchmark setup. The focus is on comparing the performance of different approaches, making it accessible to a wide range of software engineers.

**Alternatives**

Other alternatives for parsing ISO dates in JavaScript might include:

* Using a dedicated date parsing library like Moment.js
* Utilizing a polyfill for older browsers that may not support modern Date object parsing features
* Implementing custom date parsing logic using regular expressions or other string manipulation techniques

However, the built-in `new Date()` method remains a widely supported and efficient way to parse ISO dates in JavaScript.

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 127 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
new Date	4364059.5 Ops/sec
parseDateISO	3776009.2 Ops/sec
parseDate	3387259.2 Ops/sec
parseDateInline	3798111.5 Ops/sec

Related benchmarks:

parseDateISO vs parseDate vs parseDateInline (version: 0)

Comparing performance of: new Date vs parseDateISO vs parseDate vs parseDateInline

Created: 2 months ago by: Registered User

Jump to the latest result

new Date

parseDateISO

parseDate

parseDateInline

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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