Question

我有两个字符串数组：

"bob marley", "bob dylan", "bob harris"

和

"alfred hitchcock", "matt damon", "bob marley"

我如何比较这两个数组并发现Bob Marley同时存在？

Answer 1

如果您不想自己编写阵列交叉点，可以使用下划线

取自http://documentcloud.github.com/underscore/

intersection_.intersection（*阵列）计算所有数组交集的值列表。结果中的每个值都存在于每个数组中。

 _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
 => [1, 2]

Answer 2

var arr1 = ["bob marley", "bob dylan", "bob harris"];
var arr2 = ["alfred hitchcock", "matt damon", "bob marley"];

$.each(arr1, function(i, val) {
    if ($.inArray(val, arr2) !== -1) {
        console.log(val + " is in both");
    }
});

http://jsfiddle.net/BvTTf/

Answer 3

var array1 = [];
var array2 = [];
var matched = [];

for ( var i = 0; i < array1.length; i++ ){
    var s = array[i];
    for ( var j = 0; j < array2.length; j++ ){
        if ( s == array2[j] ){
             matched.push( s );
             break;
        }
    } 
}

然后matched将包含两个数组中出现的字符串

请注意，比较s == array2[j]是准确的（区分大小写）

Answer 4

您想要的是一组集合（在本例中为数组）。没有内置的javascript或jQuery函数来执行此操作，但您可以通过多种方式轻松编写代码。这是一个：

$(function() {
    var array1 = ["bob marley", "bob dylan", "bob harris"];
    var array2 = ["alfred hitchcock", "matt damon", "bob marley", "bob dylan"];

    var intersect = $.map(array1, function(el) {
        return $.inArray(el, array2) < 0 ? null : el;
    })
});

演示：http://jsfiddle.net/jtbowden/2mxzX/

Answer 5

将一个数组的字符串添加为对象中的属性，然后从另一个数组中搜索元素：

var obj = {}
var matching = [];
$.each(array1,function(index,s) { obj[s] = true; });
$.each(array2,function(index,s) {
    if ( obj[s] )
        matching.push(s);
});

如果您的数组不是很大，那么一个天真的解决方案（将一个数组的所有元素与另一个数组的所有元素进行比较）也可以正常工作。

Answer 6

这基本上是设置交集，其中集合使用无序数组表示。如果有一个排序函数cmp对数组中的元素进行排序，那么您可以将无序表示转换为更容易相交的有序表示。

function commonElements(arr1, arr2, cmp) {
  // Defensively copy the input.
  arr1 = arr1.slice(0);
  arr2 = arr2.slice(0);
  // Assume the natural ordering if none is provided.
  // cmp should return a negative number to indicate that the first
  // argument is less than the second, a positive to indicate the opposite
  // and 0 to indicate equivalence.
  cmp = cmp || function (a, b) { return a < b ? -1 : a > b ? 1 : 0; };
  // Convert the input arrays to ordered form in O(n*log n) time so we
  // can intersect the arrays in O(n) time instead of O(n*m).
  arr1.sort(cmp);
  arr2.sort(cmp);
  var intersection = [];
  var i1 = 0, i2 = 0, n1 = arr1.length, n2 = arr2.length;
  while (i1 < n1 && i2 < n2) {
    var el1 = arr1[i1], el2 = arr2[i2];
    var delta = cmp(el1, el2);
    if (delta) {
      // If el1 < el2, increment i1 so we compare el2 with
      // the next element of arr1 on loop reentry.
      // Otherwise, increment i2 for similar reasons.
      if (delta < 0) { ++i1; } else { ++i2; }
    } else {  // Found a match.
      intersection.push(el1);
      ++i1, ++i2;
    }
  }
  // There will be no intersection in the unscanned portion of whichever
  // array we did not fully traverse so we're done.
  return intersection;
}

Answer 7

你可以做到

function getSimilar(array1, array2) {

 var exists = {};
 var similar = [];

   for(var i = 0; i < array1.length; i++) {
     exists[array1[i]] = true;
    }
    for(var i = 0; i < array2.length; i++) {
     if(exists[array2[i]]) {
       similar.push(array2[i]);
     }
   }
  return similar;
 }

Answer 8

var arr = ["bob marley", "bob dylan", "bob harris"];
var arr1 = ["alfred hitchcock", "matt damon", "bob marley"];

function findCommonElements(arr, arr1){
   var matches=[];
   for(var i=0; i < arr.length;i++){
      for(var x=0; x < arr1.length; x++){
         if(arr[i] == arr1[x]){
             matches.push(arr[i]);
         }
       }
   }
  return matches;
 }

查看一个有效的示例：http://jsfiddle.net/Vuryj/

Answer 9

这里有很多答案都可以。我认为如果你只处理字符串，这是最快的一个。它只对每个数组执行一个循环，然后循环遍历结果。如果数组不仅仅是几个条目，那么大多数其他示例将执行100或1000个循环。

var names1 = ["john", "steve", "joe", "tom", "marco", "eric", "buddy"];
var names2 = ["joe", "marco", "buddy", "chris", "tim", "clarke", "pat"];

var intersection = function(firstArray, secondArray) {
    var matches = {}, results = [], a = firstArray, b = secondArray, i, l;

    for (i=0, l=a.length; i<l; i++) {
        matches[a[i]] = 1;
    }

    for (i=0, l=b.length; i<l; i++) {
        if (matches[b[i]]) matches[b[i]]++;
    }

    for (i in matches) {
        if (matches[i] === 2) results.push(i);
    }

    return results;
};

console.log(intersection(names1,names2));

基本上它循环遍历第一个数组，并将每个条目添加到值为1的对象。然后它运行通过第二个数组，如果对象已经有一个键，那么它将它递增1.然后循环遍历该对象并将值为2的所有键推送到它返回的新数组中。

即使每个阵列中有1000多个条目，这也只能完成三个循环。

这是一个jsfiddle：http://jsfiddle.net/pseudosavant/5EeUZ/

有没有办法在两个数组中找到匹配的元素？

9 个答案: