Benchmark: Compare dates without time 2

Script Preparation code:

window.dt1 = new Date();
window.dt2 = new Date();
dt2.setHours(dt2.getHours()+1);

window.compareLocal = function compareLocal(v1, v2) {
  const d1 = v1.getFullYear() * 1000 + v1.getMonth() * 32 + v1.getDate();
  const d2 = v2.getFullYear() * 1000 + v2.getMonth() * 32 + v2.getDate();

  if (d1 > d2) return 1;
  if (d1 < d2) return -1;
  return 0;
}

window.compareUTC = function compareUTC(v1, v2) {
  const d1 = v1.getUTCFullYear() * 1000 + v1.getUTCMonth() * 32 + v1.getUTCDate();
  const d2 = v2.getUTCFullYear() * 1000 + v2.getUTCMonth() * 32 + v2.getUTCDate();
  
  if (d1 > d2) return 1;
  if (d1 < d2) return -1;
  return 0;
}

window.compareLocal2 = function compareLocal2(v1, v2) {
  let d1 = v1.getFullYear();
  let d2 = v2.getFullYear();
  if (d1 > d2) return 1;
  if (d1 < d2) return -1;

  d1 = v1.getMonth();
  d2 = v2.getMonth();
  if (d1 > d2) return 1;
  if (d1 < d2) return -1;

  d1 = v1.getDate();
  d2 = v2.getDate();
  if (d1 > d2) return 1;
  if (d1 < d2) return -1;

  return 0;
}

function compareLocal3(v1, v2) {
  const d1 = new Date(v1).setHours(0, 0, 0, 0);
  const d2 = new Date(v2).setHours(0, 0, 0, 0);
  if (d1 > d2) return 1;
  if (d1 < d2) return -1;

  return 0;
}

Tests:

compareLocal
const result = compareLocal(dt1, dt2);
compareUTC
const result2 = compareUTC(dt1, dt2);
compareLocal2
const result3 = compareLocal2(dt1, dt2);
compareLocal3
const result4 = compareLocal3(dt1, dt2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
compareLocal
compareUTC
compareLocal2
compareLocal3

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and test cases to explain what is being tested, compared, and the pros and cons of different approaches.

**Benchmark Definition**

The benchmark measures how fast JavaScript can compare two dates using different methods. There are four comparison functions:

1. `compareLocal`: Compares two local dates (without time zone information) using a custom algorithm.
2. `compareUTC`: Compares two UTC (Coordinated Universal Time) dates using the built-in `Date` object's `getUTCFullYear`, `getUTCMonth`, and `getUTCDate` methods.
3. `compareLocal2`: A simplified version of `compareLocal`, which only compares the year, month, and day of the dates.
4. `compareLocal3`: Uses the `Date` constructor to create a new date object with a specific hour, minute, second, and millisecond, then compares it with the original date.

**Comparison Functions**

Each comparison function uses a different approach:

1. `compareLocal` and `compareLocal2` use custom algorithms to extract year, month, and day values from the dates.
	* Pros: Customizable and efficient for specific use cases.
	* Cons: May not be accurate or efficient for all date formats or edge cases.
2. `compareUTC`: Uses built-in methods of the `Date` object.
	* Pros: Accurate and efficient for comparing UTC dates.
	* Cons: May not work correctly with local dates or dates without time zone information.
3. `compareLocal3`: Creates a new `Date` object with a specific hour, minute, second, and millisecond, then compares it with the original date.
	* Pros: Simplifies the comparison process by creating a new date object.
	* Cons: May not be accurate or efficient for all edge cases.

**Libraries and Features**

None of the comparison functions rely on external libraries. However, the `Date` object is used in all four functions, which is a built-in JavaScript library.

No special JS features or syntax are used in these benchmark tests.

**Alternatives**

Other alternatives to compare dates could include:

1. Using the `Date.compare()` method (not supported in older browsers).
2. Implementing a custom comparison function using arithmetic operations.
3. Using a third-party library like Moment.js for date manipulation and comparison.
4. Comparing dates as strings, which can be prone to errors due to cultural differences in date formatting.

Overall, the benchmark tests provide insight into the performance differences between various approaches to comparing dates in JavaScript.

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/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Windows

View result in a separate tab

Test name	Executions per second
compareLocal	2596007.5 Ops/sec
compareUTC	2149272.2 Ops/sec
compareLocal2	2535505.2 Ops/sec
compareLocal3	1139383.8 Ops/sec

Related benchmarks:

Compare dates without time 2 (version: 1)

Comparing performance of: compareLocal vs compareUTC vs compareLocal2 vs compareLocal3

Created: one year ago by: Registered User

Jump to the latest result

compareLocal

compareUTC

compareLocal2

compareLocal3

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