Wie kann man mit JavaScript prüfen, ob zwei Arrays gleich sind?

Question

var a = [1, 2, 3];
var b = [3, 2, 1];
var c = new Array(1, 2, 3);

alert(a == b + "|" + b == c);

Demo

Wie kann ich diese Arrays auf Gleichheit prüfen und eine Methode erhalten, die Folgendes zurückgibt true wenn sie gleich sind?

Bietet jQuery eine Methode dafür?

Answer 1

使用する map() y reduce() :

function arraysEqual (a1, a2) {
    return a1 === a2 || (
        a1 !== null && a2 !== null &&
        a1.length === a2.length &&
        a1
            .map(function (val, idx) { return val === a2[idx]; })
            .reduce(function (prev, cur) { return prev && cur; }, true)
    );
}

Answer 2

Wenn Sie Folgendes überprüfen möchten Arrays von Objekten für Gleichheit und die Reihenfolge spielt KEINE Rolle, d.h.

areEqual([{id: "0"}, {id: "1"}], [{id: "1"}, {id: "0"}]) // true

müssen Sie die Arrays zunächst sortieren. lodash hat alle Werkzeuge, die Sie brauchen, und kombiniert sortBy y isEqual :

// arr1 & arr2: Arrays of objects 
// sortProperty: the property of the object with which you want to sort
// Note: ensure every object in both arrays has your chosen sortProperty
// For example, arr1 = [{id: "v-test_id0"}, {id: "v-test_id1"}]
// and          arr2 = [{id: "v-test_id1"}, {id: "v-test_id0"}]
// sortProperty should be 'id'

function areEqual (arr1, arr2, sortProperty) {
  return _.areEqual(_.sortBy(arr1, sortProperty), _.sortBy(arr2, sortProperty))
}

EDIT: Da sortBy ein neues Array zurückgibt, müssen Sie Ihre Arrays vor dem Sortieren nicht klonen. Die ursprünglichen Arrays werden nicht verändert.

Beachten Sie, dass für lodash's isEqual , Ordnung ist wichtig . Das obige Beispiel liefert false wenn sortBy nicht zuerst auf jedes Array angewendet wird.

Answer 3

Diese Methode ist ätzend, aber ich habe sie hier als Referenz angegeben, damit andere diesen Weg vermeiden:

---

Die Option 1 von @ninjagecko hat bei mir am besten funktioniert:

Array.prototype.equals = function(array) {
    return array instanceof Array && JSON.stringify(this) === JSON.stringify(array) ;
}

a = [1, [2, 3]]
a.equals([[1, 2], 3]) // false
a.equals([1, [2, 3]]) // true

Es wird auch die null und undefiniert Fall behandeln, da wir dies auf den Prototyp von Array hinzufügen und überprüfen, dass das andere Argument auch ein Array ist.

Answer 4

Es gibt keine einfache Möglichkeit, dies zu tun. Ich brauchte dies auch, wollte aber eine Funktion, die zwei beliebige Variablen nehmen und auf Gleichheit testen kann. Das schließt Nicht-Objekt-Werte, Objekte, Arrays und jede Ebene der Verschachtelung ein.

In Ihrer Frage erwähnen Sie, dass Sie die Reihenfolge der Werte in einem Array ignorieren wollen. Meine Lösung tut das nicht von Haus aus, aber Sie können es erreichen, indem Sie die Arrays vor dem Vergleich auf Gleichheit sortieren

Außerdem wollte ich die Möglichkeit haben, Nicht-Objekte in Strings umzuwandeln, so dass [1,2]===["1",2]

Da mein Projekt UnderscoreJs verwendet, habe ich beschlossen, es zu einem Mixin zu machen und nicht zu einer eigenständigen Funktion.

Sie können es ausprobieren auf http://jsfiddle.net/nemesarial/T44W4/

Hier ist mein Mxin:

