Есть ли способ найти соответствующий элемент в двух массивах?

Question

У меня есть два массива строк:

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

и

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

Как бы сравнить эти два массива и найти, что Боб Марли существует в обоих?

Answer 1

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 2

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 3

Добавьте строки из одного массива в качестве свойства в объекте, затем поиск элементов из другого:

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

Если ваши массивы не очень большие, наивное решение (сравнение всех элементов одного массива со всеми элементами другого) также может работать отлично.

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

В основном это набор пересечения, где наборы представлены с использованием неупорядоченных массивов. Если есть функция упорядочения 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 6

Вы можете сделать

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 7

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 8

Если вы не хотите, чтобы написать массив пересечения себя, вы можете использовать подчеркивающий

Взято из http://documentcloud.github.com/underscore/

intersection_.intersection (* array) Вычисляет список значений, являющихся пересечением всех массивов. Каждое значение в результате присутствует в каждом из массивов.

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

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. Затем он перебирает объект и выталкивает все ключи со значением 2 в новый массив, который он возвращает.

Даже с 1000+ элементами в каждом массиве это будет делать только три полных цикла.

Вот jsfiddle: http://jsfiddle.net/pseudosavant/5EeUZ/