比较Javascript中的两个数组

我有两个Javascript数组，目前看起来像这样，但由HTTP请求（节点）更新：

我希望比较这些数组，这样，如果y中有一个数组不在x中，它将被保存到一个新数组-

z

。请注意，有时数组中数组的顺序会改变，但我不希望这影响结果

但是，如果x中有一个数组不在y中，则不应将is保存到

z

我已阅读并能够复制此内容，但如果

x

数组未显示在

y

中，它将打印到

z

。我想知道是否可以不存储此项，仅存储

y

？

中的不同项目，尝试以下操作：

function getArraysDiff(arr1, arr2) {
   var x = arr1.map(function(a) { return a.join("") });
   var y = arr2.map(function(a) { return a.join("") });
   var z = [];

   for ( var i = 0, l = arr1.length; i < l; i++ ) {
      if ( y.indexOf(x[i]) == -1 ) {
        z.push(arr1[i])
      }
   }

   return z;
}

---

您可以使用此函数

arrayDiff

它接受两个数组（A和B），并返回第一个数组中而不是第二个数组（A\B）中的所有元素的数组，并删除所有重复项。如果两个数组元素的JSON序列化相同，则它们相等

var x = [[292,"2349","902103","9"],[3289,"93829","092","920238"]];
var y = [[292,"2349","902103","9"],[322,"93829","092","920238"],[924,"9320","8932","4329"]];

var z = arrayDiff(y, x);

// z is [[322,"93829","092","920238"],[924,"9320","8932","4329"]]

// arrayDiff :: [a], [a] -> [a]
function arrayDiff(a1, a2) {
    let a1Set = toStringSet(a1),
        a2Set = toStringSet(a2);

    return Array.from(a1Set)
                .filter(jsonStr => !a2Set.has(jsonStr))
                .map(JSON.parse);

    // toStringSet :: [a] -> Set<String>
    function toStringSet(arr) {
        return new Set(arr.map(JSON.stringify));
    }
}

