查找多个 JavaScript 数组之间的匹配项
Finding matches between multiple JavaScript Arrays
我有多个带有字符串值的数组，我想比较它们，只保留它们之间相同的匹配结果。
给定此示例代码：
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza'];
var arr3 = ['banana', 'pizza', 'fish', 'apple'];
我想生成以下数组，其中包含所有给定数组的匹配项：
['apple', 'fish', 'pizza']
我知道我可以将所有数组与var newArr = arr1.concat(arr2, arr3);组合在一起，但这只会给我一个包含所有内容的数组，再加上重复项。 这是否可以轻松完成，而不需要库（如 underscore.js）的开销？
（太好了，现在我也饿了！
编辑我想我应该提到可能有未知数量的数组，我只是以 3 为例。
var result = arrays.shift().filter(function(v) {
return arrays.every(function(a) {
return a.indexOf(v) !== -1;
});
});
演示：http://jsfiddle.net/nWjcp/2/
您可以先对外部数组进行排序，以获得开头最短的数组...
arrays.sort(function(a, b) {
return a.length - b.length;
});
为了完整起见，这里有一个处理数组中重复项的解决方案。它使用.reduce()而不是.filter()...
var result = arrays.shift().reduce(function(res, v) {
if (res.indexOf(v) === -1 && arrays.every(function(a) {
return a.indexOf(v) !== -1;
})) res.push(v);
return res;
}, []);
演示：http://jsfiddle.net/nWjcp/4/
假设有一个数组数组，我们想要找到它们的交集，最简单的单行方法可能是
var arr = [[0,1,2,3,4,5,6,7,8,9],[0,2,4,6,8],[4,5,6,7]],
int = arr.reduce((p,c) => p.filter(e => c.includes(e)));
document.write("<pre>" + JSON.stringify(int) + "</pre>");现在，您已经向问题添加了不确定数量的数组，下面是另一种方法，该方法将每个项目的计数收集到一个对象中，然后整理具有最大计数的项目。
这种方法的优点：
- 如果数组较大，则比暴力搜索选项（由其他答案使用）快 ~15 倍 不需要 ES5
- 或 ES5 填充程序（适用于所有浏览器）
- 完全无损（根本不更改源数据）
- 处理源数组中的重复项
- 处理任意数量的输入数组
这是代码：
function containsAll(/* pass all arrays here */) {
var output = [];
var cntObj = {};
var array, item, cnt;
// for each array passed as an argument to the function
for (var i = 0; i < arguments.length; i++) {
array = arguments[i];
// for each element in the array
for (var j = 0; j < array.length; j++) {
item = "-" + array[j];
cnt = cntObj[item] || 0;
// if cnt is exactly the number of previous arrays,
// then increment by one so we count only one per array
if (cnt == i) {
cntObj[item] = cnt + 1;
}
}
}
// now collect all results that are in all arrays
for (item in cntObj) {
if (cntObj.hasOwnProperty(item) && cntObj[item] === arguments.length) {
output.push(item.substring(1));
}
}
return(output);
}
工作演示：http://jsfiddle.net/jfriend00/52mAP/
仅供参考，这不需要 ES5，因此可以在没有垫片的所有浏览器中工作。
在对 15 个数组（每个数组 1000 个）进行的性能测试中，这比 am not i am 在这个 jsperf 中使用的搜索方法快 10 倍以上：http://jsperf.com/in-all-arrays。
这是一个使用 ES6 Map和Set来取消重复并跟踪计数的版本。 这样做的好处是，数据类型被保留下来，可以是任何东西（它甚至不必有自然的字符串转换，数据甚至可以是对象，尽管对象被比较为完全相同的对象，不具有相同的属性/值）。
var arrays = [
['valueOf', 'toString','apple', 'orange', 'banana', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza', 1, 2, 999, 888],
['valueOf', 'toString','taco', 'fish', 'fish', 'apple', 'pizza', 1, 999, 777, 999, 1],
['valueOf', 'toString','banana', 'pizza', 'fish', 'apple', 'apple', 1, 2, 999, 666, 555]
];
// subclass for updating cnts
class MapCnt extends Map {
constructor(iterable) {
super(iterable);
}
cnt(iterable) {
// make sure items from the array are unique
let set = new Set(iterable);
// now update the cnt for each item in the set
for (let item of set) {
let cnt = this.get(item) || 0;
++cnt;
this.set(item, cnt);
}
}
}
function containsAll(...allArrays) {
let cntObj = new MapCnt();
for (array of allArrays) {
cntObj.cnt(array);
}
// now see how many items have the full cnt
let output = [];
for (var [item, cnt] of cntObj.entries()) {
if (cnt === allArrays.length) {
output.push(item);
}
}
return(output);
}
var result = containsAll.apply(this, arrays);
document.body.innerHTML = "<pre>[<br> " + result.join(',<br> ') + "<br>]</pre>";几个想法 - 您可以只比较最短数组中的项目，并防止返回的数组中出现重复项。
function arraysInCommon(arrays){
var i, common,
L= arrays.length, min= Infinity;
while(L){
if(arrays[--L].length<min){
min= arrays[L].length;
i= L;
}
}
common= arrays.splice(i, 1)[0];
return common.filter(function(itm, indx){
if(common.indexOf(itm)== indx){
return arrays.every(function(arr){
return arr.indexOf(itm)!= -1;
});
}
});
}
var arr1= ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2= ['taco', 'fish', 'apple', 'pizza', 'apple','apple'];
var arr3= ['banana', 'pizza', 'fish', 'apple','fish'];
var allArrays = [arr1,arr2,arr3];
arraysInCommon(allArrays).sort();
返回值：apple,fish,pizza
演示 - http://jsfiddle.net/kMcud/
// The easiest way!!
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza'];
var arr3 = ['banana', 'pizza', 'fish', 'apple'];
var arr4 = [];
for(let i of arr1){
if(arr2.includes(i) && arr3.includes(i)){
arr4.push(i)
}
}
console.log(arr4)
------------- OR -----------------
arr4 = arr1.filter(value => arr2.includes(value) && arr3.includes(value))
假设数组数组并检查所有数组：
演示：http://jsfiddle.net/qUQHW/
var tmp = {};
for (i = 0; i < data.length; i++) {
for (j = 0; j < data[i].length; j++) {
if (!tmp[data[i][j]]) {
tmp[data[i][j]] = 0;
}
tmp[data[i][j]]++;
}
}
var results = $.map(tmp, function(val,key) {
return val == data.length ? key :null;
})
这里有一个单行解决方案。您可以将其分为两个思考步骤：
- 计算两个数组之间的连接/交集
var arrA = [1,2,3,4,5];
var arrB = [4,5,10];
var innerJoin = arrA.filter(el=>arrB.includes(el));
console.log(`Intersection is: ${innerJoin}`);- 减少内容：计算累积的交点和下一个数组之间的交点。
var arrays = [
['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'],
['taco', 'fish', 'apple', 'pizza'],
['banana', 'pizza', 'fish', 'apple']
];
var join = arrays.reduce((join, current) => join.filter(el => current.includes(el)));
console.log(`Intersection is: ${join}`);这应该适用于任意数量的数组：
function intersection(arr1, arr2) {
var temp = [];
for (var i in arr1) {
var element = arr1[i];
if (arr2.indexOf(element) > -1) {
temp.push(element);
}
}
return temp;
}
function multi_intersect() {
var arrays = Array.prototype.slice.apply(arguments).slice(1);
var temp = arguments[0];
for (var i in arrays) {
temp = intersection(arrays[i], temp);
if (temp == []) {
break;
}
}
return temp;
}
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza'];
var arr3 = ['banana', 'pizza', 'fish', 'apple'];
multi_intersect(arr1, arr2, arr3);
只是为了它，另一种长手方法：
function getCommon(a) {
// default result is copy of first array
var result = a[0].slice();
var mem, arr, found = false;
// For each member of result, see if it's in all other arrays
// Go backwards so can splice missing entries
var i = result.length;
while (i--) {
mem = result[i];
// Check in each array
for (var j=1, jLen=a.length; j<jLen; j++) {
arr = a[j];
found = false;
// For each member of arr and until found
var k = arr.length;
while (k-- && !found) {
// If found in this array, set found to true
if (mem == arr[k]) {
found = true;
}
}
// if word wasn't found in this array, remove it from result and
// start on next member of result, skip remaining arrays.
if (!found) {
result.splice(i,1);
break;
}
}
}
return result;
}
var data = [
['taco', 'fish', 'apple', 'pizza', 'mango', 'pear'],
['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'],
['banana', 'pizza', 'fish', 'apple'],
['banana', 'pizza', 'fish', 'apple', 'mango', 'pear']
];
编辑
在 Object.prototype 上查找基于此属性的永不枚举属性的函数：
// Return an array of Object.prototype property names that are not enumerable
// even when added directly to an object.
// Can be helpful with IE as properties like toString are not enumerable even
// when added to an object.
function getNeverEnumerables() {
// List of Object.prototype property names plus a random name for testing
var spNames = 'constructor toString toLocaleString valueOf ' +
'hasOwnProperty isPrototypeOf propertyIsEnumerable foo';
var spObj = {foo:'', 'constructor':'', 'toString':'', 'toLocaleString':'', 'valueOf':'',
'hasOwnProperty':'', 'isPrototypeOf':'', 'propertyIsEnumerable':''};
var re = [];
// BUild list of enumerable names in spObj
for (var p in spObj) {
re.push(p);
}
// Remove enumerable names from spNames and turn into an array
re = new RegExp('(^|''s)' + re.join('|') + '(''s|$)','g');
return spNames.replace(re, ' ').replace(/(^'s+)|'s's+|('s+$)/g,'').split(' ');
}
document.write(getNeverEnumerables().join('<br>'));
这本质上是所有答案的汇编：
// Intersect any number of arrays:
function intersect() {
// - Arguments -> traditional array,
// - First item ( arrays[0] ) = shortest to reduce iterations
var arrays = Array.prototype.slice.call(arguments).sort(function(a, b) {
return a.length - b.length;
});
// Use first array[0] as the base.
var a = arrays.shift();
var result = [];
for (var i = a.length; i--;) {
var val = a[i];
// Prevent duplicates
if (result.indexOf(val) < 0) {
// Seek
var found = true;
for (var ii = arrays.length; ii--;) {
if (arrays[ii].indexOf(val) < 0) {
found = false;
break;
}
}
if (found) {
result.push(val);
}
}
}
return result;
}
/*
// Slower, but smaller code-base:
function intersect (){
// - Arguments -> traditional array,
// - First item ( arrays[0] ) = shortest to reduce iterations
var arrays = Array.prototype.slice.call(arguments).sort(function(a, b) {
return a.length - b.length;
});
// Use first array[0] as the base.
var a = arrays.shift();
return a.filter(function (val, idx, aa) {
// Seek
for(var i=arrays.length; i--;){
if (arrays[i].indexOf(val) < 0) {
return false;
}
}
// Prevent duplicates
return aa.indexOf(val) === idx;
});
}
*/
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza', 'apple', 'apple'];
var arr3 = ['banana', 'pizza', 'fish', 'apple', 'fish'];
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza', 'apple', 'apple'];
var arr3 = ['banana', 'pizza', 'fish', 'apple', 'fish'];
var result = intersect(arr1, arr2, arr3);
// For fiddle output:
var elem = document.getElementById("result");
elem.innerHTML = JSON.stringify(result);
console.log(result);<div id="result">Results</div>您可以使用
array#reduce和array#filter。对于每个数组，获取所有唯一值，并在Map查找中保留其计数。完成后，根据数组的长度array#filter此查找。
const commonElements = (...arr) => {
const lookup = arr.reduce((map, a) => {
const unique = [...new Set(a)];
unique.forEach(v => {
map.set(v, (map.get(v) || 0) + 1)
});
return map;
},new Map());
return [...lookup.keys()].filter(k => lookup.get(k) === arr.length);
}
const arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'],
arr2 = ['taco', 'fish', 'apple', 'pizza'],
arr3 = ['banana', 'pizza', 'fish', 'apple'];
console.log(commonElements(arr1,arr2,arr3));另一个解决方案：
const arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
const arr2 = ['taco', 'fish', 'apple', 'pizza'];
const arr3 = ['banana', 'pizza', 'fish', 'apple'];
const combinedArr = [arr1, arr2, arr3];
const result = combinedArr
.flatMap(([...values]) => values)
.filter((value, index, coll) => (coll.indexOf(value) === index) && combinedArr.every(
(values) => values.includes(value)
));
console.log(result);.as-console-wrapper { max-height: 100% !important; top: 0; }此方法计算每个项目的数量。 迭代所有数组后，将选择等于数组数的计数。
为了通用，该函数接受数组数组和比较函数，以便在使用对象而不是基元值的情况下生成映射键。
它返回一个通用值数组，使用第一个数组中的实例作为引用。
function commonValues<T>(arrays: T[][], keyFn: (item: T) => string): T[] {
const counts: Record<any, { count: number, item: T }> = {}
for (const array of arrays) {
for (const item of array) {
const key = keyFn(item)
let entry = counts[key]
if (!entry) {
entry = {count: 0, item}
counts[key] = entry
}
entry.count++
}
}
return Object.values(counts)
.filter(it => it.count === arrays.length)
.map(it => it.item)
}
对于这个基本示例，key 函数只返回字符串。
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza'];
var arr3 = ['banana', 'pizza', 'fish', 'apple'];
const common = commonItems([arr1,arr2,arr3], it=>it)
function commonValues(arrays, keyFn) {
const counts = {}
for (const array of arrays) {
for (const item of array) {
const key = keyFn(item)
let entry = counts[key]
if (!entry) {
entry = {count: 0, item}
counts[key] = entry
}
entry.count++
}
}
return Object.values(counts)
.filter(it => it.count === arrays.length)
.map(it => it.item)
}
var arr1 = ['apple', 'orange', 'banana', 'pear', 'fish', 'pancake', 'taco', 'pizza'];
var arr2 = ['taco', 'fish', 'apple', 'pizza'];
var arr3 = ['banana', 'pizza', 'fish', 'apple'];
const found = commonValues([arr1,arr2,arr3], it=>it)
console.log('common', found)相关文章：
- 在 JavaScript 数组中的所有元素之间穿插元素的简洁方法
- 效率:整数数组的一个子集中两个项之间的最大差值
- 使用Javascript获取两个字符串之间的字符串数组
- 如何将json文件中的数据提取到对象数组中，并在两个控制器之间共享
- 尝试在一个对象的值和一个对象数组之间进行匹配
- 在angularJS中使用模态窗口时，在控制器之间共享对象数组
- 无法在提交之间清空数组
- 使用工厂/服务在控制器AngularJS之间推送数组中的数据
- 数组和ArrayBuffer之间的区别是什么
- 只有一些带undercore.js的字段在对象数组之间求交集和等于
- 如何在数组中循环，等待每个项目之间的时间
- 在数组中的偶数之间插入连字符
- 创建新数组和清除长度之间的差异
- 如何循环数组并保持它们之间的索引增长
- for(数组中的i）和for(var i=0;i<array.length;i++）之间的差异
- 在javascript数组元素之间添加换行符
- 我如何获得 Javascript 中关联数组和常规数组之间的区别
- 如何确定数组中的值是否位于两个附加数组的所有并行索引的值之间
- 数组值和字符串之间的 JavaScript 比较
- AngularJS控制器语法 - 数组和函数版本之间的差异
