У меня есть два массива, и я хочу иметь возможность сравнивать два и возвращать только совпадающие значения. Например, оба массива имеют значение cat, так что именно это и будет возвращено. Я не нашел ничего подобного. Каков наилучший способ вернуть сходство?
var array1 = ["cat", "sum","fun", "run"];
var array2 = ["bat", "cat","dog","sun", "hut", "gut"];
//if value in array1 is equal to value in array2 then return match: cat
Естественно, мой подход состоял в том, чтобы один раз пройти через первый массив и проверить индекс каждого значения во втором массиве. Если индекс > -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));
Если у вас есть проблема с расширением прототипа Array, вы можете легко изменить его на функцию.
var diff = function(arr, arr2) {
И вы бы изменили в любом месте, где func первоначально сказал this arr2.
Вы можете использовать:
const intersection = array1.filter(element => array2.includes(element));
Эта функция работает в 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"]
Я обнаружил небольшое изменение в отношении того, что @jota3 предложил работать отлично для меня.
var intersections = array1.filter(e => array2.indexOf(e) !== -1);
Надеюсь, это поможет!
Прокручивайте второй массив каждый раз, когда вы перебираете элемент в первом массиве, затем проверяйте наличие совпадений.
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"]
Библиотеки, такие как underscore и lodash, имеют метод утилиты, называемый intersection, чтобы найти совпадения в переданных массивах. Посмотрите на: http://underscorejs.org/#intersection
var array1 = [1, 2, 3, 4, 5, 6],
var array2 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var array3 = array2.filter(function(obj) {
return array1.indexOf(obj) == -1;
});
Сделано как ответ, поэтому я могу сделать форматирование...
Это процесс, который вам нужно пройти. Цитирование через массив для специфики.
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
}
}
}
use lodash
GLOBAL.utils = require('lodash')
var arr1 = ['first' , 'second'];
var arr2 = ['second '];
var result = utils.difference (arr1 , arr2);
console.log ( "result :" + result );
С некоторыми 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'];
Если ваши значения являются ненулевыми строками или цифрами, вы можете использовать объект в качестве словаря:
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;
Выполните итерацию по array1 и найдите элемент indexof, присутствующий в array2.
var array1 = ["cat", "sum","fun", "run"];
var array2 = ["bat", "cat","sun", "hut", "gut"];
var str='';
for(var i=0;i<array1.length;i++){
if(array2.indexOf(array1[i]) != -1){
str+=array1[i]+' ';
};
}
console.log(str)
Вы можете использовать функцию javascript .find() Как сказано в MDN, она вернет первое значение, которое является истинным. Если такой элемент найден, find немедленно возвращает значение этого элемента. В противном случае поиск возвращает undefined.
var array1 = ["cat", "sum","fun", "run"];
var array2 = ["bat", "cat","dog","sun", "hut", "gut"];
found = array1.find( val => array2.includes(val) )
console.log(found)