Comparación de matrices de objetos en JavaScript

Question

Quiero comparar 2 matrices de objetos en código JavaScript.Los objetos tienen 8 propiedades en total, pero cada objeto no tendrá un valor para cada uno, y las matrices nunca tendrán más de 8 elementos cada una, por lo que tal vez el método de fuerza bruta de atravesar cada uno y luego mirar los valores de los 8 propiedades es la forma más fácil de hacer lo que quiero hacer, pero antes de implementarlo, quería ver si alguien tenía una solución más elegante.¿Alguna idea?

Answer 1

EDITAR:No puede sobrecargar operadores en implementaciones actuales y comunes de intérpretes de JavaScript basadas en navegador.

Para responder a la pregunta original, una forma de hacer esto, y eso sí, es un truco, simplemente serializar las dos matrices a JSON y luego compare las dos cadenas JSON.Eso simplemente le diría si las matrices son diferentes, obviamente podría hacer esto para cada de los objetos dentro de las matrices también para ver cuáles eran diferentes.

Otra opción es utilizar una biblioteca que tenga buenas funciones para comparar objetos. Yo uso y recomiendo MochiKit.

---

EDITAR: La respuesta que dio Kamens. También merece consideración, ya que una sola función para comparar dos objetos dados sería mucho más pequeña que cualquier biblioteca para hacer lo que sugiero (aunque mi sugerencia ciertamente funcionaría bastante bien).

Aquí hay una implementación ingenua que puede ser suficiente para usted; tenga en cuenta que existen problemas potenciales con esta implementación:

function objectsAreSame(x, y) {
   var objectsAreSame = true;
   for(var propertyName in x) {
      if(x[propertyName] !== y[propertyName]) {
         objectsAreSame = false;
         break;
      }
   }
   return objectsAreSame;
}

La suposición es que ambos objetos tienen exactamente la misma lista de propiedades.

Ah, y probablemente sea obvio que, para bien o para mal, pertenezco al campo del único punto de retorno.:)

Answer 2

Sé que esta es una pregunta antigua y las respuestas proporcionadas funcionan bien...pero esto es un poco más corto y no requiere bibliotecas adicionales (es decir,JSON):

function arraysAreEqual(ary1,ary2){
  return (ary1.join('') == ary2.join(''));
}

Answer 3

Honestamente, con un máximo de 8 objetos y un máximo de 8 propiedades por objeto, lo mejor que puede hacer es simplemente atravesar cada objeto y hacer las comparaciones directamente.Será rápido y será fácil.

Si va a utilizar este tipo de comparaciones con frecuencia, entonces estoy de acuerdo con Jason sobre la serialización JSON... pero de lo contrario no hay necesidad de ralentizar su aplicación con una nueva biblioteca o código de serialización JSON.

Answer 4

He trabajado un poco en un algoritmo simple para comparar el contenido de dos objetos y devolver una lista inteligible de diferencias.Pensé en compartir.Toma prestadas algunas ideas para jQuery, a saber, la map implementación de funciones y verificación de tipos de objetos y matrices.

Devuelve una lista de "objetos de diferencia", que son matrices con la información de diferencia.Es muy sencillo.

Aquí lo tienes:

// compare contents of two objects and return a list of differences
// returns an array where each element is also an array in the form:
// [accessor, diffType, leftValue, rightValue ]
//
// diffType is one of the following:
//   value: when primitive values at that index are different
//   undefined: when values in that index exist in one object but don't in 
//              another; one of the values is always undefined
//   null: when a value in that index is null or undefined; values are
//         expressed as boolean values, indicated wheter they were nulls
//   type: when values in that index are of different types; values are 
//         expressed as types
//   length: when arrays in that index are of different length; values are
//           the lengths of the arrays
//

