Benchmark: string.split vs string.substring vs toLocaleDateString("pt-PT") vs Intl.DateTimeateTimeFormat

string.split vs string.substring vs toLocaleDateString("pt-PT") vs Intl.DateTimeateTimeFormat (version: 1)

Comparing performance of: split vs Date toLocaleString without date being cached vs slice vs substring vs Intl no format cache no date cache vs Intl no format cache with date cache vs Intl with format cache no date cache vs Intl with format cache with date cache vs Date toLocaleString with date being cached

Created: one month ago by: Guest

Jump to the latest result

Script Preparation code:

var dateStr = "2021-08-10";
var dateDate = new Date(dateStr);
var formatter = new Intl.DateTimeFormat("pt-PT");

Tests:

split
const [yyyy, mm, dd] = dateStr.split("/"); const result =`${dd}/${mm}/${yyyy}`;
Date toLocaleString without date being cached
const result = new Date(dateStr).toLocaleString("pt-PT");
slice
const day = dateStr.slice(8, 10); const month = dateStr.slice(5, 7); const year = dateStr.slice(0, 4); const result = `${day}/${month}/${year}`
substring
const day = dateStr.substring(8, 10); const month = dateStr.substring(5, 7); const year = dateStr.substring(0, 4); const result = `${day}/${month}/${year}`
Intl no format cache no date cache
const result = new Intl.DateTimeFormat("pt-PT").format(new Date(dateStr));
Intl no format cache with date cache
const result = new Intl.DateTimeFormat("pt-PT").format(dateDate);
Intl with format cache no date cache
const result = formatter.format(new Date(dateStr));
Intl with format cache with date cache
const result = formatter.format(dateDate);
Date toLocaleString with date being cached
const result = dateDate.toLocaleString("pt-PT");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
split
Date toLocaleString without date being cached
slice
substring
Intl no format cache no date cache
Intl no format cache with date cache
Intl with format cache no date cache
Intl with format cache with date cache
Date toLocaleString with date being cached

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0

Browser/OS: Firefox 136 on Windows

View result in a separate tab

Test name	Executions per second
split	9663759.0 Ops/sec
Date toLocaleString without date being cached	5636.4 Ops/sec
slice	676450816.0 Ops/sec
substring	733038336.0 Ops/sec
Intl no format cache no date cache	6414.0 Ops/sec
Intl no format cache with date cache	6546.7 Ops/sec
Intl with format cache no date cache	322170.4 Ops/sec
Intl with format cache with date cache	394237.5 Ops/sec
Date toLocaleString with date being cached	5870.1 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark tests various methods of date manipulation and formatting in JavaScript, specifically comparing string manipulation techniques and date formatting methods for converting a date string into a different format. Here’s a breakdown of the different approaches tested, their pros and cons, and other considerations.

### Approaches Tested

1. **String Manipulation with `split`**
   - **Test Case:** `const [yyyy, mm, dd] = dateStr.split("/");`
   - **Pros:** Very readable and straightforward. Easy to understand how the date is split into its components.
   - **Cons:** Relatively slow as it involves creating an array and may not be as performant as direct indexing methods.

2. **String Manipulation with `slice`**
   - **Test Case:** 
     ```javascript
     const day = dateStr.slice(8, 10);
     const month = dateStr.slice(5, 7);
     const year = dateStr.slice(0, 4);
     ```
   - **Pros:** Directly accesses the string based on indices, which may improve performance over `split` since there's no intermediate array created.
   - **Cons:** Slightly less readable than `split` for someone unfamiliar with `slice`.

3. **String Manipulation with `substring`**
   - **Test Case:**
     ```javascript
     const day = dateStr.substring(8, 10);
     const month = dateStr.substring(5, 7);
     const year = dateStr.substring(0, 4);
     ```
   - **Pros:** Similar to `slice`, it allows efficient direct access to string portions.
   - **Cons:** The behavior of `substring` can be slightly confusing due to its handling of parameters (it treats negative indices differently compared to `slice`).

4. **Date Formatting with `toLocaleString`**
   - **Test Case:** `const result = new Date(dateStr).toLocaleString("pt-PT");`
   - **Pros:** Automatically handles localization according to the specified locale settings, which is useful for displaying dates in a region-specific manner.
   - **Cons:** Slow compared to direct string manipulation approaches; may include unnecessary details (time) if only the date is needed.

5. **Using `Intl.DateTimeFormat` without caching**
   - **Test Case:** `const result = new Intl.DateTimeFormat("pt-PT").format(new Date(dateStr));`
   - **Pros:** Powerful and flexible for complex formatting needs, and can handle localization efficiently.
   - **Cons:** May be slower due to repeated creation of formatters without caching.

6. **Using `Intl.DateTimeFormat` with caching**
   - **Test Case:** 
     ```javascript
     const formatter = new Intl.DateTimeFormat("pt-PT");
     const result = formatter.format(new Date(dateStr));
     ```
   - **Pros:** Much faster for multiple date formats since the formatter is created once and reused.
   - **Cons:** Initial setup time for the formatter may be slightly longer.

### Performance Results

From the provided benchmark results, the following observations can be made:

- **Fastest:** The `substring` and `slice` methods proved to be the most performant, executing over 700 million times per second on the tested environment. This demonstrates the efficiency of directly accessing string parts compared to date manipulation functions.

- **Slowest:** The `Intl.DateTimeFormat` methods, particularly when not using caching, showed significantly lower execution rates (thousands of executions per second). This indicates that while they provide flexibility and convenience for localization, they may not be optimal for high-performance scenarios.

### Other Considerations

- **Readability vs. Performance:** For many developers, readability often takes precedence over raw performance. While `substring` and `slice` are more performant, `split` is often clearer, especially for those who are new to the language.
  
- **Locale Requirements:** It is vital to choose the right method based on the application requirements—if internationalization (i18n) is essential, using `Intl.DateTimeFormat` becomes more favorable despite its lower performance.

- **Caching Mechanisms:** By caching the `Intl.DateTimeFormat` instance, performance can be significantly enhanced in scenarios involving numerous date manipulations.

### Alternatives

Other alternatives for date formatting in JavaScript include:

- **Third-party libraries** such as **Moment.js**, **date-fns**, or **Luxon** that provide additional functionality, such as time zone support and more sophisticated date manipulation.
  
- **Native Date Object Methods**: Combining various Date methods, though less flexible than `Intl.DateTimeFormat` in terms of locale handling.

Ultimately, the choice of method will depend on the specific context, balancing performance, readability, and functionality based on the needs of the project.

Related benchmarks:

string.split vs string.substring vs toLocaleDateString("pt-PT") vs Intl.DateTimeateTimeFormat (version: 1)

Created: one month ago by: Guest

Jump to the latest result

split

Date toLocaleString without date being cached

slice

substring

Intl no format cache no date cache

Intl no format cache with date cache

Intl with format cache no date cache

Intl with format cache with date cache

Date toLocaleString with date being cached

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):