我有一个目标数组[“apple”、“banana”、“orange”],我想检查其他数组是否包含任何一个目标阵列元素。
例如:
["apple","grape"] //returns true;
["apple","banana","pineapple"] //returns true;
["grape", "pineapple"] //returns false;
如何在JavaScript中实现?
我有一个目标数组[“apple”、“banana”、“orange”],我想检查其他数组是否包含任何一个目标阵列元素。
例如:
["apple","grape"] //returns true;
["apple","banana","pineapple"] //returns true;
["grape", "pineapple"] //returns false;
如何在JavaScript中实现?
当前回答
console.log("searching Array: "+finding_array);
console.log("searching in:"+reference_array);
var check_match_counter = 0;
for (var j = finding_array.length - 1; j >= 0; j--)
{
if(reference_array.indexOf(finding_array[j]) > 0)
{
check_match_counter = check_match_counter + 1;
}
}
var match = (check_match_counter > 0) ? true : false;
console.log("Final result:"+match);
其他回答
如果不需要类型强制(因为使用了indexOf),可以尝试以下方法:
var arr = [1, 2, 3];
var check = [3, 4];
var found = false;
for (var i = 0; i < check.length; i++) {
if (arr.indexOf(check[i]) > -1) {
found = true;
break;
}
}
console.log(found);
其中arr包含目标项。最后,find将显示第二个数组是否与目标至少匹配一次。
当然,您可以将数字换成任何您想要使用的东西-字符串很好,就像您的示例一样。
在我的具体示例中,结果应该为真,因为目标中存在第二个数组的3。
更新:
以下是我如何将其组织成一个函数(与之前的一些小变化):
var anyMatchInArray = (function () {
"use strict";
var targetArray, func;
targetArray = ["apple", "banana", "orange"];
func = function (checkerArray) {
var found = false;
for (var i = 0, j = checkerArray.length; !found && i < j; i++) {
if (targetArray.indexOf(checkerArray[i]) > -1) {
found = true;
}
}
return found;
};
return func;
}());
演示:http://jsfiddle.net/u8Bzt/
在这种情况下,可以修改函数,使targetArray作为参数传入,而不是在闭包中进行硬编码。
更新2:
虽然我上面的解决方案可能有效,并且(希望更)可读,但我认为处理我描述的概念的“更好”方法是做一些稍微不同的事情。上述解决方案的“问题”是,循环中的indexOf会导致目标数组对另一个数组中的每个项进行完全循环。这可以通过使用“查找”(一个映射…一个JavaScript对象文本)轻松“修复”。这允许在每个数组上进行两个简单的循环。下面是一个示例:
var anyMatchInArray = function (target, toMatch) {
"use strict";
var found, targetMap, i, j, cur;
found = false;
targetMap = {};
// Put all values in the `target` array into a map, where
// the keys are the values from the array
for (i = 0, j = target.length; i < j; i++) {
cur = target[i];
targetMap[cur] = true;
}
// Loop over all items in the `toMatch` array and see if any of
// their values are in the map from before
for (i = 0, j = toMatch.length; !found && (i < j); i++) {
cur = toMatch[i];
found = !!targetMap[cur];
// If found, `targetMap[cur]` will return true, otherwise it
// will return `undefined`...that's what the `!!` is for
}
return found;
};
演示:http://jsfiddle.net/5Lv9v/
这种解决方案的缺点是,只能(正确地)使用数字和字符串(以及布尔值),因为这些值(隐式地)转换为字符串并设置为查找映射的键。对于非文字值,这不是很好/可能/容易做到的。
如果你不反对使用图书馆,http://underscorejs.org/有一种相交方法,可以简化这一点:
var _ = require('underscore');
var target = [ 'apple', 'orange', 'banana'];
var fruit2 = [ 'apple', 'orange', 'mango'];
var fruit3 = [ 'mango', 'lemon', 'pineapple'];
var fruit4 = [ 'orange', 'lemon', 'grapes'];
console.log(_.intersection(target, fruit2)); //returns [apple, orange]
console.log(_.intersection(target, fruit3)); //returns []
console.log(_.intersection(target, fruit4)); //returns [orange]
交集函数将返回一个包含匹配项的新数组,如果不匹配,则返回空数组。
添加到阵列原型
免责声明:许多人强烈建议不要这样做。唯一真正有问题的是,如果一个库添加了一个同名(行为不同)的原型函数或类似的东西。
代码:
Array.prototype.containsAny = function(arr) {
return this.some(
(v) => (arr.indexOf(v) >= 0)
)
}
不使用大箭头功能:
Array.prototype.containsAny = function(arr) {
return this.some(function (v) {
return arr.indexOf(v) >= 0
})
}
用法
var a = ["a","b"]
console.log(a.containsAny(["b","z"])) // Outputs true
console.log(a.containsAny(["z"])) // Outputs false
嵌套调用.find()的Array.filter()将返回第一个数组中属于第二个数组的所有元素。检查返回数组的长度,以确定第一个数组中是否有第二个数组。
getCommonItems(firstArray, secondArray) {
return firstArray.filter((firstArrayItem) => {
return secondArray.find((secondArrayItem) => {
return firstArrayItem === secondArrayItem;
});
});
}
可以使用嵌套的Array.prototype.some调用。这有一个好处,即它将在第一场比赛中获胜,而不是其他将在整个嵌套循环中运行的解决方案。
eg.
var arr = [1, 2, 3];
var match = [2, 4];
var hasMatch = arr.some(a => match.some(m => a === m));