function DiffObjects(o1, o2) {
    // choose a map() impl.
    // you may use $.map from jQuery if you wish
    var map = Array.prototype.map?
        function(a) { return Array.prototype.map.apply(a, Array.prototype.slice.call(arguments, 1)); } :
        function(a, f) { 
            var ret = new Array(a.length), value;
            for ( var i = 0, length = a.length; i < length; i++ ) 
                ret[i] = f(a[i], i);
            return ret.concat();
        };

    // shorthand for push impl.
    var push = Array.prototype.push;

    // check for null/undefined values
    if ((o1 == null) || (o2 == null)) {
        if (o1 != o2)
            return [["", "null", o1!=null, o2!=null]];

        return undefined; // both null
    }
    // compare types
    if ((o1.constructor != o2.constructor) ||
        (typeof o1 != typeof o2)) {
        return [["", "type", Object.prototype.toString.call(o1), Object.prototype.toString.call(o2) ]]; // different type

    }

    // compare arrays
    if (Object.prototype.toString.call(o1) == "[object Array]") {
        if (o1.length != o2.length) { 
            return [["", "length", o1.length, o2.length]]; // different length
        }
        var diff =[];
        for (var i=0; i<o1.length; i++) {
            // per element nested diff
            var innerDiff = DiffObjects(o1[i], o2[i]);
            if (innerDiff) { // o1[i] != o2[i]
                // merge diff array into parent's while including parent object name ([i])
                push.apply(diff, map(innerDiff, function(o, j) { o[0]="[" + i + "]" + o[0]; return o; }));
            }
        }
        // if any differences were found, return them
        if (diff.length)
            return diff;
        // return nothing if arrays equal
        return undefined;
    }

    // compare object trees
    if (Object.prototype.toString.call(o1) == "[object Object]") {
        var diff =[];
        // check all props in o1
        for (var prop in o1) {
            // the double check in o1 is because in V8 objects remember keys set to undefined 
            if ((typeof o2[prop] == "undefined") && (typeof o1[prop] != "undefined")) {
                // prop exists in o1 but not in o2
                diff.push(["[" + prop + "]", "undefined", o1[prop], undefined]); // prop exists in o1 but not in o2

            }
            else {
                // per element nested diff
                var innerDiff = DiffObjects(o1[prop], o2[prop]);
                if (innerDiff) { // o1[prop] != o2[prop]
                    // merge diff array into parent's while including parent object name ([prop])
                    push.apply(diff, map(innerDiff, function(o, j) { o[0]="[" + prop + "]" + o[0]; return o; }));
                }

            }
        }
        for (var prop in o2) {
            // the double check in o2 is because in V8 objects remember keys set to undefined 
            if ((typeof o1[prop] == "undefined") && (typeof o2[prop] != "undefined")) {
                // prop exists in o2 but not in o1
                diff.push(["[" + prop + "]", "undefined", undefined, o2[prop]]); // prop exists in o2 but not in o1

            }
        }
        // if any differences were found, return them
        if (diff.length)
            return diff;
        // return nothing if objects equal
        return undefined;
    }
    // if same type and not null or objects or arrays
    // perform primitive value comparison
    if (o1 != o2)
        return [["", "value", o1, o2]];

    // return nothing if values are equal
    return undefined;
}

Answer 5

Lo intenté JSON.stringify() y funcionó para mí.

let array1 = [1,2,{value:'alpha'}] , array2 = [{value:'alpha'},'music',3,4];

JSON.stringify(array1) // "[1,2,{"value":"alpha"}]"

JSON.stringify(array2) // "[{"value":"alpha"},"music",3,4]"

JSON.stringify(array1) === JSON.stringify(array2); // false

Answer 6

Como la serialización no funciona generalmente (solo cuando el orden de las propiedades coincide: JSON.stringify({a:1,b:2}) !== JSON.stringify({b:2,a:1})) tienes que verificar el recuento de propiedades y comparar cada propiedad también:

const objectsEqual = (o1, o2) =>
    Object.keys(o1).length === Object.keys(o2).length 
        && Object.keys(o1).every(p => o1[p] === o2[p]);

