wake-up-neo.com

Objektvergleich in JavaScript

Was ist der beste Weg, um Objekte in JavaScript zu vergleichen?

Beispiel:

var user1 = {name : "nerd", org: "dev"};
var user2 = {name : "nerd", org: "dev"};
var eq = user1 == user2;
alert(eq); // gives false

Ich weiß, dass zwei Objekte sind gleich, wenn sie sich auf genau dasselbe Objekt beziehen, aber gibt es eine Möglichkeit zu überprüfen, ob sie die gleichen Attributwerte haben?

Der folgende Weg funktioniert für mich, aber ist es die einzige Möglichkeit?

var eq = Object.toJSON(user1) == Object.toJSON(user2);
alert(eq); // gives true
javascriptobjectcomparisonobject-comparison
963
spankmaster79

Leider gibt es keine perfekte Möglichkeit, es sei denn, Sie verwenden _proto_ rekursiv und greifen auf alle nicht aufzählbaren Eigenschaften zu, dies funktioniert jedoch nur in Firefox.

Das Beste, was ich tun kann, ist, Nutzungsszenarien zu erraten.

1) Schnell und begrenzt.

Funktioniert, wenn Sie einfache Objekte im JSON-Stil ohne Methoden und DOM-Knoten haben:

 JSON.stringify(obj1) === JSON.stringify(obj2)

Die ORDER der Eigenschaften IS WICHTIG, daher gibt diese Methode für folgende Objekte false zurück:

 x = {a: 1, b: 2};
 y = {b: 2, a: 1};

2) Langsam und allgemeiner.

Vergleicht Objekte, ohne in Prototypen zu graben, vergleicht dann rekursiv die Projektionen der Eigenschaften und vergleicht auch Konstruktoren.

Dies ist fast der richtige Algorithmus:

function deepCompare () {
  var i, l, leftChain, rightChain;

  function compare2Objects (x, y) {
    var p;

    // remember that NaN === NaN returns false
    // and isNaN(undefined) returns true
    if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
         return true;
    }

    // Compare primitives and functions.     
    // Check if both arguments link to the same object.
    // Especially useful on the step where we compare prototypes
    if (x === y) {
        return true;
    }

    // Works in case when functions are created in constructor.
    // Comparing dates is a common scenario. Another built-ins?
    // We can even handle functions passed across iframes
    if ((typeof x === 'function' && typeof y === 'function') ||
       (x instanceof Date && y instanceof Date) ||
       (x instanceof RegExp && y instanceof RegExp) ||
       (x instanceof String && y instanceof String) ||
       (x instanceof Number && y instanceof Number)) {
        return x.toString() === y.toString();
    }

    // At last checking prototypes as good as we can
    if (!(x instanceof Object && y instanceof Object)) {
        return false;
    }

    if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
        return false;
    }

    if (x.constructor !== y.constructor) {
        return false;
    }

    if (x.prototype !== y.prototype) {
        return false;
    }

    // Check for infinitive linking loops
    if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
         return false;
    }

    // Quick checking of one object being a subset of another.
    // todo: cache the structure of arguments[0] for performance
    for (p in y) {
        if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
            return false;
        }
        else if (typeof y[p] !== typeof x[p]) {
            return false;
        }
    }

    for (p in x) {
        if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
            return false;
        }
        else if (typeof y[p] !== typeof x[p]) {
            return false;
        }

        switch (typeof (x[p])) {
            case 'object':
            case 'function':

                leftChain.Push(x);
                rightChain.Push(y);

                if (!compare2Objects (x[p], y[p])) {
                    return false;
                }

                leftChain.pop();
                rightChain.pop();
                break;

            default:
                if (x[p] !== y[p]) {
                    return false;
                }
                break;
        }
    }

    return true;
  }

  if (arguments.length < 1) {
    return true; //Die silently? Don't know how to handle such case, please help...
    // throw "Need two or more arguments to compare";
  }

  for (i = 1, l = arguments.length; i < l; i++) {

      leftChain = []; //Todo: this can be cached
      rightChain = [];

      if (!compare2Objects(arguments[0], arguments[i])) {
          return false;
      }
  }

  return true;
}

