Javascript很新，我在大约一个月的时间里尝试过这个问题大约4次，我仍然无法解决它。
所以这是一个问题： 构造一个函数交集，它比较输入数组并返回一个新数组，其中包含在所有输入中找到的元素。奖励：使用reduce！
格式为：
function intersection(arrays) {
// Your Code Goes Here
}
测试用例：应记录[15,5]
console.log('Extensions 3 Test: ' + intersection([5, 10, 15, 20], [15, 88, 1, 5, 7]/*, [1, 10, 15, 5, 20]*/));
我当前的解决方案：适用于只有两个项目要比较的情况，但不适用于第三个项目，我可以做到这样我会循环并将获得的值与下一个数组进行比较但我不会＃39 ;我认为我正走在正确的道路上......而且，我并没有使用reduce来实现它......而且我不确定我是否应该使用＆＃39;论证。＆＃39;任何帮助表示赞赏！非常感谢你。
function intersection(arrays) {
array = [];
for (var i = 0; i < arguments.length; i++)
array.push(arguments[i]);
var result = [];
for(var i = 0; i < array.length - 1; i++) {
for(var j = 0; j < array[i].length; j++) {
if (array[i+1].includes(array[i][j]))
result.push(array[i][j]);
}
}
return result;
}
答案 0 :(得分：3)
虽然有几条建议说，你可以使用 underscore ， lodash 或我个人最喜欢的 {{3 }} （免责声明：我是其中一位作者），这个函数应该很简单，你甚至不会考虑它的库。这是一个简单的版本：
const intersection = (xs, ys) => xs.filter(x => ys.indexOf(x) > -1);
intersection([5, 10, 15, 20, 3], [15, 88, 3, 1, 5, 7]); //=> [5, 15, 3]
const intersectAll = (...xss) => xss.reduce(intersection);
intersectAll([5, 10, 15, 20, 3], [15, 88, 3, 1, 5, 7], [1, 10, 15, 5, 20]); //=> [5, 15]
我认为这就是你所需要的，至少只要你只担心参考/原始平等而不需要考虑你想知道{x: 1}和{{的情况。 1}}是相同的，即使它们不是相同的参考。如果确实需要，可以查看Ramda的Ramda函数。
请注意，如果{x: 1} intersection ，我建议使用此版本，因为它更好：
includes此外，如果您不需要二进制函数，可以通过组合上述两个函数来制作它的可变版本：
const intersection = (xs, ys) => xs.filter(x => ys.includes(x));
答案 1 :(得分：2)
也许有人会发现它有用。
作为函数的参数，您可以给出任意长度的任意数量的数组，并且函数很紧凑；）
const findSimilar = (...arrays) => {
return arrays.reduce((includ, current) =>
Array.from(new Set(includ.filter((a) => current.includes(a))))
);
};
console.log(
findSimilar([5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20])
);
及其工作方式：
好的，首先您将rest parameters（... arrays）作为函数的参数，所以您有了
数组= [[5，10，15，20]，[15，88，1，5，7]，[1，10，15，5，20]]
然后在reduce的第一次迭代中，我们有了
包括= [5、10、15、20]和电流= [15、88、1、5、7]
在这两个函数上，我们使用filter，这给了我们[5,15]，我使用Set来确保没有重复，并返回数组（Array.from()），这被传递给reduce的下一个迭代为“包含”，在下一个迭代中，我们有
包括= [5,15]和电流= [1、10、15、5、20]等...
我们甚至可以像这样使用它
let result = [
[5, 10, 15, 20],
[15, 88, 1, 5, 7],
[1, 10, 15, 5, 20]
].reduce((includ, current) =>
Array.from(new Set(includ.filter((a) => current.includes(a))))
);
console.log(result);
答案 2 :(得分：1)
虽然没有直接解决您的问题，但您可以使用开源库underscore.js执行您尝试执行的操作。
_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]
您或许可以从实施的方式中获得灵感。以上是函数调用它们自己的_.intersection函数，它也依赖于其他underscore.js函数，如下所示：
// Produce an array that contains every item shared between all the
// passed-in arrays.
_.intersection = function(array) {
if (array == null) return [];
var result = [];
var argsLength = arguments.length;
for (var i = 0, length = array.length; i < length; i++) {
var item = array[i];
if (_.contains(result, item)) continue;
for (var j = 1; j < argsLength; j++) {
if (!_.contains(arguments[j], item)) break;
}
if (j === argsLength) result.push(item);
}
return result;
};
答案 3 :(得分：1)
这是一个使用reduce的解决方案，将空数组作为交集作为初始值传入。
迭代数字并检查每个数字是否出现在其中一个子数组中。
如果没有，请将布尔值isPresentInAll设置为false。
如果它确实出现在所有三个中，并且它不存在于 交叉点数组，然后推送到交集数组。
{{1}}
答案 4 :(得分：0)
我想我能为你找到合适的功能。 （注意：结果没有排序！）
var intersection = function() {
// merge deduped arrays from arguments
var arrays = Array.prototype.reduce.call(arguments, function(carry, array) {
return [].concat(carry, array.filter(function(item, index, origin) {
return origin.indexOf(item) === index;
}));
}, []);
var results = arrays.reduce(function(carry, item, index, arr) {
if(
// just select items, which have more then 1 occurance
arr.filter(function(fItem) {
return fItem === item;
}).length > 1 &&
// ... and which are not already in results
!~carry.indexOf(item)
) {
carry = [].concat(carry,item);
}
return carry;
}, []);
return results;
};
答案 5 :(得分：0)
这是一个使用2的版本减少。
第一个迭代数组只创建一个hashmap对象来跟踪实例计数，第二个返回值，其中count与参数数量相匹配
function intersection(){
// convert arguments to array of arrays
var arrays = [].slice.call(arguments);
// create an object that tracks counts of instances and is type specific
// so numbers and strings would not be counted as same
var counts= arrays.reduce(function(a,c){
// iterate sub array and count element instances
c.forEach(function(val){
var propName = typeof val + '|' + val;
// if array value not previously encountered add a new property
a[propName] = a[propName] || {count:0, value: val};
// increment count for that property
a[propName].count++;
});
return a;
},{});
// iterate above object to return array of values where count matches total arrays length
return Object.keys(counts).reduce(function(resArr, propName){
if(counts[propName].count === arrays.length){
resArr.push(counts[propName].value);
}
return resArr;
},[]);
}
console.log(intersection([5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20]))
可以使用一些微调来确保有足够的参数并且它们都是数组
答案 6 :(得分：0)
以下是我使用vanilla javascript和一次调用reduce来实现的目标。
function intersection(){
var arrays = [].slice.call(arguments);
var first = arrays[0];
var rest = arrays.slice(1);
return first.reduce(function(all, item, index){
var push = rest.every(function(subArray){
return subArray.indexOf(item) > -1;
});
if(push){
all.push(item);
}
return all;
},[])
}
console.log(intersection([5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20]));
答案 7 :(得分：0)
function intersection(arrays) {
let common = arrays.reduce(function(accumulator, currentValue) {
return accumulator.filter(function(x){
return currentValue.indexOf(x) > -1;
})
})
return common;
}
答案 8 :(得分：0)
要优化您的答案，该答案不能在两个以上的子数组上使用并且不使用reduce，那么以下代码可用于您传入的许多子数组。
function intersection(arr1, arr2, arr3){
let ans = arr1[0]; // ans = [5,10,15,20]
for(let i = 0; i < ans.length; i++){ // i = 0...3
for(let j = 1; j < arr1.length; j++){ // j = 1...2
if(!(arr1[j].includes(ans[i]))){ // if the new subarray doesn't include an element in the ans
ans.splice(i, 1); // delete the element from ans
}
}
}
return ans;
}
const arr1 = [5, 10, 15, 20];
const arr2 = [15, 88, 1, 5, 7];
const arr3 = [1, 10, 15, 5, 20];
console.log(intersection([arr1, arr2, arr3])); // should log: [5, 15]