在JavaScript中获得两个数组的联合


Getting a union of two arrays in JavaScript

本问题已经有最佳答案，请猛点这里访问。

假设我有一个[34, 35, 45, 48, 49]数组和另一个[48, 55]数组。我怎样才能得到一个[34, 35, 45, 48, 49, 55]的结果数组？

相关讨论

与在美国es6与集J和图示，运营商(在时间成为工程只在Firefox，compatibility检查表)，你可以写上以下一个cryptic liner： P / < >

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

P / < >

小解释关于这线：[...a, ...b]concatenates两arrays，你可以使用a.concat(b)为好。new Set()创建一套出它，因此你的联盟。和最后一个[...x]converts它回到一个阵列。 P / < >

相关讨论

如果你不需要来保持秩序，和考虑到45和"45"是一样的： P / < >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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]));

P / < >

相关讨论

如果你使用图书馆underscore你可以这样写 P / < >

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

P / < >

裁判：/ / / underscorejs.org #联盟 P / < >

相关讨论

我可能wasting时间C，死的线程的睾丸。我只是让我到这和implement出去想看看如果我是wasting我的时间。 P / < >

我真的很喜欢kennytm的答案。那只是我脑缺血发作的技术问题。merge *键入的散列到naturally消除duplicates然后提取物的钥匙。如果你有jquery其实你可以利用其糖果让这2线的问题，然后滚到一个扩展它。"每一个(是)在jquery会照顾不iterating结束项目在hasownproperty(虚假的)。 P / < >

1
2
3
4
5
6
7
8
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;
    }
});

注意这两种英语，原是arrays intact离开。然后你叫它像这样： P / < >

1
var union = $.union(array1, array2);
相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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);

P / < >

相关讨论

我喜欢彼得ajtai的concat -然后-独特的解决方案，但代码并不是很清晰。这里的nicer替代： P / < >

1
2
3
4
5
6
function unique(x) {
  return x.filter(function(elem, index) { return x.indexOf(elem) === index; });
};
function union(x, y) {
  return unique(x.concat(y));
};

由于indexof returns同步指数的第一occurence，我们看看这个对的电流元的指数(第二parameter 过滤器predicate)。 P / < >

从adapted：https:/ / / / / / 1830259 4026828 stackoverflow.com P / < >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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

如果你想concatenate两arrays重复的形式没有任何价值，只是尝试这个 P / < >

1
2
3
4
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;} );
相关讨论

你可以用jquery plugin：jquery阵列的事业 P / < >

例如下面的代码 P / < >

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

将返回(1,2,3,4,5) P / < >

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
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 :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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);

P / < >

有点similar在进场到Alejandro的方法，但在小短和我一起工作的任何数量的arrays。 P / < >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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);

P / < >

更快的 网址：/ / / jsperf.com联盟-更快的阵列 P / < >

我的第一concatenate arrays，然后我会返回唯一的独特的价值。 P / < >

你要创建你自己的独特的功能到返回的值。由于它的useful功能，你可能会给我个好它在20世纪的functionality之Array。 P / < >

在你的案例与arrays array1和array2它会看起来像这样： P / < >

  • array1.concat(array2)- concatenate两个arrays
  • array1.concat(array2).unique()-返回的值是唯一的，独特的。睾丸unique()的方法添加到你的prototype为Array。

    • 整件事会看起来像这样： P / < >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    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());

    P / < >

    相关讨论

    简单的方式来处理与合并的单值的阵列。 P / < >

    1
    2
    3
    4
    5
    6
    7
    8
    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)

    如果你想要custom equals功能到你的火柴盒的元素，你可以使用这个功能在es2015： P / < >

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

    它traverses左边+正确的阵列。然后为每一元，将填补的accumulator如果它并没有发现在accumulator元。在商场的结局，有没有重复的形式为specified由equals功能。 P / < >

    漂亮的，但可能不是很高效与thousands的物体。 P / < >

    你可以尝试这些： P / < >

    1
    2
    3
    4
    5
    6
    function union(a, b) {
        return a.concat(b).reduce(function(prev, cur) {
            if (prev.indexOf(cur) === -1) prev.push(cur);
            return prev;
        }, []);    
    }

    或 P / < >

    1
    2
    3
    4
    5
    function union(a, b) {
        return a.concat(b.filter(function(el) {
            return a.indexOf(el) === -1;
        }));
    }

    只是写在为同样的原因(工程与任何量的arrays)： P / < >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    /**
     * 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; }

    es2015版本 P / < >

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

    Array.prototype.union = function(a) {return [...this.diff(a), ...a]}
    相关讨论

    短版的kennytm的回答： P / < >

    1
    2
    3
    4
    5
    6
    7
    8
    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
    [i for( i of new Set(array1.concat(array2)))]

    让我休息的这件中的*。 P / < >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    // 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)
                )
        )
    ]

    在其他的话，它的第一concatenates两种，然后它removes的duplicates(集，通过定义不能有duplicates) P / < >

    做的音符，虽然那秩序"的元素也不保证，在这个案例。 P / < >

    我认为它会simplest到创建一个新的阵列，添加独特的值只在determined by indexof。 P / < >

    这似乎是我到现在straightforward同步的解决方案，虽然我不知道如果它是最高效的。collation不preserved。 P / < >

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    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;
    }