Home / Questions / 58926
Accepted
bypabloc_
Asked: 2020-03-30 10:00:50 +0800 CST 2020-03-30 10:00:50 +0800 CST

如何比较两个数组并消除相同的对象并仅返回不在其中的对象？

  • 772

就像在php( link ) 中完成的一样，但我想在javascript.

var data1 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 6,
    "nombre": "No Se"
  },
  {
    "id": 5,
    "nombre": "Etiquetado"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

console.log(data1);

var data2 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

console.log(data2);

更新 1： 在这 2 个中，arrays我返回以下内容：

var data3 = [{
    "id": 6,
    "nombre": "No Se"
  },
  {
    "id": 5,
    "nombre": "Etiquetado"
  }
];

console.log(data3);

javascript

6 Answers

  1. 我不知道这是否是您正在寻找的方式，但我添加了它，因为它达到了预期的结果。用两个For简单的数组循环两个数组。然后去比较字段之间的差异。

    var data1 = [
  { "id": 1, "nombre": "Mezcla" },
  { "id": 6, "nombre": "No Se" },
  { "id": 5, "nombre": "Etiquetado" },
  { "id": 4, "nombre": "Vaciado" },
  { "id": 3, "nombre": "Llenado" },
  { "id": 2, "nombre": "Esterilizacion" }
];

var data2 = [
  { "id": 1, "nombre": "Mezcla" },
  { "id": 4, "nombre": "Vaciado" },
  { "id": 3, "nombre": "Llenado" },
  { "id": 2, "nombre": "Esterilizacion" }
];

var array = [];
for (var i = 0; i < data1.length; i++) {
    var igual=false;
     for (var j = 0; j < data2.length & !igual; j++) {
         if(data1[i]['id'] == data2[j]['id'] && 
            data1[i]['nombre'] == data2[j]['nombre']) 
                 igual=true;
     }
    if(!igual)array.push(data1[i]);
}
console.log(JSON.stringify(array));

    • 6
  2. Best Answer

    这显然可以使用纯 javascript 来完成，但是对于使用集合，已经有经过充分验证的工具，例如下划线和lodash。

    下面的解决方案使用了lodash的find方法。

    var data1 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 6,
    "nombre": "No Se"
  },
  {
    "id": 5,
    "nombre": "Etiquetado"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];


var data2 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

var data3=[];

_.each(data1,function(objeto) {
  
  var elemento_en_data2 = _.find(data2,objeto);
  
  if(elemento_en_data2===undefined) {
    data3.push(objeto);
  }
  
});

console.log(data3);
    <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

    您的问题的主要困难是，在 javascript 中，两个对象彼此不相等，即使它们具有相同的属性。对于相同的使用方法查找某个对象的存在indexOf

    var posicion = data2.indexOf({"id": 2, "nombre": "Esterilizacion"});

    它总是说对象不在数组中。当两个对象的可枚举属性重合时，有必要实现一个相等函数，然后在嵌套循环中遍历两个数组，检查是否存在满足该自定义函数的元素。我宁愿不重新发明轮子。

    • 2

  3. 在这里，我留下一个纯 JavaScript 版本，虽然它有点“丑陋”。这个想法是将对象转换为字符串，以使它们更易于使用。步骤是：

    1. 将对象数组转换为字符串数组
    2. 我们添加第一个数组中不在第二个数组中的所有字符串
    3. 我们添加第二个数组中所有不在第一个数组中的字符串
    4. 我们将字符串转换回对象

    代码如下所示：

    var data1 = [
  { "id": 1, "nombre": "Mezcla" },
  { "id": 6, "nombre": "No Se" },
  { "id": 5, "nombre": "Etiquetado" },
  { "id": 4, "nombre": "Vaciado" },
  { "id": 3, "nombre": "Llenado" },
  { "id": 2, "nombre": "Esterilizacion" }
];

var data2 = [
  { "id": 1, "nombre": "Mezcla" },
  { "id": 4, "nombre": "Vaciado" },
  { "id": 3, "nombre": "Llenado" },
  { "id": 2, "nombre": "Esterilizacion" }
];

// convertimos los arrays de objetos a arrays de cadenas
var aux1 = data1.map(function(el) { return JSON.stringify(el); });
var aux2 = data2.map(function(el) { return JSON.stringify(el); });

// añadimos todas las cadenas del primer array que no estén en el segundo
var data3 = aux1.filter(function(el) {
  if (aux2.indexOf(el) < 0) return el;
});