const obj1 = { name: 'John', age: 33};
const obj2 = { age: 33, name: 'John' };
const obj3 = { name: 'John', age: 45 };
        
console.log(objectsEqual(obj1, obj2)); // true
console.log(objectsEqual(obj1, obj3)); // false

Si necesita una comparación profunda, puede llamar a la función de forma recursiva:

const obj1 = { name: 'John', age: 33, info: { married: true, hobbies: ['sport', 'art'] } };
const obj2 = { age: 33, name: 'John', info: { hobbies: ['sport', 'art'], married: true } };
const obj3 = { name: 'John', age: 33 };

const objectsEqual = (o1, o2) => 
    typeof o1 === 'object' && Object.keys(o1).length > 0 
        ? Object.keys(o1).length === Object.keys(o2).length 
            && Object.keys(o1).every(p => objectsEqual(o1[p], o2[p]))
        : o1 === o2;
        
console.log(objectsEqual(obj1, obj2)); // true
console.log(objectsEqual(obj1, obj3)); // false

Entonces es fácil usar esta función para comparar objetos en matrices:

const arr1 = [obj1, obj1];
const arr2 = [obj1, obj2];
const arr3 = [obj1, obj3];

const arraysEqual = (a1, a2) => 
   a1.length === a2.length && a1.every((o, idx) => objectsEqual(o, a2[idx]));

console.log(arraysEqual(arr1, arr2)); // true
console.log(arraysEqual(arr1, arr3)); // false

Answer 7

Por favor, pruebe este:

function used_to_compare_two_arrays(a, b)
{
  // This block will make the array of indexed that array b contains a elements
  var c = a.filter(function(value, index, obj) {
    return b.indexOf(value) > -1;
  });

  // This is used for making comparison that both have same length if no condition go wrong 
  if (c.length !== a.length) {
    return 0;
  } else{
    return 1;
  }
}

Answer 8

Aquí está mi intento, usando Módulo de afirmación del nodo + paquete npm hash de objeto.

Supongo que le gustaría comprobar si dos matrices contienen los mismos objetos, incluso si esos objetos están ordenados de manera diferente entre las dos matrices.

var assert = require('assert');
var hash = require('object-hash');

var obj1 = {a: 1, b: 2, c: 333},
    obj2 = {b: 2, a: 1, c: 444},
    obj3 = {b: "AAA", c: 555},
    obj4 = {c: 555, b: "AAA"};

var array1 = [obj1, obj2, obj3, obj4];
var array2 = [obj3, obj2, obj4, obj1]; // [obj3, obj3, obj2, obj1] should work as well

// calling assert.deepEquals(array1, array2) at this point FAILS (throws an AssertionError)
// even if array1 and array2 contain the same objects in different order,
// because array1[0].c !== array2[0].c

// sort objects in arrays by their hashes, so that if the arrays are identical,
// their objects can be compared in the same order, one by one
var array1 = sortArrayOnHash(array1);
var array2 = sortArrayOnHash(array2);

// then, this should output "PASS"
try {
    assert.deepEqual(array1, array2);
    console.log("PASS");
} catch (e) {
    console.log("FAIL");
    console.log(e);
}

// You could define as well something like Array.prototype.sortOnHash()...
function sortArrayOnHash(array) {
    return array.sort(function(a, b) {
        return hash(a) > hash(b);
    });
}

Answer 9

El objectsAreSame La función mencionada en la respuesta de @JasonBunting funciona bien para mí.Sin embargo, hay un pequeño problema:Si x[propertyName] y y[propertyName] son objetos (typeof x[propertyName] == 'object'), necesitarás llamar a la función de forma recursiva para poder compararlos.

Answer 10

usando _.some de lodash: https://lodash.com/docs/4.17.11#some

const array1AndArray2NotEqual = 
          _.some(array1, (a1, idx) => a1.key1 !== array2[idx].key1 
                                     || a1.key2 !== array2[idx].key2 
                                     || a1.key3 !== array2[idx].key3);