如何找到两个数组中的匹配值？

Question

我有两个数组，我希望能够比较两个，只返回匹配的值。例如两个数组的值都是cat，这样就会返回。我还没有找到像这样的东西。什么是最好的方式来回报相似之处？

var array1 = ["cat", "sum","fun", "run"]; 
var array2 = ["bat", "cat","dog","sun", "hut", "gut"]; 

if array1 value is equal to array2 value then return match: cat 

Answer 1

当然，我的做法是，通过第一阵列循环一旦检查索引第二个数组中的每个值。如果索引是> -1，那么push它将返回到返回的数组上。

​Array.prototype.diff = function(arr2) { 
    var ret = []; 
    for(var i in this) { 
     if(arr2.indexOf(this[i]) > -1){ 
      ret.push(this[i]); 
     } 
    } 
    return ret; 
}; 

我的解决方案不使用两个循环像其他人，因此它可能跑快一点。如果你想避免使用for..in，你既可以阵列第一排序重新索引所有的价值：

Array.prototype.diff = function(arr2) { 
    var ret = []; 
    this.sort(); 
    arr2.sort(); 
    for(var i = 0; i < this.length; i += 1) { 
     if(arr2.indexOf(this[i]) > -1){ 
      ret.push(this[i]); 
     } 
    } 
    return ret; 
}; 

使用看起来像：

var array1 = ["cat", "sum","fun", "run", "hut"]; 
var array2 = ["bat", "cat","dog","sun", "hut", "gut"]; 

console.log(array1.diff(array2)); 

如果你有一个问题/问题扩展阵列原型，你可以很容易地将其改变为一个函数。

var diff = function(arr, arr2) { 

而且其中FUNC原本说this到arr2你会随时随地改变。

Answer 2

完成的答案，所以我可以做格式化......

这就是你需要经历的过程。循环访问数组以获取具体信息。

create an empty array 
loop through array1, element by element. { 
    loop through array2, element by element { 
    if array1.element == array2.element { 
     add to your new array 
    } 
    } 
} 

Answer 3

每次迭代第一阵列中的元素，然后检查比赛时间循环通过第二阵列。

var array1 = ["cat", "sum", "fun", "run"], 
    array2 = ["bat", "cat", "dog", "sun", "hut", "gut"]; 

function getMatch(a, b) { 
    var matches = []; 

    for (var i = 0; i < a.length; i++) { 
     for (var e = 0; e < b.length; e++) { 
      if (a[i] === b[e]) matches.push(a[i]); 
     } 
    } 
    return matches; 
} 

getMatch(array1, array2); // ["cat"] 

Answer 4

如果值非空字符串或数字，你可以使用一个对象作为字典：

var map = {}, result = [], i; 
for (i = 0; i < array1.length; ++i) { 
    map[array1[i]] = 1; 
} 

for (i = 0; i < array2.length; ++i) { 
    if (map[array2[i]] === 1) { 
     result.push(array2[i]); 

     // avoid returning a value twice if it appears twice in array 2 
     map[array2[i]] = 0; 
    } 
} 

return result; 

Answer 5

此函数在O(n log(n) + m log(m))中运行，与O(n*m)相比（如其他带有回路/ indexOf的解决方案中所示），如果您处理大量值，则该函数可能很有用。

但是，因为既不是"a" > 1也不是"a" < 1，这只适用于相同类型的元素。

function intersect_arrays(a, b) { 
    var sorted_a = a.concat().sort(); 
    var sorted_b = b.concat().sort(); 
    var common = []; 
    var a_i = 0; 
    var b_i = 0; 

    while (a_i < a.length 
      && b_i < b.length) 
    { 
     if (sorted_a[a_i] === sorted_b[b_i]) { 
      common.push(sorted_a[a_i]); 
      a_i++; 
      b_i++; 
     } 
     else if(sorted_a[a_i] < sorted_b[b_i]) { 
      a_i++; 
     } 
     else { 
      b_i++; 
     } 
    } 
    return common; 
} 

实施例：

var array1 = ["cat", "sum", "fun", "hut"], //modified for additional match 
    array2 = ["bat", "cat", "dog", "sun", "hut", "gut"]; 
intersect_arrays(array1, array2); 
>> ["cat", "hut"] 

Answer 6

use lodash 
GLOBAL.utils = require('lodash') 
var arr1 = ['first' , 'second']; 
var arr2 = ['second ']; 

var result = utils.difference (arr1 , arr2); 
    console.log ("result :" + result); 

Answer 7

库

像下划线和lodash有一个名为intersection找到在通过阵列的匹配工具方法。看一看：http://underscorejs.org/#intersection

Answer 8

正如@hanu提到的，你可以使用lodash但你也可以使用原生的JavaScript用：

const intersection = array1.filter(element => array2.includes(element)); 

Answer 9

我发现了什么@ jota3提示完全为我工作有轻微的改变。

var intersections = array1.filter(e => array2.indexOf(e) !== -1); 

希望这有助于！

Answer 10

随着一些ES6：

let sortedArray = []; 
firstArr.map((first) => { 
    sortedArray[defaultArray.findIndex(def => def === first)] = first; 
}); 
sortedArray = sortedArray.filter(v => v); 

这个片段也是排序firstArr基础的秩序的defaultArray

，如：

let firstArr = ['apple', 'kiwi', 'banana']; 
let defaultArray = ['kiwi', 'apple', 'pear']; 
... 
console.log(sortedArray); 
// ['kiwi', 'apple'];