// añadimos todas las cadenas del segundo array que no estén en el primero
data3 = data3.concat( aux2.filter(function(el) {
  if (aux1.indexOf(el) < 0) return el;
}));

// convertimos las cadenas de nuevo a objetos
data3 = data3.map(function (el) { return JSON.parse(el); });

// mostramos el resultado
console.log(data3);

    如果您不想将对象转换为字符串，则可以定义自己的比较函数并遍历数组以查找重复元素（而不是使用indexOf）。

    像这样的东西：

    var data1 = [
  { "id": 1, "nombre": "Mezcla" },
  { "id": 6, "nombre": "No Se" },
  { "id": 5, "nombre": "Etiquetado" },
  { "id": 4, "nombre": "Vaciado" },
  { "id": 3, "nombre": "Llenado" },
  { "id": 2, "nombre": "Esterilizacion" }
];

var data2 = [
  { "id": 1, "nombre": "Mezcla" },
  { "id": 4, "nombre": "Vaciado" },
  { "id": 3, "nombre": "Llenado" },
  { "id": 2, "nombre": "Esterilizacion" }
];

// añadimos todas las cadenas del primer array que no estén en el segundo
var data3 = data1.filter(function(el) {
  var found = false, x = 0;
  while (x < data2.length && !found) {
    if (el.id == data2[x].id && el.nombre == data2[x].nombre) found = true;
    x++;
  }
  if (!found) return el;
});

// añadimos todas las cadenas del segundo array que no estén en el primero
data3 = data3.concat( data2.filter(function(el) {
  var found = false, x = 0;
  while (x < data1.length && !found) {
    if (el.id == data1[x].id && el.nombre == data1[x].nombre) found = true;
    x++;
  }
  if (!found) return el;
}));

console.log(data3);

    • 2

  4. 这是我的版本array_diff_assoc：

    • 支持1 o más安排
    • 使用比较对象JSON.stringify
    • 返回不在其他所有值中的所有arr1值。

    示范：

    function array_diff_assoc () {
  var args = Array.prototype.slice.call(arguments),
   arr = args.shift().splice(0);

  args.forEach(function(arrN) {
    arrN.forEach(function(objN) {
      for(var i = 0; i < arr.length; i++) {
        if (JSON.stringify(arr[i]) === JSON.stringify(objN)) {
          arr.splice(i, 1);
          break;
        }
      }
    });
  });
  
  return arr;
}

var data1 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 6,
    "nombre": "No Se"
  },
  {
    "id": 5,
    "nombre": "Etiquetado"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

var data2 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

console.log(array_diff_assoc(data1, data2));

    • 2

  5. 根据您的问题，我假设对象总是很简单，没有方法或 html 节点，否则解决方案会有点复杂

    Array.prototype.arrayDiffAssoc = function(){
            //Une los arrays
    return [].concat.apply( this, arguments )
                //Convierte a string los json (funciona siempre que sea un objeto simple)
                .map(function(obj){ return JSON.stringify(obj) })
                //remueve los elementos duplicados que van a retornar siempre lenght > 1
                .filter(function(item, index, self) { return self.filter(function(duplicate){ return item === duplicate; }).length === 1; })
                //restaura los objetos en el array
                .map(function(obj) { return JSON.parse(obj); });
}

//Te permite
data1.arrayDiffAssoc(data2); // [{"id": 6,"nombre": "No Se"},{"id": 5, "nombre": "Etiquetado"}]

//o en caso de tener otro array para comparar
data1.arrayDiffAssoc(data2, data3); // [{"id": 6,"nombre": "No Se"},{"id": 5, "nombre": "Etiquetado"}]
    • 1

  6. 我对这个问题的版本

    var data1 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 6,
    "nombre": "No Se"
  },
  {
    "id": 5,
    "nombre": "Etiquetado"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

var data2 = [{
    "id": 1,
    "nombre": "Mezcla"
  },
  {
    "id": 4,
    "nombre": "Vaciado"
  },
  {
    "id": 3,
    "nombre": "Llenado"
  },
  {
    "id": 2,
    "nombre": "Esterilizacion"
  }
];

    var data3=[];
        data1.forEach(i => {
        var existe= false;
        data2.forEach(j => {
          !igual && i.id== j.id&& (existe= true);
        });
        !existe && data3.push(i);
      });

console.log(data3);
    • 1