Bekannte Probleme (na ja, sie haben eine sehr niedrige Priorität, wahrscheinlich werden Sie sie nie bemerken):

  • objekte mit unterschiedlicher Prototypstruktur, aber gleicher Projektion
  • funktionen können identischen Text haben, sich jedoch auf verschiedene Abschlüsse beziehen

Tests: bestandene Tests stammen von Wie wird die Gleichheit für zwei JavaScript-Objekte ermittelt?.

1156
crazyx
  Utils.compareObjects = function(o1, o2){
    for(var p in o1){
        if(o1.hasOwnProperty(p)){
            if(o1[p] !== o2[p]){
                return false;
            }
        }
    }
    for(var p in o2){
        if(o2.hasOwnProperty(p)){
            if(o1[p] !== o2[p]){
                return false;
            }
        }
    }
    return true;
};

Einfache Möglichkeit, nur EINSTUFIGE Objekte zu vergleichen.

25
pincopallo

Mit Sicherheit nicht der einzige Weg - Sie könnten eine Methode prototypisieren (hier gegen Object, aber ich würde auf keinen Fall die Verwendung von Object für Live-Code vorschlagen), um Vergleichsmethoden im C #/Java-Stil zu replizieren.

Bearbeiten, da ein allgemeines Beispiel zu erwarten scheint:

Object.prototype.equals = function(x)
{
    for(p in this)
    {
        switch(typeof(this[p]))
        {
            case 'object':
                if (!this[p].equals(x[p])) { return false }; break;
            case 'function':
                if (typeof(x[p])=='undefined' || (p != 'equals' && this[p].toString() != x[p].toString())) { return false; }; break;
            default:
                if (this[p] != x[p]) { return false; }
        }
    }

    for(p in x)
    {
        if(typeof(this[p])=='undefined') {return false;}
    }

    return true;
}

Beachten Sie, dass Testmethoden mit toString () absolut nicht gut genug sind, aber eine Methode, die akzeptabel wäre, ist sehr schwierig, da das Problem der Bedeutung von Leerzeichen besteht oder nicht Ergebnis mit verschiedenen Implementierungen. nd die Probleme des Prototyping gegen Object im Allgemeinen.

22
annakata

Der folgende Algorithmus verarbeitet selbstreferenzierende Datenstrukturen, Zahlen, Zeichenfolgen, Datumsangaben und natürlich einfach verschachtelte Javascript-Objekte:

Objekte gelten als gleichwertig, wenn

  • Sie sind pro === genau gleich (String und Number werden zuerst entpackt, um sicherzustellen, dass 42Number(42) entspricht)
  • oder sie sind beide Daten und haben das gleiche valueOf()
  • oder sie sind beide vom selben Typ und nicht null und ...
    • sie sind keine Objekte und laut == gleich (fängt Zahlen/Zeichenfolgen/Boolesche Werte ab).
    • wenn Eigenschaften mit dem Wert undefined ignoriert werden, haben sie dieselben Eigenschaften, die alle als rekursiv äquivalent gelten.

Funktionen werden vom Funktionstext nicht als identisch angesehen. Dieser Test ist unzureichend, da Funktionen unterschiedliche Verschlüsse haben können. Funktionen werden nur dann als gleich angesehen, wenn === dies sagt (aber Sie können diese äquivalente Beziehung leicht erweitern, wenn Sie dies wünschen).

Endlosschleifen, die möglicherweise durch kreisförmige Datenstrukturen verursacht werden, werden vermieden. Wenn areEquivalent versucht, die Gleichheit zu widerlegen, und dazu in die Eigenschaften eines Objekts zurückkehrt, verfolgt es die Objekte, für die dieser Untervergleich erforderlich ist. Wenn die Gleichheit widerlegt werden kann, unterscheidet sich ein erreichbarer Eigenschaftspfad zwischen den Objekten. Dann muss es einen kürzesten erreichbaren Pfad geben, und dieser kürzeste erreichbare Pfad darf keine Zyklen enthalten, die in beiden Pfaden vorhanden sind. es ist in Ordnung, Gleichheit anzunehmen, wenn Objekte rekursiv verglichen werden. Die Annahme wird in einer Eigenschaft areEquivalent_Eq_91_2_34 gespeichert, die nach der Verwendung gelöscht wird. Wenn das Objektdiagramm jedoch bereits eine solche Eigenschaft enthält, ist das Verhalten undefiniert. Die Verwendung einer solchen Marker-Eigenschaft ist erforderlich, da Javascript keine Wörterbücher unterstützt, die beliebige Objekte als Schlüssel verwenden.

