Benchmark: react shallowEqual vs ramda

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

AخA
 
<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

Script Preparation code:

function is(x, y) {
  return (
    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
  );
}

const hasOwnProperty = Object.prototype.hasOwnProperty;

function shallowEqual(objA, objB) {
    if (is(objA, objB)) {
        return true;
    }

    if (
        typeof objA !== 'object' ||
        objA === null ||
        typeof objB !== 'object' ||
        objB === null
    ) {
        return false;
    }

    const keysA = Object.keys(objA);
    const keysB = Object.keys(objB);

    if (keysA.length !== keysB.length) {
        return false;
    }

    // Test for A's keys different from B.
    for (let i = 0; i < keysA.length; i++) {
        const currentKey = keysA[i];
        if (
            !hasOwnProperty.call(objB, currentKey) ||
            !is(objA[currentKey], objB[currentKey])
        ) {
            return false;
        }
    }

    return true;
}

var data = [{
    foo: {
        bar: {
            foo: {
                bar: ''
            }
        }
    }
}, {}, {}];

​x
 
function is(x, y) {  return (    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare  );}​const hasOwnProperty = Object.prototype.hasOwnProperty;​function shallowEqual(objA, objB) {    if (is(objA, objB)) {        return true;    }​    if (        typeof objA !== 'object' ||        objA === null ||        typeof objB !== 'object' ||        objB === null    ) {        return false;    }​    const keysA = Object.keys(objA);    const keysB = Object.keys(objB);​    if (keysA.length !== keysB.length) {        return false;    }​    // Test for A's keys different from B.    for (let i = 0; i < keysA.length; i++) {        const currentKey = keysA[i];        if (            !hasOwnProperty.call(objB, currentKey) ||            !is(objA[currentKey], objB[currentKey])        ) {            return false;        }    }​    return true;}​var data = [{    foo: {        bar: {            foo: {                bar: ''            }        }    }}, {}, {}];

Tests:

Ramda
var result = R.equals(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);
var result = R.equals(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);
shallowEqual
var result = shallowEqual(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);
var result = shallowEqual(data, [{foo: {bar: {foo: {bar: ''}}}}, {}, {}]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Ramda
shallowEqual

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36

Browser/OS: Chrome 123 on Linux

View result in a separate tab

Test name	Executions per second
Ramda	190091.5 Ops/sec
shallowEqual	1477757.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 4 months ago):

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

Benchmark Definition

The benchmark measures the performance of two JavaScript functions: shallowEqual (custom implementation) and Ramda's equals function. Both functions compare two objects for shallow equality.

What is tested?

shallowEqual: a custom JavaScript function implemented by the test user, which checks if two objects are equal by comparing their keys and values.
Ramda's equals: a functional programming library function that compares two values for equality.

Options compared

The benchmark compares the performance of the following options:

Custom implementation (shallowEqual): The test user's custom JavaScript function, which manually checks if two objects have the same keys and values.
Ramda's equals: A widely-used functional programming library function that compares two values for equality.

Pros and Cons

Custom implementation (shallowEqual):
- Pros:
  - Can be optimized for specific use cases or data structures.
  - May be more efficient for certain types of data.
- Cons:
  - Requires manual implementation, which can be error-prone and time-consuming.
  - May not handle edge cases or complex data structures well.
Ramda's equals:
- Pros:
  - Well-tested and widely used, with a large community of developers who contribute to its development.
  - Handles many common use cases and edge cases out-of-the-box.
- Cons:
  - May have performance overhead due to its functional programming nature.
  - Requires additional dependencies (Ramda library).

Library: Ramda

Ramda is a popular JavaScript functional programming library that provides a wide range of functions for working with data. The equals function is one of its most commonly used functions, and it's designed to compare two values for equality.

Special JS feature or syntax: None

This benchmark does not use any special JavaScript features or syntax, such as ES6 classes, async/await, or Promises.

Other alternatives

If you're looking for alternative libraries or implementations for shallow equality checks, some options include:

Lodash's isEqual function
jQuery's .deepEqual method ( deprecated in favor of Lodash's implementation)
A custom implementation using the JSON.stringify() and JSON.parse() methods.

Keep in mind that the best approach depends on your specific use case and requirements. If you need a lightweight, high-performance solution for shallow equality checks, Ramda's equals function may be a good choice. However, if you require more advanced features or customization options, a custom implementation or another library like Lodash may be a better fit.

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance of two JavaScript functions: `shallowEqual` (custom implementation) and Ramda's `equals` function. Both functions compare two objects for shallow equality.

**What is tested?**

* `shallowEqual`: a custom JavaScript function implemented by the test user, which checks if two objects are equal by comparing their keys and values.
* Ramda's `equals`: a functional programming library function that compares two values for equality.

**Options compared**

The benchmark compares the performance of the following options:

1. **Custom implementation (shallowEqual)**: The test user's custom JavaScript function, which manually checks if two objects have the same keys and values.
2. **Ramda's `equals`**: A widely-used functional programming library function that compares two values for equality.

**Pros and Cons**

* **Custom implementation (shallowEqual)**:
	+ Pros:
		- Can be optimized for specific use cases or data structures.
		- May be more efficient for certain types of data.
	+ Cons:
		- Requires manual implementation, which can be error-prone and time-consuming.
		- May not handle edge cases or complex data structures well.
* **Ramda's `equals`**:
	+ Pros:
		- Well-tested and widely used, with a large community of developers who contribute to its development.
		- Handles many common use cases and edge cases out-of-the-box.
	+ Cons:
		- May have performance overhead due to its functional programming nature.
		- Requires additional dependencies (Ramda library).

**Library: Ramda**

Ramda is a popular JavaScript functional programming library that provides a wide range of functions for working with data. The `equals` function is one of its most commonly used functions, and it's designed to compare two values for equality.

**Special JS feature or syntax: None**

This benchmark does not use any special JavaScript features or syntax, such as ES6 classes, async/await, or Promises.

**Other alternatives**

If you're looking for alternative libraries or implementations for shallow equality checks, some options include:

* Lodash's `isEqual` function
* jQuery's `.deepEqual` method ( deprecated in favor of Lodash's implementation)
* A custom implementation using the `JSON.stringify()` and `JSON.parse()` methods.

Keep in mind that the best approach depends on your specific use case and requirements. If you need a lightweight, high-performance solution for shallow equality checks, Ramda's `equals` function may be a good choice. However, if you require more advanced features or customization options, a custom implementation or another library like Lodash may be a better fit.

Related benchmarks:

react shallowEqual vs ramda (version: 0)

Comparing performance of: Ramda vs shallowEqual

Created: 2 years ago by: Guest

Jump to the latest result

Ramda

shallowEqual

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 4 months ago):