ti-enxame.com

Obtendo uma união de duas matrizes em JavaScript

Digamos que eu tenha uma matriz de [34, 35, 45, 48, 49] e outra matriz de [48, 55]. Como posso obter uma matriz resultante de [34, 35, 45, 48, 49, 55]?

58
CFNinja

Se você não precisar manter o pedido e considerar 45 e "45" como sendo o mesmo:

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;
}

console.log(union_arrays([34,35,45,48,49], [44,55]));

41
kennytm

Com a chegada do ES6 com conjuntos e operador de splat (no momento de estar funcionando apenas no Firefox, verifique a tabela de compatibilidade), você pode escrever o seguinte liner críptico:

var a = [34, 35, 45, 48, 49];
var b = [48, 55];
var union = [...new Set([...a, ...b])];
console.log(union);

Pequena explicação sobre esta linha: [...a, ...b] concatena duas matrizes, você pode usar a.concat(b) também. new Set() criar um conjunto de fora e, portanto, sua união. E o último [...x] converte de volta para um array. 

69
Salvador Dali

Se você usa a biblioteca sublinhado você pode escrever assim

var unionArr = _.union([34,35,45,48,49], [48,55]);
console.log(unionArr);
<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.9.1/underscore-min.js"></script>

Ref: http://underscorejs.org/#union

42
Codler

Eu provavelmente estou perdendo tempo em um fio morto aqui. Eu só tinha que implementar isso e fui ver se estava perdendo meu tempo. 

Eu realmente gosto da resposta do KennyTM. É assim que eu atacaria o problema. Mesclar as chaves em um hash para eliminar naturalmente as duplicatas e extrair as chaves. Se você realmente tem o jQuery, pode aproveitar as vantagens para criar um problema de 2 linhas e, em seguida, transferi-lo para uma extensão. O each () no jQuery cuidará de não iterar sobre itens em que hasOwnProperty () é false.

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;
    }
});

Note que ambos os arrays originais são deixados intactos. Então você chama assim:

var union = $.union(array1, array2);
16
Gareth Farrington

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));
console.log(union);

9
Bob

Adaptado de: https://stackoverflow.com/a/4026828/1830259

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 
6
Adam Fox

Se você quiser concatenar duas matrizes sem qualquer valor duplicado, tente isso

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;} );
6
Narendra Manam

Eu gosto da solução concat-then-unique de Peter Ajtai, mas o código não é muito claro. Aqui está uma alternativa melhor:

function unique(x) {
  return x.filter(function(elem, index) { return x.indexOf(elem) === index; });
};
function union(x, y) {
  return unique(x.concat(y));
};

Como indexOf retorna o índice da ocorrência first, verificamos isso no índice do elemento atual (o segundo parâmetro para o predicado do filtro).

6
Warbo

Você pode usar um plugin jQuery: jQuery Array Utilities

Por exemplo, o código abaixo 

$.union([1, 2, 2, 3], [2, 3, 4, 5, 5])

retornará [1,2,3,4,5]

3
Kristian Abrahamsen
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 :)
2
Ademola Adegbuyi

Eu primeiro concatenaria os arrays, então retornaria apenas o valor único.

Você precisa criar sua própria função para retornar valores exclusivos. Como é uma função útil, você pode também adicioná-la como uma funcionalidade de Array .

No seu caso, com matrizes array1 e array2, ficaria assim:

  1. array1.concat(array2) - concatena as duas matrizes
  2. array1.concat(array2).unique() - retorna apenas os valores exclusivos. Aqui unique() é um método que você adicionou ao protótipo para Array.

A coisa toda ficaria assim:

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
console.log(array1.concat(array2).unique());

2
Peter Ajtai

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;
}
var unionArr = unionArrays([34, 35, 45, 48, 49], [44, 55]);
console.log(unionArr);

Algo semelhante na abordagem ao método de alejandro, mas um pouco mais curto e deve funcionar com qualquer número de matrizes.

2
TimTucker

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;
}
var unionArr = unionArray([34, 35, 45, 48, 49], [44, 55]);
console.log(unionArr);

Mais rápido http://jsperf.com/union-array-faster

2
alejandro

Versão ES2015

Array.prototype.diff = function(a) {return this.filter(i => a.indexOf(i) < 0)};

Array.prototype.union = function(a) {return [...this.diff(a), ...a]}
1
Adnan Y

Maneira simples de lidar com a fusão de valores de matriz única.

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)
1
Jhune Geronimo

Apenas escrevi antes pelo mesmo motivo (funciona com qualquer quantidade de matrizes):

/**
 * 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; }
1
Geri

Você pode tentar estes:

function union(a, b) {
    return a.concat(b).reduce(function(prev, cur) {
        if (prev.indexOf(cur) === -1) prev.Push(cur);
        return prev;
    }, []);    
}

ou

function union(a, b) {
    return a.concat(b.filter(function(el) {
        return a.indexOf(el) === -1;
    }));
}
1
Si Pham

Versão mais curta da resposta de kennytm:

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]);
};
1
worsnupd

Se você quiser que uma função custom equals} corresponda aos seus elementos, você pode usar esta função no ES2015:

function unionEquals(left, right, equals){
    return left.concat(right).reduce( (acc,element) => {
        return acc.some(elt => equals(elt, element))? acc : acc.concat(element)
    }, []);
}

Atravessa a matriz esquerda + direita. Então, para cada elemento, o acumulador será preenchido se não encontrar esse elemento no acumulador. No final, não há duplicação conforme especificado pela função equals.

Pretty, mas provavelmente não é muito eficiente com milhares de objetos.

1
Nicolas Zozol
[i for( i of new Set(array1.concat(array2)))]

Deixe-me dividir isso em partes para você

// 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)
            )
    )
]

Em outras palavras, ele primeiro concatena ambos e, em seguida, remove as duplicatas (um conjunto, por definição, não pode ter duplicatas)

Observe, no entanto, que a ordem dos elementos não é garantida, neste caso.

0
brunoais

Eu acho que seria mais simples criar uma nova matriz, adicionando os valores exclusivos apenas conforme determinado pelo indexOf.

Essa parece ser a solução mais direta, embora eu não saiba se é a mais eficiente. Agrupamento não é preservado.

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;
}
0
supershnee