Benchmark: Custom Array Equality Function vs Lodash.isEqualWith Equality Comparison for Shallow Array of Strings.

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>

Script Preparation code:

window.foo = ['cat', 'dog', 'bird'];
window.bar = ['cat', 'dog', 'bird'];

function arraysAreEqual(
    firstArray,
    secondArray,
    options,
) {
    if (firstArray.length !== secondArray.length) {
        return false;
    }

    const {
        comparator,
        orderSensitive = true
    } = options;

    const first = orderSensitive ? firstArray : [...firstArray.sort()];
    const second = orderSensitive ? secondArray : [...secondArray.sort()];

    return first.every((firstItem, index) => {
        const secondItem = second[index];
        if (comparator != null) {
            return comparator(firstItem, secondItem);
        }
        return firstItem === secondItem;
    });
}

Tests:

Arrays are equal
arraysAreEqual(window.foo, window.bar, {comparator: (a, b) => a===b, orderSensitive: false})
_.isEqualWith
_.isEqualWith(window.foo, window.bar, (a, b) => a===b)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Arrays are equal
_.isEqualWith

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

_.isEqualWith

5.1M/s

Arrays are equal

3.2M/s

View exact numbers

Test name	Executions per second
✓ _.isEqualWith	5,066,832 Ops/sec
Arrays are equal	3,168,949 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark and its results.

**Benchmark Overview**

The benchmark measures the performance of two different approaches for comparing arrays: `arraysAreEqual` (a custom implementation) and `_.isEqualWith` from the Lodash library. The test compares the equality of two shallow arrays of strings (`window.foo` and `window.bar`) using different comparison options.

**Comparison Options**

There are two main options being compared:

1. **Arrays are equal**: This option uses the default behavior of both `arraysAreEqual` and `_.isEqualWith`, which checks for reference equality, i.e., whether the arrays have the same underlying memory location.
2. **_.isEqualWith**: This option uses a custom comparator function provided by Lodash to compare the elements of the arrays. The comparator function is specified as `(a, b) => a === b`, which simply checks if both elements are equal using strict equality (`===`).

**Pros and Cons**

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

1. **Arrays are equal (default behavior)**:
	* Pros: Simple and straightforward to implement.
	* Cons: Can be slower due to reference comparison, which checks for memory location instead of actual value equality.
2. **_.isEqualWith**:
	* Pros: Can be faster since it uses a custom comparator function that only checks for value equality.
	* Cons: Requires Lodash library and can be more complex to implement.

**Library - Lodash**

Lodash is a popular JavaScript utility library that provides various functions for tasks such as array manipulation, object transformation, and functional programming. In this benchmark, `_.isEqualWith` is used to compare the arrays using a custom comparator function.

**Special JS Feature/Syntax - None**

There are no special JavaScript features or syntaxes being used in this benchmark beyond the standard language.

**Other Alternatives**

If you were to reimplement this benchmark without using Lodash, you could consider using other libraries or implementing your own comparator function. Some alternatives include:

* Using `Array.prototype.every()` and a custom callback function.
* Implementing a custom comparator function similar to the one used in `_.isEqualWith`.
* Utilizing a library like Jest or Mocha for benchmarking.

Keep in mind that the choice of alternative will depend on your specific requirements and preferences.

Custom Array Equality Function vs Lodash.isEqualWith Equality Comparison for Shallow Array of Strings. (version: 0) Benchmark.js

Test on isEqualWith performance

Comparing performance of: `Arrays are equal vs _.isEqualWith`

Created: 2 years ago by: Guest

Go to the latest result

Arrays are equal

_.isEqualWith

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Custom Array Equality Function vs Lodash.isEqualWith Equality Comparison for Shallow Array of Strings. (version: 0) Benchmark.js

Test on isEqualWith performance

Comparing performance of: Arrays are equal vs _.isEqualWith

Created: 2 years ago by: Guest

Go to the latest result

Arrays are equal

_.isEqualWith

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Related benchmarks

Comparing performance of: `Arrays are equal vs _.isEqualWith`