Benchmark: toISOString and literalISO 3

Script Preparation code:


function toISOString() {
  	const date = new Date();
	return date.toISOString();
}

function toISOStringLiteral() {
 const date = new Date();

  const d = date.getUTCDate();
  const m = date.getUTCMonth() + 1;
  const y = date.getUTCFullYear();
  const hh = date.getUTCHours();
  const mm = date.getUTCMinutes();
  const ss = date.getUTCSeconds();
  const mss = date.getUTCMilliseconds();

  const ds = d <= 9 ? `0${d}` : `${d}`;
  const ms = m <= 9 ? `0${m}` : `${m}`;

  const hhs = hh <= 9 ? `0${hh}` : `${hh}`;
  const mms = mm <= 9 ? `0${mm}` : `${mm}`;
  const sss = ss <= 9 ? `0${ss}` : `${ss}`;
  let msss = mss <= 9 ? `0${mss}` : `${mss}`;
  msss = mss <= 99 ? `0${msss}` : msss;

  return `${y}-${ms}-${ds}T${hhs}:${mms}:${sss}.${msss}Z`;
};

function concat() {
   	const date = new Date();
 	var d = date.getUTCDate();
	var m = date.getUTCMonth() + 1;
	var y = date.getUTCFullYear();
  	var hh = date.getUTCHours();
 	var mm = date.getUTCMinutes();
  	var ss = date.getUTCSeconds();
  	var ms = date.getUTCMilliseconds();
  	var day = d <= 9 ? '0' + d : '' + d;
    var month = m <= 9 ? '0' + m : '' + m;
    var year = '' + y;
  
  	hh = hh <= 9 ? '0' + hh : '' + hh;
    mm = mm <= 9 ? '0' + mm : '' + mm;
    ss = ss <= 9 ? '0' + ss : '' + ss;
    ms = ms <= 9 ? '0' + ms : '' + ms;
    ms = ms <= 99 ? '0' + ms : '' + ms;
  
	return year + '-' + month + '-' + day + 'T' + hh + ':' + mm + ':' + ss + '.' + ms + 'Z';
}

Tests:

toISOString
for (var i=0; i<1000; ++i) { toISOString(); }
concat
for (var i=0; i<1000; ++i) { concat(); }
toISOStringLiteral
for (var i=0; i<1000; ++i) { toISOStringLiteral(); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toISOString
concat
toISOStringLiteral

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.

I'll break down the provided benchmark definition and test cases to explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmarking framework called MeasureThat.net. The benchmark definition is a set of three functions: `toISOString`, `concat`, and `toISOStringLiteral`. Each function performs a specific task:

1.  `toISOString`: Creates an ISO date string using the `Date` object's `toISOString()` method.
2.  `concat`: Manually constructs an ISO date string by extracting individual components from the `Date` object and concatenating them manually.

The benchmark definition is a simple "for" loop that executes each function 1000 times, allowing users to compare the performance of these different approaches.

**Comparison**

The three functions are compared in terms of their execution speed. The benchmark result shows the number of executions per second for each function on a specific device and browser configuration (Chrome 90 on Mac OS X 10.15.7).

| Test Case | Executions Per Second |
| --- | --- |
| `toISOStringLiteral` | 1782.7298583984375 |
| `concat` | 1768.691650390625 |
| `toISOString` | 1237.7230224609375 |

**Pros and Cons**

Here's a brief analysis of the pros and cons of each approach:

*   **`toISOStringLiteral`:**
    *   Pros:
        *   Manual concatenation can be seen as a "native" or "built-in" way to construct ISO date strings, which might lead to better performance.
        *   The generated string has a consistent format (YYYY-MM-DDTHH:MM:SS.SSSZ), which is often preferred in software development.
    *   Cons:
        *   Manual concatenation can be error-prone and less readable than using built-in methods.

*   **`concat`:**
    *   Pros:
        *   Manually constructed strings can be more readable, especially for developers who are familiar with the individual components of ISO date strings.
        *   Less memory-intensive due to not creating a single string object.
    *   Cons:
        *   Manual concatenation is less efficient and might lead to performance issues in high-performance applications.

*   **`toISOString`:**
    *   Pros:
        *   Built-in method, which often results in better performance.
    *   Cons:
        *   Less readable and not as flexible as manually constructed strings.

**Library and Special JS Features**

There are no specific libraries mentioned in the benchmark definition. However, it's worth noting that `toISOString()` is a built-in method provided by JavaScript's Date object, which simplifies date string formatting without requiring manual concatenation or manipulation of individual components.

No special JavaScript features (e.g., async/await, decorators) are used in this benchmark.

**Alternatives**

Some alternatives to these approaches include:

*   Using third-party libraries for date string formatting, such as Moment.js or Luxon.
*   Implementing custom date parsing and formatting logic using regular expressions or template literals.
*   Utilizing browser-specific APIs, like the Date Intl API, which provides more advanced date manipulation capabilities.

Keep in mind that these alternatives may introduce additional dependencies, complexity, or performance overhead compared to the simple approaches presented in this benchmark.

Related benchmarks:

toISOString and literalISO 3 (version: 0)

Comparing performance of: toISOString vs concat vs toISOStringLiteral

Created: 4 years ago by: Guest

Jump to the latest result

toISOString

concat

toISOStringLiteral

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):