Javascript 优化ES6阵列交叉功能

我有以下阵列：

this.originalSelectedRows = [1,2,3,4,5];
this.selectedRows = [3,4,5,6,7,8];

我想知道以下几点：

此中有多少个数字。原始选定的箭头

，但不在

此中。选定的箭头

在这种情况下，为2：

1和2

这个.selectedRows中有多少个数字，而不是这个.originalSelectedRows中的数字

在这种情况下，这将是3：

6、7和8

我有以下几点，效果很好：

    let isOnListCount = 0;
    let isNotOnListCount = 0

    this.selectedRows.map((row) => {
      const isSelected = this.originalSelectedRows.filter(x => x === row);
        if(isSelected.length > 0)
          isOnListCount++;
        else
          isNotOnListCount++;
    });

但我想知道，如果使用ES6的一些新功能或原始JS，是否可以以更简洁的方式实现这一点，您可以使用函数检查元素是否存在于第二个数组中

const originalSelectedRows=[1,2,3,4,5]；
const selectedRows=[3,4,5,6,7,8]；
设isOnListCount=0；
让isNotOnListCount=0；
selectedRows.forEach（行=>
原始选定行。包括（行）？isOnListCount++：isNotOnListCount++
);
console.log（isOnListCount）；
console.log（isNotOnListCount）您可以使用函数检查元素是否存在于第二个数组中


const originalSelectedRows=[1,2,3,4,5]；
const selectedRows=[3,4,5,6,7,8]；
设isOnListCount=0；
让isNotOnListCount=0；
selectedRows.forEach（行=>
原始选定行。包括（行）？isOnListCount++：isNotOnListCount++
);
console.log（isOnListCount）；
console.log（isNotOnListCount）集合在这里会做得很好：）

它们也相对较快，但不如精心设计的解决方案快：p

我假设您的所有项目都是唯一的：）
集合在这里会做得很好：）

它们也相对较快，但不如精心设计的解决方案快：p

我假设您的所有项目都是唯一的：）
您可以将长度作为计数器，并使用普通项目减少值


var array1=[1,2,3,4,5]，
array2=[3,4,5,6,7,8]，
count1=阵列1.1长度，
count2=阵列2.长度；
数组1.forEach（函数（a）{
如果（包括（a））{
第1项--；
第二条--；
}
});
console.log（count1，count2）您可以将长度作为计数器，并使用常用项减少值


var array1=[1,2,3,4,5]，
array2=[3,4,5,6,7,8]，
count1=阵列1.1长度，
count2=阵列2.长度；
数组1.forEach（函数（a）{
如果（包括（a））{
第1项--；
第二条--；
}
});
console.log（count1，count2）我会将一个数组转换为一个集合，然后过滤另一个数组中不在集合中的项


const
值a=[1,2,3,4,5]，
valuesB=[3,4,5,6,7,8]；
函数getUniqueValues（sourceArray、testArray）{
常数
集合=新集合（测试阵列）；
返回sourceArray.filter（value=>！set.has（value））；
}
log（`A中的值而不是B中的值：${getUniqueValues（valuesA，valuesB）}`）；
log（`B中的值而不是A中的值：${getUniqueValues（valuesB，valuesA）}`）我将一个数组转换为一个集合，而不是为不在集合中的项过滤另一个数组


const
值a=[1,2,3,4,5]，
valuesB=[3,4,5,6,7,8]；
函数getUniqueValues（sourceArray、testArray）{
常数
集合=新集合（测试阵列）；
返回sourceArray.filter（value=>！set.has（value））；
}
log（`A中的值而不是B中的值：${getUniqueValues（valuesA，valuesB）}`）；
log（`B中的值而不是A中的值：${getUniqueValues（valuesB，valuesA）}`）您可以假定它们通常是排序的吗？您正在查找两个数组之间的差异。这个问题的答案有很多想法，包括使用ES6生成器。如果得到结果3和3，为什么代码工作正常？您能假定它们通常是排序的吗？您正在寻找两个数组之间的差异。这个问题的答案有很多想法，包括使用ES6生成器。如果你得到结果3和3，为什么你的代码工作得很好？我喜欢你的笑容——它们是不是意味着我错过了某种笑话？：-）我真的需要放松一下微笑！该死！我喜欢你的笑容——它们是不是意味着我错过了某种笑话？：-）我真的需要放松一下微笑！该死！可读性比短小的花哨代码更重要。你总是有办法使最简单的逻辑对新程序员来说完全不可理解。特别是
&（count1--，count2--）
是新用户无法识别的<如果
和
（，）
不是它们可以识别的常用结构，则代码>&&
作为快捷方式
。@NinaScholz我知道您希望使用
减少
，并编写更晦涩的代码。你看：
const common=arr.reduce（（result，elt）=>result+array2.includes（elt））。注意我们添加布尔值的巧妙方法。现在的答案是
array1.length-common
和
array2.length-common
@torazaburo，你知道（我希望如此），我可以用reduce风格编写，但在这种情况下（为了保存一行代码）没有必要这样做。可读性比简短的花哨代码更重要。你总是有办法使最简单的逻辑对新程序员来说完全不可理解。特别是
&（count1--，count2--）
是新用户无法识别的<如果
和
（，）
不是它们可以识别的常用结构，则代码>&&

作为快捷方式

。@NinaScholz我知道您希望使用
减少
，并编写更晦涩的代码。你看：
const common=arr.reduce（（result，elt）=>result+array2.includes（elt））。注意我们添加布尔值的巧妙方法。现在答案很简单，就是
array1.length-common
和
array2.length-common
@torazaburo，你知道（我希望如此），我可以用reduce风格写，但是我
let set1 = new Set(this.originalSelectedRows)
let set2 = new Set(this.selectedRows)
let difference = new Set([...set1].filter(n => !set2.has(n)))