Wie bestimmt man die Gleichheit zweier JavaScript-Objekte?

Question

Ein strikter Gleichheitsoperator sagt Ihnen, ob zwei Objekte Typen gleich sind. Gibt es jedoch eine Möglichkeit zu erkennen, ob zwei Objekte gleich sind, ähnlich wie der Hash-Code Wert in Java?

Stack Overflow Frage Gibt es irgendeine Art von HashCode-Funktion in JavaScript? ist dieser Frage ähnlich, erfordert aber eine eher akademische Antwort. Das obige Szenario zeigt, warum es notwendig wäre, eine zu haben, und ich frage mich, ob es irgendeine gleichwertige Lösung .

Answer 1

Hier ist ein sehr einfacher Ansatz zur Überprüfung der "Wertgleichheit" eines Objekts.

var john = {
    occupation: "Web Developer",
    age: 25
};

var bobby = {
    occupation: "Web Developer",
    age: 25
};

function isEquivalent(a, b) {
    // Create arrays of property names

    var aProps = Object.getOwnPropertyNames(a);
    var bProps = Object.getOwnPropertyNames(b);

    // If number of properties is different, objects are not equivalent

    if (aProps.length != bProps.length) {
        return false;
    }

    for (var i = 0; i < aProps.length; i++) {
        var propName = aProps[i];

        // If values of same property are not equal, objects are not equivalent
        if (a[propName] !== b[propName]) {
           return false;
        }
    }

    // If we made it this far, objects are considered equivalent
    return true;
}

// Outputs: true
console.log(isEquivalent(john, bobby));

Demo - JSFiddle

Wie Sie sehen, müssen wir, um die "Wertgleichheit" der Objekte zu prüfen, im Wesentlichen jede Eigenschaft der Objekte durchlaufen, um zu sehen, ob sie gleich sind. Und obwohl diese einfache Implementierung für unser Beispiel funktioniert, gibt es eine Menge Fälle, die sie nicht abdeckt. Zum Beispiel:

• Was ist, wenn einer der Eigenschaftswerte selbst ein Objekt ist?
• Was ist, wenn einer der Eigenschaftswerte NaN ist (der einzige Wert in JavaScript, der nicht gleich sich selbst ist?)
• Was ist, wenn a eine Eigenschaft mit dem Wert undefiniert hat, während b keine Eigenschaft hat? diese Eigenschaft nicht hat (die somit als undefiniert ausgewertet wird)?

Für eine robuste Methode zur Überprüfung der "Wertgleichheit" von Objekten ist es besser, sich auf eine gut getestete Bibliothek zu verlassen, die die verschiedenen Randfälle abdeckt wie Unterstrich .

var john = {
    occupation: "Web Developer",
    age: 25
};

var bobby = {
    occupation: "Web Developer",
    age: 25
};

// Outputs: true
console.log(_.isEqual(john, bobby));

Demo - JSFiddle

Answer 2

Wenn Sie wirklich vergleichen und den Unterschied zwischen den beiden Objekten zurückgeben möchten. können Sie dieses Paket verwenden: https://www.npmjs.com/package/deep-diff

oder verwenden Sie einfach den in diesem Paket verwendeten Code

https://github.com/flitbit/diff/blob/master/index.js

nur nicht in eine zu vergleichende Zeichenkette umwandeln.

Answer 3

const obj = {
  name: "Carl",
  age: 15
}
const obj2 = {
  name: "Carl",
  age: 15,
}

const compareObj = (objects) => {
  const res =  objects.map((item) => {
    return Object.entries(item).flat().join()
  })
  return res.every((a) => {
    return a === res[0]
  })
}

console.log(compareObj([obj,obj2]))

Answer 4

Eine zusätzliche Option ist die Verwendung von equals de Ramda-Bibliothek :

const c = {a: 1, b: 2};
const d = {b: 2, a: 1};
R.equals(c, d); //=> true

Answer 5

Ich habe diese Methode nur geschrieben, um sicher zu sein, dass Arrays und Objekte auf eindeutige Weise verglichen werden.

Das sollte auch klappen! :)

public class Objects {
    /**
     * Checks whether a value is of type Object
     * @param value the value
     */
    public static isObject = (value: any): boolean => {
        return value === Object(value) && Object.prototype.toString.call(value) !== '[object Array]'
    }

    /**
     * Checks whether a value is of type Array
     * @param value the value
     */
    public static isArray = (value: any): boolean => {
        return Object.prototype.toString.call(value) === '[object Array]' && !Objects.isObject(value)
    }

    /**
     * Check whether two values are equal
     */
    public static isEqual = (objectA: any, objectB: any) => {
        // Objects
        if (Objects.isObject(objectA) && !Objects.isObject(objectB)) {
            return false
        }
        else if (!Objects.isObject(objectA) && Objects.isObject(objectB)) {
            return false
        }
        // Arrays
        else if (Objects.isArray(objectA) && !Objects.isArray(objectB)) {
            return false
        }
        else if (!Objects.isArray(objectA) && Objects.isArray(objectB)) {
            return false
        }
        // Primitives
        else if (!Objects.isArray(objectA) && !Objects.isObject(objectA)) {
            return objectA === objectB
        }
        // Object or array
        else {
            const compareObject = (objectA: any, objectB: any): boolean => {
                if (Object.keys(objectA).length !== Object.keys(objectB).length) return false

                for (const propertyName of Object.keys(objectA)) {
                    const valueA = objectA[propertyName]
                    const valueB = objectB[propertyName]

                    if (!Objects.isEqual(valueA, valueB)) {
                        return false
                    }
                }

                return true
            }
            const compareArray = (arrayA: any[], arrayB: any[]): boolean => {
                if (arrayA.length !== arrayB.length) return false

                for (const index in arrayA) {
                    const valueA = arrayA[index]
                    const valueB = arrayB[index]

                    if (!Objects.isEqual(valueA, valueB)) {
                        return false
                    }
                }

                return true
            }
            if (Objects.isObject(objectA)) {
                return compareObject(objectA, objectB)
            } else {
                return compareArray(objectA, objectB)
            }
        }
    }
}