function unwrapStringOrNumber(obj) {
    return (obj instanceof Number || obj instanceof String 
            ? obj.valueOf() 
            : obj);
}
function areEquivalent(a, b) {
    a = unwrapStringOrNumber(a);
    b = unwrapStringOrNumber(b);
    if (a === b) return true; //e.g. a and b both null
    if (a === null || b === null || typeof (a) !== typeof (b)) return false;
    if (a instanceof Date) 
        return b instanceof Date && a.valueOf() === b.valueOf();
    if (typeof (a) !== "object") 
        return a == b; //for boolean, number, string, xml

    var newA = (a.areEquivalent_Eq_91_2_34 === undefined),
        newB = (b.areEquivalent_Eq_91_2_34 === undefined);
    try {
        if (newA) a.areEquivalent_Eq_91_2_34 = [];
        else if (a.areEquivalent_Eq_91_2_34.some(
            function (other) { return other === b; })) return true;
        if (newB) b.areEquivalent_Eq_91_2_34 = [];
        else if (b.areEquivalent_Eq_91_2_34.some(
            function (other) { return other === a; })) return true;
        a.areEquivalent_Eq_91_2_34.Push(b);
        b.areEquivalent_Eq_91_2_34.Push(a);

        var tmp = {};
        for (var prop in a) 
            if(prop != "areEquivalent_Eq_91_2_34") 
                tmp[prop] = null;
        for (var prop in b) 
            if (prop != "areEquivalent_Eq_91_2_34") 
                tmp[prop] = null;

        for (var prop in tmp) 
            if (!areEquivalent(a[prop], b[prop]))
                return false;
        return true;
    } finally {
        if (newA) delete a.areEquivalent_Eq_91_2_34;
        if (newB) delete b.areEquivalent_Eq_91_2_34;
    }
}
17
Eamon Nerbonne

Ich habe diesen Code für den Objektvergleich geschrieben, und er scheint zu funktionieren. überprüfe die Behauptungen:


function countProps(obj) {
    var count = 0;
    for (k in obj) {
        if (obj.hasOwnProperty(k)) {
            count++;
        }
    }
    return count;
};

function objectEquals(v1, v2) {

    if (typeof(v1) !== typeof(v2)) {
        return false;
    }

    if (typeof(v1) === "function") {
        return v1.toString() === v2.toString();
    }

    if (v1 instanceof Object && v2 instanceof Object) {
        if (countProps(v1) !== countProps(v2)) {
            return false;
        }
        var r = true;
        for (k in v1) {
            r = objectEquals(v1[k], v2[k]);
            if (!r) {
                return false;
            }
        }
        return true;
    } else {
        return v1 === v2;
    }
}

assert.isTrue(objectEquals(null,null));
assert.isFalse(objectEquals(null,undefined));

assert.isTrue(objectEquals("hi","hi"));
assert.isTrue(objectEquals(5,5));
assert.isFalse(objectEquals(5,10));

assert.isTrue(objectEquals([],[]));
assert.isTrue(objectEquals([1,2],[1,2]));
assert.isFalse(objectEquals([1,2],[2,1]));
assert.isFalse(objectEquals([1,2],[1,2,3]));

assert.isTrue(objectEquals({},{}));
assert.isTrue(objectEquals({a:1,b:2},{a:1,b:2}));
assert.isTrue(objectEquals({a:1,b:2},{b:2,a:1}));
assert.isFalse(objectEquals({a:1,b:2},{a:1,b:3}));

