Benchmark: Manually adding month to YYYY-MM formatted date VS dayjs .add(n, "months")

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/dayjs/1.10.7/dayjs.min.js'></script>

Script Preparation code:

function addDeltaMonthsToDateKeyCustom(date, delta) {
  const [year, month] = date.split("-");
  const monthInt = parseInt(month, 10);
  const yearInt = parseInt(year, 10);
  let newYear = yearInt;
  let newMonth = monthInt + delta;

  if (newMonth > 12 || newMonth <= 0) {
    const spilloverMonths = newMonth % 12;
    const spilloverYears = newMonth === 0 ? -1 : Math.floor(newMonth / 12);
    newMonth = newMonth > 0 ? spilloverMonths : 12 + spilloverMonths;
    newYear = yearInt + spilloverYears;
  }
  const updatedDate = `${newYear}-${newMonth.toString().padStart(2, "0")}`;

  return updatedDate;
}

function addDeltaMonthsToDateKeyDayJs(date, delta) {
  return dayjs(date, "YYYY-MM").add(delta, "months").format("YYYY-MM");
}

function randomIntFromInterval(min, max) { // min and max included 
  return Math.floor(Math.random() * (max - min + 1) + min)
}

var dates = [];
var deltas = [];
for(let i = 0; i < 100; i++) {
  const year = randomIntFromInterval(1990, 2150);
  const month = randomIntFromInterval(1, 12).toString().padStart(2);
  dates.push(`${year}-${month}`);
  deltas.push(randomIntFromInterval(-100, 100));
}

Tests:

Manual
const transformedDates = []; for(const [index, date] of dates.entries()) { transformedDates.push(addDeltaMonthsToDateKeyCustom(date, deltas[index])); }
Dayjs
const transformedDates = []; for(const [index, date] of dates.entries()) { transformedDates.push(addDeltaMonthsToDateKeyDayJs(date, deltas[index])); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Manual
Dayjs

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.

Let's break down the provided benchmark and explain what's being tested, compared, and discussed.

**Benchmark Overview**

The test measures how fast two approaches are for adding a specified number of months to a date string in YYYY-MM format. The two approaches are:

1. Manual (using custom JavaScript code)
2. Dayjs (a library that provides date manipulation functions)

**Manual Approach**

In the manual approach, the `addDeltaMonthsToDateKeyCustom` function is used to calculate the new month and year by parsing the input date string, adding the delta value, and handling edge cases. The function takes a date string (`date`) and a delta value (`delta`) as inputs.

The code uses an array of random dates and deltas generated using `randomIntFromInterval`. For each date, it applies the custom logic to calculate the new month and year, and then constructs a new date string in YYYY-MM format.

**Dayjs Approach**

In contrast, the Dayjs approach relies on the `dayjs` library to manipulate dates. The `addDeltaMonthsToDateKeyDayJs` function takes a date string (`date`) and a delta value (`delta`) as inputs. It uses `dayjs` to parse the input date string, add the specified number of months using the `add` method, and then formats the result in YYYY-MM format.

**Comparison**

The two approaches are compared in terms of performance, with the benchmarking process measuring how many executions per second each approach can handle. The test results show that the manual approach outperforms Dayjs for this specific task.

**Pros and Cons**

* **Manual Approach:**
	+ Pros:
		- No dependencies on external libraries
		- Can be optimized for performance with custom implementation
	+ Cons:
		- Requires manual handling of edge cases (e.g., month wraparound)
		- May have slower performance due to the custom logic
* **Dayjs Approach:**
	+ Pros:
		- Fast and efficient, thanks to the `dayjs` library's optimized date manipulation functions
		- Easier to maintain and extend, as it leverages a well-tested library
	+ Cons:
		- Dependent on external libraries (may introduce overhead or versioning issues)
		- Less control over performance optimization

**Library - Dayjs**

Dayjs is a lightweight JavaScript date library that provides efficient and easy-to-use functions for manipulating dates. It's designed to be fast, flexible, and extensible, making it a popular choice for many applications.

**Other Alternatives**

For this specific task, other alternatives to the manual approach could include:

1. Using a dedicated date arithmetic library (e.g., Moment.js)
2. Leveraging modern JavaScript features like `Date` manipulation functions (e.g., `Date.prototype.addMonths`)
3. Employing a just-in-time (JIT) compiler or a more specialized execution engine (e.g., WebAssembly)

Keep in mind that these alternatives may have their own trade-offs, and the choice of approach depends on the specific requirements and constraints of your project.

I hope this explanation helps clarify what's being tested and compared in the benchmark!

Related benchmarks:

Manually adding month to YYYY-MM formatted date VS dayjs .add(n, "months") (version: 0)

Comparing performance of: Manual vs Dayjs

Created: 4 years ago by: Registered User

Jump to the latest result

Manual

Dayjs

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