Benchmark: comparing arrays with lodash and not

HTML Preparation code:

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

Script Preparation code:

var a=[];
var b=[];

for (var i = 0; i < 1024; i++) {
  a[i] = i;
  b[i] = i;
}


// ###############################################
// # https://stackoverflow.com/a/16436975/2601293
// ###############################################
function arraysEqual(a, b) {
  if (a === b) return true;
  if (a == null || b == null) return false;
  if (a.length != b.length) return false;

  // If you don't care about the order of the elements inside
  // the array, you should sort both arrays here.
  // Please note that calling sort on an array will modify that array.
  // you might want to clone your array first.

  for (var i = 0; i < a.length; ++i) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}


// ###############################################
// # https://stackoverflow.com/a/10316616/2601293 (Option 1)
// ###############################################
function arraysEqual(a1,a2) {
    /* WARNING: arrays must not contain {objects} or behavior may be undefined */
    return JSON.stringify(a1)==JSON.stringify(a2);
}

// #########################################################
// # https://stackoverflow.com/a/10316616/2601293 (Option 2)
// #########################################################
// generally useful functions
function type(x) { // does not work in general, but works on JSONable objects we care about... modify as you see fit
    // e.g.  type(/asdf/g) --> "[object RegExp]"
    return Object.prototype.toString.call(x);
}
function zip(arrays) {
    // e.g. zip([[1,2,3],[4,5,6]]) --> [[1,4],[2,5],[3,6]]
    return arrays[0].map(function(_,i){
        return arrays.map(function(array){return array[i]})
    });
}
// helper functions
function allCompareEqual(array) {
    // e.g.  allCompareEqual([2,2,2,2]) --> true
    // does not work with nested arrays or objects
    return array.every(function(x){return x==array[0]});
}

function isArray(x){ return type(x)==type([]) }
function getLength(x){ return x.length }
function allTrue(array){ return array.reduce(function(a,b){return a&&b},true) }
function allDeepEqual(things) {
    // works with nested arrays
    if( things.every(isArray) )
        return allCompareEqual(things.map(getLength))     // all arrays of same length
               && allTrue(zip(things).map(allDeepEqual)); // elements recursively equal
    //else if( this.every(isObject) )
    //  return {all have exactly same keys, and for 
    //          each key k, allDeepEqual([o1[k],o2[k],...])}
    //  e.g. ... && allTrue(objectZip(objects).map(allDeepEqual)) 

    //else if( ... )
    //  extend some more
    else
        return allCompareEqual(things);
}
function allDeepEqual2() {
    return allDeepEqual([].slice.call(arguments));
}

// #########################################################
// # https://stackoverflow.com/a/10316616/2601293 (Option 3)
// #########################################################
function optionThree(a,b) {
    /*
        Array-aware equality checker:
        Returns whether arguments a and b are == to each other;
        however if they are equal-lengthed arrays, returns whether their 
        elements are pairwise == to each other recursively under this
        definition.
    */
    if (a instanceof Array && b instanceof Array) {
        if (a.length!=b.length)  // assert same length
            return false;
        for(var i=0; i<a.length; i++)  // assert each element equal
            if (!arraysEqual(a[i],b[i]))
                return false;
        return true;
    } else {
        return a==b;  // if not both arrays, should be the same
    }
}


// #########################################################
// # https://stackoverflow.com/a/10316616/2601293 (Option 4)
// #########################################################
function deepEquals(a,b) {
    if (a instanceof Array && b instanceof Array)
        return arraysEqual(a,b);
    if (Object.getPrototypeOf(a)===Object.prototype && Object.getPrototypeOf(b)===Object.prototype)
        return objectsEqual(a,b);
    if (a instanceof Map && b instanceof Map)
        return mapsEqual(a,b);        
    if (a instanceof Set && b instanceof Set)
        throw "Error: set equality by hashing not implemented."
    if ((a instanceof ArrayBuffer || ArrayBuffer.isView(a)) && (b instanceof ArrayBuffer || ArrayBuffer.isView(b)))
        return typedArraysEqual(a,b);
    return a==b;  // see note[1] -- IMPORTANT
}