assert.isTrue(objectEquals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}},{1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}));
assert.isFalse(objectEquals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}},{1:{name:"mhc",age:28}, 2:{name:"arb",age:27}}));

assert.isTrue(objectEquals(function(x){return x;},function(x){return x;}));
assert.isFalse(objectEquals(function(x){return x;},function(y){return y+2;}));
12
mhoms

Ich habe den obigen Code ein wenig geändert. für mich ! == false und null! == undefined. Wenn Sie keine so strenge Prüfung benötigen, entfernen Sie ein "=" Anmelden "this [p]! == x [p]" im Code.

Object.prototype.equals = function(x){
    for (var p in this) {
        if(typeof(this[p]) !== typeof(x[p])) return false;
        if((this[p]===null) !== (x[p]===null)) return false;
        switch (typeof(this[p])) {
            case 'undefined':
                if (typeof(x[p]) != 'undefined') return false;
                break;
            case 'object':
                if(this[p]!==null && x[p]!==null && (this[p].constructor.toString() !== x[p].constructor.toString() || !this[p].equals(x[p]))) return false;
                break;
            case 'function':
                if (p != 'equals' && this[p].toString() != x[p].toString()) return false;
                break;
            default:
                if (this[p] !== x[p]) return false;
        }
    }
    return true;
}

Dann habe ich es mit nächsten Objekten getestet:

var a = {a: 'text', b:[0,1]};
var b = {a: 'text', b:[0,1]};
var c = {a: 'text', b: 0};
var d = {a: 'text', b: false};
var e = {a: 'text', b:[1,0]};
var f = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
var g = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
var h = {a: 'text', b:[1,0], f: function(){ this.a = this.b; }};
var i = {
    a: 'text',
    c: {
        b: [1, 0],
        f: function(){
            this.a = this.b;
        }
    }
};
var j = {
    a: 'text',
    c: {
        b: [1, 0],
        f: function(){
            this.a = this.b;
        }
    }
};
var k = {a: 'text', b: null};
var l = {a: 'text', b: undefined};

a == b erwartet wahr; zurückgegeben wahr

a == c erwartet falsch; Falsch zurückgegeben

c == d erwartet falsch; Falsch zurückgegeben

a == e erwartet falsch; Falsch zurückgegeben

f == g erwartet wahr; zurückgegeben wahr

h == g erwartet falsch; Falsch zurückgegeben

i == j erwartet wahr; zurückgegeben wahr

d == k erwartet falsch; Falsch zurückgegeben

k == Ich habe falsch erwartet; Falsch zurückgegeben

6
Jevgeni Kiski

wenn Sie explizit nach Methoden suchen möchten, können Sie die Methoden method.toSource () oder method.toString () verwenden.

4
Nicolas R

Hier ist meine Version, so ziemlich alles aus diesem Thread ist integriert (das gleiche gilt für die Testfälle):

Object.defineProperty(Object.prototype, "equals", {
    enumerable: false,
    value: function (obj) {
        var p;
        if (this === obj) {
            return true;
        }

        // some checks for native types first

        // function and sring
        if (typeof(this) === "function" || typeof(this) === "string" || this instanceof String) { 
            return this.toString() === obj.toString();
        }

        // number
        if (this instanceof Number || typeof(this) === "number") {
            if (obj instanceof Number || typeof(obj) === "number") {
                return this.valueOf() === obj.valueOf();
            }
            return false;
        }

        // null.equals(null) and undefined.equals(undefined) do not inherit from the 
        // Object.prototype so we can return false when they are passed as obj
        if (typeof(this) !== typeof(obj) || obj === null || typeof(obj) === "undefined") {
            return false;
        }

        function sort (o) {
            var result = {};

            if (typeof o !== "object") {
                return o;
            }

            Object.keys(o).sort().forEach(function (key) {
                result[key] = sort(o[key]);
            });

            return result;
        }

        if (typeof(this) === "object") {
            if (Array.isArray(this)) { // check on arrays
                return JSON.stringify(this) === JSON.stringify(obj);                
            } else { // anyway objects
                for (p in this) {
                    if (typeof(this[p]) !== typeof(obj[p])) {
                        return false;
                    }
                    if ((this[p] === null) !== (obj[p] === null)) {
                        return false;
                    }
                    switch (typeof(this[p])) {
                    case 'undefined':
                        if (typeof(obj[p]) !== 'undefined') {
                            return false;
                        }
                        break;
                    case 'object':
                        if (this[p] !== null 
                                && obj[p] !== null 
                                && (this[p].constructor.toString() !== obj[p].constructor.toString() 
                                        || !this[p].equals(obj[p]))) {
                            return false;
                        }
                        break;
                    case 'function':
                        if (this[p].toString() !== obj[p].toString()) {
                            return false;
                        }
                        break;
                    default:
                        if (this[p] !== obj[p]) {
                            return false;
                        }
                    }
                };

            }
        }

        // at least check them with JSON
        return JSON.stringify(sort(this)) === JSON.stringify(sort(obj));
    }
});

