Benchmark: lodash isEqual vs redux shallowEqual test 2

HTML Preparation code:

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

Script Preparation code:

function equal(a, b) {
  if (a === b) return true;

  if (a && b && typeof a == 'object' && typeof b == 'object') {
    if (a.constructor !== b.constructor) return false;

    var length, i, keys;
    if (Array.isArray(a)) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (!equal(a[i], b[i])) return false;
      return true;
    }



    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();

    keys = Object.keys(a);
    length = keys.length;
    if (length !== Object.keys(b).length) return false;

    for (i = length; i-- !== 0;)
      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

    for (i = length; i-- !== 0;) {
      var key = keys[i];

      if (!equal(a[key], b[key])) return false;
    }

    return true;
  }

  // true if both NaN, false otherwise
  return a!==a && b!==b;
};

function is(x, y) {
  if (x === y) {
    return x !== 0 || y !== 0 || 1 / x === 1 / y
  } else {
    return x !== x && y !== y
  }
}

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

  for (let i = 0; i < keysA.length; i++) {
    if (
      !Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
      !is(objA[keysA[i]], objB[keysA[i]])
    ) {
      return false
    }
  }

  return true
}

// 1 level deep
var data = [
                    {
                        description: 'equal numbers',
                        value1: 1,
                        value2: 1,
                    },
                    {
                        description: 'not equal numbers',
                        value1: 1,
                        value2: 2,
                    },
               		{
                        description: 'equal strings',
                        value1: 'a',
                        value2: 'a',
                    },
                    {
                        description: 'simple array, same numeric array',
                        value1: [1,2,3,4],
                        value2: [1,2,3,4],
                    },
  					{
                        description: 'simple array, same string array',
                        value1: ['happy', 'birthday', 'to', 'you'],
                        value2: ['happy', 'birthday', 'to', 'you'],
                    },
  					{
                        description: 'different string array',
                        value1: ['happy', 'birthday', 'to', 'you', 'Taylor'],
                        value2: ['happy', 'birthday', 'to', 'you'],
                    },
                    {
                        description: 'array, same deep values',
                        value1: [[0],{x: 1},[3]],
                        value2: [[0],{x: 1},[3]],
                    },
                    {
                        description: 'big object',
                        value1: {
                            prop1: 'value1',
                            prop2: 'value2',
                            prop3: 'value3',
                            prop4: {
                                subProp1: 'sub value1',
                                subProp2: {
                                    subSubProp1: 'sub sub value1',
                                    subSubProp2: [
                                        1,
                                        2,
                                        { prop2: 1, prop: 2 },
                                        4,
                                        5,
                                    ],
                                },
                            },
                            prop5: 1000,
                            prop6: new Date(2016, 2, 10),
                        },
                        value2: {
                            prop5: 1000,
                            prop3: 'value3',
                            prop1: 'value1',
                            prop2: 'value2',
                            prop6: new Date('2016/03/10'),
                            prop4: {
                                subProp2: {
                                    subSubProp1: 'sub sub value1',
                                    subSubProp2: [
                                        1,
                                        2,
                                        { prop2: 1, prop: 2 },
                                        4,
                                        5,
                                    ],
                                },
                                subProp1: 'sub value1',
                            },
                        },
                        equal: true,
                    },
                ];

Tests:

lodash0
_.isEqual(data[0].value1, data[0].value2)
shallowEqual0
shallowEqual(data[0].value1, data[0].value2)
lodash1
_.isEqual(data[1].value1, data[1].value2)
shallowEqual1
shallowEqual(data[1].value1, data[1].value2)
lodash2
_.isEqual(data[2].value1, data[2].value2)
shallowEqual2
shallowEqual(data[2].value1, data[2].value2)
lodash3
_.isEqual(data[3].value1, data[3].value2)
shallowEqual3
shallowEqual(data[3].value1, data[3].value2)
lodash4
_.isEqual(data[4].value1, data[4].value2)
shallowEqual4
shallowEqual(data[4].value1, data[4].value2)
lodash5
_.isEqual(data[5].value1, data[5].value2)
shallowEqual5
shallowEqual(data[5].value1, data[5].value2)
lodash6
_.isEqual(data[6].value1, data[6].value2)
shallowEqual6
shallowEqual(data[6].value1, data[6].value2)
lodash7
_.isEqual(data[7].value1, data[7].value2)
shallowEqual7
shallowEqual(data[7].value1, data[7].value2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash0
shallowEqual0
lodash1
shallowEqual1
lodash2
shallowEqual2
lodash3
shallowEqual3
lodash4
shallowEqual4
lodash5
shallowEqual5
lodash6
shallowEqual6
lodash7
shallowEqual7

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash0	7992682.5 Ops/sec
shallowEqual0	8090894.0 Ops/sec
lodash1	7964878.0 Ops/sec
shallowEqual1	8060506.5 Ops/sec
lodash2	8027416.5 Ops/sec
shallowEqual2	7950084.5 Ops/sec
lodash3	4863613.0 Ops/sec
shallowEqual3	1358100.1 Ops/sec
lodash4	5069608.0 Ops/sec
shallowEqual4	1377755.9 Ops/sec
lodash5	7403866.5 Ops/sec
shallowEqual5	3088552.8 Ops/sec
lodash6	1699515.1 Ops/sec
shallowEqual6	2431900.2 Ops/sec
lodash7	581059.6 Ops/sec
shallowEqual7	1367601.0 Ops/sec

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

LLMs can make mistakes. Check important info.

It looks like you're sharing some logs or data from a testing environment, likely related to JavaScript execution speeds on different browsers and platforms.

If I had to summarize the data for you:

**Overview:**

The data consists of 11 entries, each representing a single test run with different characteristics (e.g., browser version, device platform, operating system). Each entry includes various metrics like executions per second, test name, and raw UA string.

**Key Observations:**

1. The majority of tests were executed on Chrome 126, which is a relatively recent version.
2. Most devices used are desktop platforms, with the Mac OS X operating system being the most common.
3. Test names suggest that these tests are related to testing JavaScript functions or libraries (e.g., "lodash4", "shallowEqual5").

**Questions:**

To help me better understand this data, could you please provide more context about what kind of tests were run and what metrics were recorded? Are there any specific goals or hypotheses behind this testing environment?

If I had to make an educated guess based on the provided data:

The tests appear to be focused on measuring JavaScript execution speeds across different browsers and devices. The high number of tests suggests that the testing environment is designed to cover a wide range of scenarios, potentially for optimization or benchmarking purposes.

Would you like me to dig deeper into any specific aspect of this data?

Related benchmarks:

lodash isEqual vs redux shallowEqual test 2 (version: 0)

Comparing performance of: lodash0 vs shallowEqual0 vs lodash1 vs shallowEqual1 vs lodash2 vs shallowEqual2 vs lodash3 vs shallowEqual3 vs lodash4 vs shallowEqual4 vs lodash5 vs shallowEqual5 vs lodash6 vs shallowEqual6 vs lodash7 vs shallowEqual7

Created: 3 years ago by: Guest

Jump to the latest result

lodash0

shallowEqual0

lodash1

shallowEqual1

lodash2

shallowEqual2

lodash3

shallowEqual3

lodash4

shallowEqual4

lodash5

shallowEqual5

lodash6

shallowEqual6

lodash7

shallowEqual7

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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