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

ⓘ Get performance results from real users on your website with Request Metrics.

Website Performance Monitoring by Request Metrics

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

Browser/OS: Chrome 112 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash0	7714223.0 Ops/sec
shallowEqual0	7708237.0 Ops/sec
lodash1	7696003.0 Ops/sec
shallowEqual1	7701057.0 Ops/sec
lodash2	7584654.0 Ops/sec
shallowEqual2	7014766.0 Ops/sec
lodash3	3726215.0 Ops/sec
shallowEqual3	1249029.0 Ops/sec
lodash4	3960223.0 Ops/sec
shallowEqual4	1275505.0 Ops/sec
lodash5	6601690.0 Ops/sec
shallowEqual5	2912385.0 Ops/sec
lodash6	1387414.0 Ops/sec
shallowEqual6	2305369.0 Ops/sec
lodash7	523649.5 Ops/sec
shallowEqual7	1337958.0 Ops/sec

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: one year 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>

Experimental features:

Fastest: N/A

Slowest: N/A