function arraysEqual(a,b) {
    if (a.length!=b.length)
        return false;
    for(var i=0; i<a.length; i++)
        if (!deepEquals(a[i],b[i]))
            return false;
    return true;
}
function objectsEqual(a,b) {
    var aKeys = Object.getOwnPropertyNames(a);
    var bKeys = Object.getOwnPropertyNames(b);
    if (aKeys.length!=bKeys.length)
        return false;
    aKeys.sort();
    bKeys.sort();
    for(var i=0; i<aKeys.length; i++)
        if (aKeys[i]!=bKeys[i]) // keys must be strings
            return false;
    return deepEquals(aKeys.map(k=>a[k]), aKeys.map(k=>b[k]));
}
function mapsEqual(a,b) {
    if (a.size!=b.size)
        return false;
    var aPairs = Array.from(a);
    var bPairs = Array.from(b);
    aPairs.sort((x,y) => x[0]<y[0]);
    bPairs.sort((x,y) => x[0]<y[0]);
    for(var i=0; i<a.length; i++)
        if (!deepEquals(aPairs[i][0],bPairs[i][0]) || !deepEquals(aPairs[i][1],bPairs[i][1]))
            return false;
    return true;
}
function typedArraysEqual(a,b) {
    a = new Uint8Array(a);
    b = new Uint8Array(b);
    if (a.length != b.length)
        return false;
    for(var i=0; i<a.length; i++)
        if (a[i]!=b[i])
            return false;
    return true;
}

Tests:

lodash isEqual
_.isEqual(a, b)
arraysEqual
arraysEqual(a, b)
JSON.stringify (WONT WORK WITH OBJECTS)
arraysEqual(a, b)
Option 2
allDeepEqual2(a, b)
option 3
optionThree(a,b)
Option 4
deepEquals(a,b)

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

lodash isEqual

420K/s

option 3

28K/s

Option 2

3K/s

Option 4

2K/s

JSON.stringify (WONT WORK WITH OBJECTS)

2K/s

arraysEqual

2K/s

Fastest: lodash isEqual (192.8x faster)

View exact numbers

✓ lodash isEqual: 419,972 ops/sec
• option 3: 27,865 ops/sec
• Option 2: 3,330 ops/sec
• Option 4: 2,188 ops/sec
• JSON.stringify (WONT WORK WITH OBJECTS): 2,183 ops/sec
• arraysEqual: 2,179 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash isEqual
arraysEqual
JSON.stringify (WONT WORK WITH OBJECTS)
Option 2
option 3
Option 4

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Windows

View result in a separate tab

lodash isEqual

412K/s

option 3

20K/s

Option 2

2K/s

Option 4

2K/s

arraysEqual

2K/s

JSON.stringify (WONT WORK WITH OBJECTS)

2K/s

View exact numbers

Test name	Executions per second
✓ lodash isEqual	412,450 Ops/sec
option 3	19,776 Ops/sec
Option 2	2,492 Ops/sec
Option 4	1,673 Ops/sec
arraysEqual	1,638 Ops/sec
JSON.stringify (WONT WORK WITH OBJECTS)	1,620 Ops/sec

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

LLMs can make mistakes. Check important info.

It appears that you have provided a benchmark test result in a JSON format, which includes the following information:

1. Benchmark definition and name for each test case
2. Raw UA string (User Agent) and browser version for each test case
3. Device platform, operating system, executions per second, and test name for each test case

To answer your question, I'll need to analyze this data to provide a response.

From the provided benchmark result, it's clear that:

* `arraysEqual` and `option 3` have similar performance (ExecutionsPerSecond) when comparing arrays
* `lodash isEqual`, `Option 2`, and `deepEquals` have different performance (ExecutionsPerSecond)
* `JSON.stringify (WONT WORK WITH OBJECTS)` has the lowest executions per second compared to other tests

However, without more context or information about what these benchmarks are measuring, it's difficult to provide a definitive answer.

If you'd like to ask a specific question related to this benchmark result, I'll do my best to help!

comparing arrays with lodash and not (version: 0) Benchmark.js

Comparing performance of: `lodash isEqual vs arraysEqual vs JSON.stringify (WONT WORK WITH OBJECTS) vs Option 2 vs option 3 vs Option 4`

Created: 6 years ago by: Registered User

Go to the latest result

lodash isEqual

arraysEqual

JSON.stringify (WONT WORK WITH OBJECTS)

Option 2

option 3

Option 4

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

comparing arrays with lodash and not (version: 0) Benchmark.js

Comparing performance of: lodash isEqual vs arraysEqual vs JSON.stringify (WONT WORK WITH OBJECTS) vs Option 2 vs option 3 vs Option 4

Created: 6 years ago by: Registered User

Go to the latest result

lodash isEqual

arraysEqual

JSON.stringify (WONT WORK WITH OBJECTS)

Option 2

option 3

Option 4

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

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: `lodash isEqual vs arraysEqual vs JSON.stringify (WONT WORK WITH OBJECTS) vs Option 2 vs option 3 vs Option 4`