Hier ist mein TestCase:

    assertFalse({}.equals(null));
    assertFalse({}.equals(undefined));

    assertTrue("String", "hi".equals("hi"));
    assertTrue("Number", new Number(5).equals(5));
    assertFalse("Number", new Number(5).equals(10));
    assertFalse("Number+String", new Number(1).equals("1"));

    assertTrue([].equals([]));
    assertTrue([1,2].equals([1,2]));
    assertFalse([1,2].equals([2,1]));
    assertFalse([1,2].equals([1,2,3]));

    assertTrue(new Date("2011-03-31").equals(new Date("2011-03-31")));
    assertFalse(new Date("2011-03-31").equals(new Date("1970-01-01")));

    assertTrue({}.equals({}));
    assertTrue({a:1,b:2}.equals({a:1,b:2}));
    assertTrue({a:1,b:2}.equals({b:2,a:1}));
    assertFalse({a:1,b:2}.equals({a:1,b:3}));

    assertTrue({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}));
    assertFalse({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28}, 2:{name:"arb",age:27}}));

    assertTrue("Function", (function(x){return x;}).equals(function(x){return x;}));
    assertFalse("Function", (function(x){return x;}).equals(function(y){return y+2;}));

    var a = {a: 'text', b:[0,1]};
    var b = {a: 'text', b:[0,1]};
    var c = {a: 'text', b: 0};
    var d = {a: 'text', b: false};
    var e = {a: 'text', b:[1,0]};
    var f = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
    var g = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
    var h = {a: 'text', b:[1,0], f: function(){ this.a = this.b; }};
    var i = {
        a: 'text',
        c: {
            b: [1, 0],
            f: function(){
                this.a = this.b;
            }
        }
    };
    var j = {
        a: 'text',
        c: {
            b: [1, 0],
            f: function(){
                this.a = this.b;
            }
        }
    };
    var k = {a: 'text', b: null};
    var l = {a: 'text', b: undefined};

    assertTrue(a.equals(b));
    assertFalse(a.equals(c));
    assertFalse(c.equals(d));
    assertFalse(a.equals(e));
    assertTrue(f.equals(g));
    assertFalse(h.equals(g));
    assertTrue(i.equals(j));
    assertFalse(d.equals(k));
    assertFalse(k.equals(l));
4
gossi

Wenn Sie ohne die JSON-Bibliothek arbeiten, hilft Ihnen möglicherweise Folgendes:

Object.prototype.equals = function(b) {
    var a = this;
    for(i in a) {
        if(typeof b[i] == 'undefined') {
            return false;
        }
        if(typeof b[i] == 'object') {
            if(!b[i].equals(a[i])) {
                return false;
            }
        }
        if(b[i] != a[i]) {
            return false;
        }
    }
    for(i in b) {
        if(typeof a[i] == 'undefined') {
            return false;
        }
        if(typeof a[i] == 'object') {
            if(!a[i].equals(b[i])) {
                return false;
            }
        }
        if(a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

var a = {foo:'bar', bar: {blub:'bla'}};
var b = {foo:'bar', bar: {blub:'blob'}};
alert(a.equals(b)); // alert's a false
3
Samuel Weber