_.mixin({
  /**
  Tests for the equality of two variables
    valA: first variable
    valB: second variable
    stringifyStatics: cast non-objects to string so that "1"===1
  **/
  equal:function(valA,valB,stringifyStatics){
    stringifyStatics=!!stringifyStatics;

    //check for same type
    if(typeof(valA)!==typeof(valB)){
      if((_.isObject(valA) || _.isObject(valB))){
        return false;
      }
    }

    //test non-objects for equality
    if(!_.isObject(valA)){
      if(stringifyStatics){
        var valAs=''+valA;
        var valBs=''+valB;
        ret=(''+valA)===(''+valB);
      }else{
        ret=valA===valB;
      }
      return ret;
    }

    //test for length
    if(_.size(valA)!=_.size(valB)){
      return false;
    }

    //test for arrays first
    var isArr=_.isArray(valA);

    //test whether both are array or both object
    if(isArr!==_.isArray(valB)){
      return false;
    }

    var ret=true;
    if(isArr){
      //do test for arrays
      _.each(valA,function(val,idx,lst){
        if(!ret){return;}
        ret=ret && _.equal(val,valB[idx],stringifyStatics);
      });
    }else{
      //do test for objects
      _.each(valA,function(val,idx,lst){
        if(!ret){return;}

        //test for object member exists
        if(!_.has(valB,idx)){
          ret=false;
          return;
        }

        // test for member equality
        ret=ret && _.equal(val,valB[idx],stringifyStatics);
      });

    }
    return ret;
  }
});

So verwenden Sie es:

_.equal([1,2,3],[1,2,"3"],true)

Um die Verschachtelung zu demonstrieren, können Sie Folgendes tun:

_.equal(
    ['a',{b:'b',c:[{'someId':1},2]},[1,2,3]],
    ['a',{b:'b',c:[{'someId':"1"},2]},["1",'2',3]]
,true);

Answer 5

Es behandelt alle möglichen Dinge und verweist sogar auf sich selbst in der Struktur des Objekts. Sie können das Beispiel am Ende des Codes sehen.

var deepCompare = (function() {
    function internalDeepCompare (obj1, obj2, objects) {
        var i, objPair;

        if (obj1 === obj2) {
            return true;
        }

        i = objects.length;
        while (i--) {
            objPair = objects[i];
            if (  (objPair.obj1 === obj1 && objPair.obj2 === obj2) ||
                  (objPair.obj1 === obj2 && objPair.obj2 === obj1)  ) {                          
                return true;
            }                    
        }
        objects.push({obj1: obj1, obj2: obj2});

        if (obj1 instanceof Array) {
            if (!(obj2 instanceof Array)) {
                return false;
            }

            i = obj1.length;

            if (i !== obj2.length) {
               return false; 
            }

            while (i--) {
                if (!internalDeepCompare(obj1[i], obj2[i], objects)) {
                    return false;
                }
            }
        }
        else {
            switch (typeof obj1) {
                case "object":                
                    // deal with null
                    if (!(obj2 && obj1.constructor === obj2.constructor)) {
                        return false;
                    }

                    if (obj1 instanceof RegExp) {
                        if (!(obj2 instanceof RegExp && obj1.source === obj2.source)) {
                            return false;
                        }
                    }                 
                    else if (obj1 instanceof Date) {
                        if (!(obj2 instanceof Date && obj1.getTime() === obj2.getTime())) {
                            return false;
                        }
                    } 
                    else {    
                        for (i in obj1) {
                            if (obj1.hasOwnProperty(i)) {       
                                if (!(obj2.hasOwnProperty(i) && internalDeepCompare(obj1[i], obj2[i], objects))) {
                                    return false;
                                }
                            }
                        }         
                    }
                    break;
                case "function": 
                    if (!(typeof obj2 === "function" && obj1+"" === obj2+"")) {
                        return false;
                    }
                    break;
                default:                 //deal with NaN 
                    if (obj1 !== obj2 && obj1 === obj1 && obj2 === obj2) {
                        return false;            
                    }
            }
        }

        return true;
    }

    return function (obj1, obj2) {
        return internalDeepCompare(obj1, obj2, []);    
    };
}());

/*    
var a = [a, undefined, new Date(10), /.+/, {a:2}, function(){}, Infinity, -Infinity, NaN, 0, -0, 1, [4,5], "1", "-1", "a", null],
    b = [b, undefined, new Date(10), /.+/, {a:2}, function(){}, Infinity, -Infinity, NaN, 0, -0, 1, [4,5], "1", "-1", "a", null];
deepCompare(a, b);
*/