Javascript 获取项目内容'；s不在第二、第三阵列上-JS

我正在尝试创建一个函数，该函数将获取在函数中传递的第2或第3个以及后续数组上看不到的项

现在，我的函数只得到类似的项。我如何才能使其获得差异（w/c是第二和第三阵列以及后续阵列中不存在的项目）

const callM = function(arrays) {
   arrays = Array.prototype.slice.call(arguments);


   let result = [];

  for(let i = 1; i < arrays.length; i++){
    for(let x = 0; x < arrays[i].length; x++){
      if(arrays[0].includes(arrays[i][x])){
        result.push(arrays[i][x]);
      }
    }
  }

  return result;

  };

console.log(callM([1, 2, 3, 4, 5], [5, 2, 10])); // -> must be [1, 3, 4]
console.log(callM([1, 2, 3, 4, 5], [5, 2, 10], [7, 1, 8])); // -> must be [3,4]

const callM=函数（数组）{
arrays=Array.prototype.slice.call（参数）；
让结果=[]；
for（设i=1；i必须是[1,3,4]
log（callM（[1,2,3,4,5]，[5,2,10]，[7,1,8]）；//->必须是[3,4]

现在的逻辑有点不正确，因为情况正好相反。我该如何解决这个问题

还有没有一种方法可以使用高阶函数来实现这一点，例如reduce或filter

---

谢谢！

如果您愿意使用下划线，只需一行代码即可：

console.log(_.difference([1, 2, 3, 4, 5], [5, 2, 10], [7, 1, 8]))

---

我会以不同的方式思考这个问题。作为两个集合之间的区别：数组0和数组1…n

要获得数组0，只需将其从顶部移开即可

const arr0 = arrays.shift()

参考：

这将从数组中删除第一个数组 接下来，我们合并其余的数组

const arrN = arrays.reduce(function(prev, curr) {
  return prev.concat(curr)
})

参考：

不需要，由@Phil提到的

处理，包括

下一个过滤器通过与自身比较从arrN复制

const unique = arrN.filter(function(elem, index, self) {
    return index == self.indexOf(elem);
})

参考：

下一个过滤器包含查找差异（或联合）

完整片段：

函数调用m（数组）{
常量arr0=arrays.shift（）
const arrN=arrays.reduce（函数（prev，curr）{
返回上一个concat（当前）
})
//const unique=arrN.filter（函数（元素、索引、自身）{
//返回索引==self.indexOf（elem）
//})
返回arr0.filter（函数（项）{
退货！到货包括（项目）
})
}
log（callM（[[1,2,3,4,5]，[5,2,10]]））
log（callM（[[1,2,3,4,5]，[5,2,10]，[7,1,8]]）

您可以使用

array#reduce

创建除第一个数组之外的所有其他数组的对象查找。然后使用

array#filter

获取对象查找中不存在的值

var callM=（第一，…剩余）=>{
var组合=剩余
.reduce（（res，arr）=>res.concat（arr））
.减少（（o，v）=>{
o[v]=真；
返回o；
},{}); 
先返回
.filter（v=>！组合[v]）；
}
log（callM（[1,2,3,4,5]，[5,2,10]）；//->必须是[1,3,4]
log（callM（[1,2,3,4,5]，[5,2,10]，[7,1,8]）；/->必须是[3,4]

排除值的“正确”方法通常是使用一个包含要排除的值的查找哈希集：

const callM=（a，…b）=>（b=新集合（b.concat.apply（…b）），a.filter（v=>！b.has（v）））
log（callM（[1,2,3,4,5]，[5,2,10]）；//[1,3,4]
log（callM（[1,2,3,4,5]，[5,2,10]，[7,1,8]）；//[3,4]

适用于中小型阵列的简短解决方案：

//返回数组中的元素，但不返回筛选器中的元素：
函数差异（数组，…过滤器）{
返回array.filter（el=>！filters.some（filter=>filter.includes（el））；
}
//例如：
log（差异（[1,2,3,4,5]，[5,2,10]）；//[1,3,4]
console.log（区别（[1,2,3,4,5]，[5,1,10]，[7,2,8]）；//[3,4]

关于这个

console.log（callM（[1,2,3,4,5]，[5,2,10]）；//->必须是[1,3,4]，

结果不应该是

[1,3,4,10]

如果该项不存在于任何数组中，那么差异的类型是什么？实际上不存在。我们在这里只检查数组[0]，其他数组上不存在的内容。例如[1,2,3,4,5]->显然[1,3,4]在[5,2,10]上不存在，所以我们只关心检查数组[0]这里，我们不关心数组2…3…等等。然后这应该输出

console.log（callM（[1,2,3,4,5]，[5,2,10]，[7,1,8]）；

将是

[3,4]

这不是一个很好的答案，但我觉得将组合数组减少到它们的唯一值是浪费精力。不了解include的工作方式。这已经涵盖了DUP。感谢您的评论。更改它的内容非常

arr.indexOf（v）！=-1

const diff = arr0.filter(function(item) {
    return !arrN.includes(item))
}