Скажем, у меня есть массив [34, 35, 45, 48, 49] и еще один массив [48, 55]. Как я могу получить результирующий массив [34, 35, 45, 48, 49, 55]?
Получение объединения двух массивов в JavaScript
Ответ 1
Если вам не нужно сохранять порядок и считайте 45 и "45" одинаковыми:
function union_arrays (x, y) {
var obj = {};
for (var i = x.length-1; i >= 0; -- i)
obj[x[i]] = x[i];
for (var i = y.length-1; i >= 0; -- i)
obj[y[i]] = y[i];
var res = []
for (var k in obj) {
if (obj.hasOwnProperty(k)) // <-- optional
res.push(obj[k]);
}
return res;
}
alert(union_arrays([34,35,45,48,49], [44,55]));
// shows [49, 48, 45, 35, 34, 55, 44]
Ответ 2
С появлением ES6 с наборами и оператором splat (во время работы только в Firefox, проверьте таблицу совместимости), вы можете написать следующий критический один лайнер:
var a = [34, 35, 45, 48, 49];
var b = [48, 55];
var union = [...new Set([...a, ...b])];
который выведет что-то вроде [ 34, 35, 45, 48, 49, 55 ].
Маленькое объяснение этой строки: [...a, ...b] объединяет два массива, вы также можете использовать a.concat(b). new Set() создайте набор из него и, следовательно, ваш союз. И последний [...x] преобразует его обратно в массив.
Ответ 3
Если вы используете библиотеку underscore, вы можете написать вот так:
_.union([34,35,45,48,49], [48,55]);
// [34, 35, 45, 48, 49, 55]
Ссылка: http://underscorejs.org/#union
Ответ 4
Вероятно, я трачу время на мертвую нить. Я просто должен был это реализовать и пошел посмотреть, не трачу ли я свое время.
Мне очень нравится ответ KennyTM. Это как раз то, как я буду атаковать проблему. Объедините ключи в хэш, чтобы естественным образом удалить дубликаты, а затем извлечь ключи. Если у вас действительно есть jQuery, вы можете использовать свои преимущества, чтобы сделать эту проблему с двумя строками, а затем перевернуть ее в расширение. Каждый() в jQuery позаботится о том, чтобы не перебирать элементы, где hasOwnProperty() является ложным.
jQuery.fn.extend({
union: function(array1, array2) {
var hash = {}, union = [];
$.each($.merge($.merge([], array1), array2), function (index, value) { hash[value] = value; });
$.each(hash, function (key, value) { union.push(key); } );
return union;
}
});
Обратите внимание, что оба исходных массива остаются нетронутыми. Затем вы вызываете это следующим образом:
var union = $.union(array1, array2);
Ответ 5
function unique(arrayName)
{
var newArray=new Array();
label:for(var i=0; i<arrayName.length;i++ )
{
for(var j=0; j<newArray.length;j++ )
{
if(newArray[j]==arrayName[i])
continue label;
}
newArray[newArray.length] = arrayName[i];
}
return newArray;
}
var arr1 = new Array(0,2,4,4,4,4,4,5,5,6,6,6,7,7,8,9,5,1,2,3,0);
var arr2= new Array(3,5,8,1,2,32,1,2,1,2,4,7,8,9,1,2,1,2,3,4,5);
var union = unique(arr1.concat(arr2));
Ответ 6
Адаптировано из: fooobar.com/questions/18760/...
Array.prototype.union = function(a)
{
var r = this.slice(0);
a.forEach(function(i) { if (r.indexOf(i) < 0) r.push(i); });
return r;
};
Array.prototype.diff = function(a)
{
return this.filter(function(i) {return a.indexOf(i) < 0;});
};
var s1 = [1, 2, 3, 4];
var s2 = [3, 4, 5, 6];
console.log("s1: " + s1);
console.log("s2: " + s2);
console.log("s1.union(s2): " + s1.union(s2));
console.log("s2.union(s1): " + s2.union(s1));
console.log("s1.diff(s2): " + s1.diff(s2));
console.log("s2.diff(s1): " + s2.diff(s1));
// Output:
// s1: 1,2,3,4
// s2: 3,4,5,6
// s1.union(s2): 1,2,3,4,5,6
// s2.union(s1): 3,4,5,6,1,2
// s1.diff(s2): 1,2
// s2.diff(s1): 5,6
Ответ 7
Мне нравится решение Peter Ajtai concat-then-unique, но код не очень ясен. Здесь более приятная альтернатива:
function unique(x) {
return x.filter(function(elem, index) { return x.indexOf(elem) === index; });
};
function union(x, y) {
return unique(x.concat(y));
};
Так как indexOf возвращает индекс первого вхождения, мы проверяем его на текущий индекс элемента (второй параметр на предикат фильтра).
Ответ 8
Если вы хотите объединить два массива без какого-либо повторяющегося значения, попробуйте это
var a=[34, 35, 45, 48, 49];
var b=[48, 55];
var c=a.concat(b).sort();
var res=c.filter((value,pos) => {return c.indexOf(value) == pos;} );
Ответ 9
Вы можете использовать плагин jQuery: утилиты jQuery Array
Например, код ниже
$.union([1, 2, 2, 3], [2, 3, 4, 5, 5])
вернет [1,2,3,4,5]
Ответ 10
Сначала я конкатенировал бы массивы, тогда я бы вернул только уникальное значение.
Вы должны создать свою собственную функцию для возврата уникальных значений. Так как это полезная функция, вы можете также добавить ее в качестве функциональности Array.
В вашем случае с массивами array1 и array2 он будет выглядеть так:
-
array1.concat(array2)- объединить два массива -
array1.concat(array2).unique()- вернуть только уникальные значения. Здесьunique()- это метод, который вы добавили в прототип дляArray.
Все будет выглядеть так:
Array.prototype.unique = function () {
var r = new Array();
o:for(var i = 0, n = this.length; i < n; i++)
{
for(var x = 0, y = r.length; x < y; x++)
{
if(r[x]==this[i])
{
continue o;
}
}
r[r.length] = this[i];
}
return r;
}
var array1 = [34,35,45,48,49];
var array2 = [34,35,45,48,49,55];
// concatenate the arrays then return only the unique values
alert(array1.concat(array2).unique());
Ответ 11
function unite(arr1, arr2, arr3) {
newArr=arr1.concat(arr2).concat(arr3);
a=newArr.filter(function(value){
return !arr1.some(function(value2){
return value == value2;
});
});
console.log(arr1.concat(a));
}//This is for Sorted union following the order :)
Ответ 12
function unionArray(arrayA, arrayB) {
var obj = {},
i = arrayA.length,
j = arrayB.length,
newArray = [];
while (i--) {
if (!(arrayA[i] in obj)) {
obj[arrayA[i]] = true;
newArray.push(arrayA[i]);
}
}
while (j--) {
if (!(arrayB[j] in obj)) {
obj[arrayB[j]] = true;
newArray.push(arrayB[j]);
}
}
return newArray;
}
unionArray([34, 35, 45, 48, 49], [44, 55]);
Ответ 13
function unionArrays() {
var args = arguments,
l = args.length,
obj = {},
res = [],
i, j, k;
while (l--) {
k = args[l];
i = k.length;
while (i--) {
j = k[i];
if (!obj[j]) {
obj[j] = 1;
res.push(j);
}
}
}
return res;
}
Несколько аналогично в подходе к методу alejandro, но немного короче и должен работать с любым количеством массивов.
Ответ 14
Просто написал ранее по той же причине (работает с любым количеством массивов):
/**
* Returns with the union of the given arrays.
*
* @param Any amount of arrays to be united.
* @returns {array} The union array.
*/
function uniteArrays()
{
var union = [];
for (var argumentIndex = 0; argumentIndex < arguments.length; argumentIndex++)
{
eachArgument = arguments[argumentIndex];
if (typeof eachArgument !== 'array')
{
eachArray = eachArgument;
for (var index = 0; index < eachArray.length; index++)
{
eachValue = eachArray[index];
if (arrayHasValue(union, eachValue) == false)
union.push(eachValue);
}
}
}
return union;
}
function arrayHasValue(array, value)
{ return array.indexOf(value) != -1; }
Ответ 15
Простой способ справиться с объединением значений одного массива.
var values[0] = {"id":1235,"name":"value 1"}
values[1] = {"id":4323,"name":"value 2"}
var object=null;
var first=values[0];
for (var i in values)
if(i>0)
object= $.merge(values[i],first)
Ответ 16
Вы можете попробовать:
function union(a, b) {
return a.concat(b).reduce(function(prev, cur) {
if (prev.indexOf(cur) === -1) prev.push(cur);
return prev;
}, []);
}
или
function union(a, b) {
return a.concat(b.filter(function(el) {
return a.indexOf(el) === -1;
}));
}
Ответ 17
Более короткая версия ответа кеннитма:
function unionArrays(a, b) {
const cache = {};
a.forEach(item => cache[item] = item);
b.forEach(item => cache[item] = item);
return Object.keys(cache).map(key => cache[key]);
};
Ответ 18
Я думаю, что было бы проще создать новый массив, добавив уникальные значения только по определению indexOf.
Это кажется мне самым простым решением, хотя я не знаю, является ли он наиболее эффективным. Сортировка не сохраняется.
var a = [34, 35, 45, 48, 49],
b = [48, 55];
var c = union(a, b);
function union(a, b) { // will work for n >= 2 inputs
var newArray = [];
//cycle through input arrays
for (var i = 0, l = arguments.length; i < l; i++) {
//cycle through each input arrays elements
var array = arguments[i];
for (var ii = 0, ll = array.length; ii < ll; ii++) {
var val = array[ii];
//only add elements to the new array if they are unique
if (newArray.indexOf(val) < 0) newArray.push(val);
}
}
return newArray;
}
Ответ 19
[i for( i of new Set(array1.concat(array2)))]
Позвольте мне разбить это на части для вас
// This is a list by comprehension
// Store each result in an element of the array
[i
// will be placed in the variable "i", for each element of...
for( i of
// ... the Set which is made of...
new Set(
// ...the concatenation of both arrays
array1.concat(array2)
)
)
]
Другими словами, он сначала объединяет оба, а затем удаляет дубликаты (набор, по определению не может иметь дубликатов)
Обратите внимание, однако, что порядок элементов не гарантируется в этом случае.
Ответ 20
Версия ES2015
Array.prototype.diff = function(a) {return this.filter(i => a.indexOf(i) < 0)};
Array.prototype.union = function(a) {return [...this.diff(a), ...a]}
Ответ 21
Если вы хотите, чтобы функция custom equals соответствовала вашим элементам, вы можете использовать эту функцию в ES2015:
function unionEquals(left, right, equals){
return left.concat(right).reduce( (acc,element) => {
return acc.some(elt => equals(elt, element))? acc : acc.concat(element)
}, []);
}
Он перемещается по левому/правому массиву. Затем для каждого элемента будет заполнять аккумулятор, если он не найдет этот элемент в аккумуляторе. В конце нет дубликата, указанного функцией equals.
Довольно, но, вероятно, не очень эффективно с тысячами объектов.