var x=[[292,2349,902103,9”]，[3289,93829,092,920238”]；
变量y=[[292,2349,902103,9”]，[322,93829,092,920238”]，[924,9320,8932,4329”]；
var z=arrayDiff（y，x）；
//z是[[322”，“93829”，“092”，“920238”]，[924”，“9320”，“8932”，“4329”]
//arrayDiff:：[a]，[a]->[a]
函数arrayDiff（a1，a2）{
设a1Set=toStringSet（a1），
a2Set=toStringSet（a2）；
返回数组.from（a1Set）
.filter（jsonStr=>！a2Set.has（jsonStr））
.map（JSON.parse）；
//toStringSet:：[a]->Set
功能到字符串集（arr）{
返回新集合（arr.map（JSON.stringify））；
}
}

即使内部数组中的顺序不同，此操作也应有效。
我假设这里只有数字和字符串，你不希望它们之间有严格的比较

var x = [[292,"2349","902103","9"],[3289,"93829","092","920238"]];
var y = [[292,"2349","902103","9"],[322,"93829","092","920238"],[924,"9320","8932","4329"]];

// this will do y \ x
var z = arrDiff(y, x);
console.log(z);


function arrDiff(arr1, arr2) {
  var rez = [];

  for (var i = 0; i < arr1.length; i++) {
    if ( ! contains(arr2, arr1[i])) {
      rez.push(arr1[i]);
    }
  }

  return rez;
}

function contains(arr, x) {
  x = x.slice().sort().toString();
  for (var i = 0; i < arr.length; i++) {
    // compare current item with the one we are searching for        
    if (x === arr[i].slice().sort().toString()) {
      return true;
    }
  }

  return false;
}

var x=[[292,2349,902103,9”]，[3289,93829,092,920238”]；
变量y=[[292,2349,902103,9”]，[322,93829,092,920238”]，[924,9320,8932,4329”]；
//这将完成y\x
var z=arrDiff（y，x）；
控制台日志（z）；
函数arrDiff（arr1、arr2）{
var-rez=[]；
对于（变量i=0；i

您可以使用

Array.prototype.forEach（）

，

Array.prototype.each（）

，

Array.prototype.map（）

，

Array.prototype.indexOf（）

，

JSON.stringify（）

，

JSON.parse（）

var x=[
[292, "2349", "902103", "9"],
[3289, "93829", "092", "920238"]
];
变量y=[
[292, "2349", "902103", "9"],
[322, "93829", "092", "920238"],
[924, "9320", "8932", "4329"]
];
var z=[]；
y、 forEach（功能（val，键）{
var curr=JSON.stringify（val）；
var match=x.every（函数（v，k）{
返回JSON.stringify（v）！==curr
});
如果（匹配和z.indexOf（当前）==-1）z.push（当前）
});
z=z.map（JSON.parse）；
控制台日志（z）；
document.querySelector（“pre”）.textContent=JSON.stringify（z，null，2）

---

使用一个高阶函数，该函数接受一个数组（随着

y

的每次迭代而变化），并返回一个新函数，该函数对

部分中的每个元素（嵌套数组）进行操作。如果数组包含相同的元素，则无论顺序如何，它都返回
true

function finder(x, y) {
  return y.filter(function (el) {
    return !x.some(matches(el));
  });
}

finder(x, y);

迭代
y
并返回不在
x
中的数组列表

var x = [[292,"2349","902103","9"],[3289,"93829","092","920238"]];
var y = [[292,"2349","902103","9"],[322,"93829","092","920238"],[924,"9320","8932","4329"]];

您有两个阵列：

function createZ(){
  var i,j,k=0,z=[],p=x;
  for(j=0;j<y.length;j++){
    for(i=0;i<p.length;i++){
      if(y[j][0]===p[i][0] && y[j][1]===p[i][1] && y[j][2]===p[i][2] && y[j][3]===p[i][3]){
        p.splice(i,1); break;
      } else {
        z[k++]=y[j]; console.log((y[j][0]===p[i][0])+" "+i+","+j);
      }
    }
  }
  return z;
}

要创建Z阵列，需要以下函数：

函数createZ（）{
变量i，j，k=0，z=[]，p=x；
对于（j=0；j），内部数组是否始终包含字符串和数字？它们将始终采用这种格式（始终以相同的顺序）：[int，“str”，“str”，“str”]。那么INT需要不同？这就足够了吗？可能的重复不是重复。问题是比较只包含原语（如数字或字符串）的数组，而问题是比较包含其他数组的数组。如果无法保证内部数组的排序顺序相同，该怎么办n双方？@GregW你能澄清一下订单是否有保证吗？@fahadash我想他可以在连接之前做一个.sort（）
x=[[2922349]]，y=[[2922349]]
在这里被认为是相等的…使用
连接是肮脏的。它们不是-这是重点-但您的算法将假定它们是相等的，因为内部数组在连接时都计算为
“2922349”
查找器中的
.reduce
是否与
过滤器中的
.filter
有任何不同？在本例中不是这样。我在答案中添加了一个编辑。这可能不会影响OP的用例，但对于两个子数组，您的
matches
函数将返回true，这两个子数组中的项顺序不同：
匹配（[1，'2'，3']）（['3'，1，'2']）===true
。如果第一个数组中有额外的项，它也将返回true:
匹配（[1,4,2,3,5,6']）（['3,1,2']）===true
。OP在其评论中澄清了第一点，但您对第二点的看法是正确的，我已经更新了代码以反映这一点，cheers@NoahFreitas。您还可以使用而不是
.indexOf（）
来确定数组是否包含特定元素。
function matches(outer) {
  return function (el) {
    if (outer.length !== el.length) return false;
    return el.every(function (x) {
      return outer.indexOf(x) > -1;
    });
  }
}

function finder(x, y) {
  return y.filter(function (el) {
    return !x.some(matches(el));
  });
}

finder(x, y);

var x = [[292,"2349","902103","9"],[3289,"93829","092","920238"]];
var y = [[292,"2349","902103","9"],[322,"93829","092","920238"],[924,"9320","8932","4329"]];

function createZ(){
  var i,j,k=0,z=[],p=x;
  for(j=0;j<y.length;j++){
    for(i=0;i<p.length;i++){
      if(y[j][0]===p[i][0] && y[j][1]===p[i][1] && y[j][2]===p[i][2] && y[j][3]===p[i][3]){
        p.splice(i,1); break;
      } else {
        z[k++]=y[j]; console.log((y[j][0]===p[i][0])+" "+i+","+j);
      }
    }
  }
  return z;
}