如何在JavaScript中合并两个数组并消除重复项

我有两个JavaScript数组：

var array1 = ["Vijendra","Singh"];
var array2 = ["Singh", "Shakya"];

我希望输出为：

var array3 = ["Vijendra","Singh","Shakya"];

输出数组应删除重复的单词。

如何在JavaScript中合并两个数组，以便从每个数组中只获得唯一的项目，其顺序与它们插入原始数组的顺序相同？

当前回答

模块化，通用

这可以通过组成两个基本功能来实现。

const getUniqueMerge = (...arrs) => getUniqueArr(mergeArrs(...arrs))
const getUniqueArr = (array) => Array.from(new Set(array))  
const mergeArrs = (...arrs) => [].concat(...arrs)

它可以处理无限的数组或值

console.log(getUniqueMerge(["Vijendra","Singh"],["Singh", "Shakya"])
// ["Vijendra", "Singh", "Shakya"]

console.log(getUniqueMerge(["Sheldon", "Cooper"], ["and", "Cooper", "Amy", "and"], "Farrah", "Amy", "Fowler"))
// ["Sheldon", "Cooper", "and", "Amy", "Farrah", "Fowler"]

2019-04-22 18:01:28

其他回答

ES2015的功能方法

按照函数方法，两个数组的联合只是concat和filter的组合。为了提供最佳性能，我们使用本机Set数据类型，该类型针对属性查找进行了优化。

无论如何，结合联合函数的关键问题是如何处理重复项。以下排列是可能的：

Array A      + Array B

[unique]     + [unique]
[duplicated] + [unique]
[unique]     + [duplicated]
[duplicated] + [duplicated]

前两种排列很容易用一个函数处理。然而，后两个更复杂，因为只要依赖Set查找，就无法处理它们。由于切换到普通的旧Object属性查找会严重影响性能，因此下面的实现只会忽略第三个和第四个排列。你必须构建一个单独的union版本来支持它们。

//小型、可重复使用的辅助功能常量comp=f=>g=>x=>f（g（x））；常量应用=f=>a=>f（a）；常量flip=f=>b=>a=>f（a）（b）；常量concat=xs=>y=>xs.contat（y）；const afrom=应用（Array.from）；const createSet=xs=>新集合（xs）；常量过滤器=f=>xs=>xs.filter（apply（f））；//重复数据消除常量重复数据删除=comp（afrom）（createSet）；//实际联合函数常量并集=xs=>ys=>{const zs=创建集（xs）；返回凹面（xs）(滤波器（x=>zs.has（x）? 假的：zs.add（x）)（ys））；}//模拟数据常量xs=[1,2,2,3,4,5]；常量=[0,1,2,3,3,4,5,6,6]；//我们来了console.log（“unique/unique”，union（重复数据消除（xs））（ys））；console.log（“重复/唯一”，union（xs）（ys））；

从这里开始，实现unionn函数变得很简单，它接受任意数量的数组（灵感来自naomik的评论）：

//小型、可重复使用的辅助功能常量未修正=f=>（a，b）=>f（a）（b）；常量foldl=f=>acc=>xs=>xs.reduce（uncurry（f），acc）；常量应用=f=>a=>f（a）；常量flip=f=>b=>a=>f（a）（b）；常量concat=xs=>y=>xs.contat（y）；const createSet=xs=>新集合（xs）；常量过滤器=f=>xs=>xs.filter（apply（f））；//工会和工会常量并集=xs=>ys=>{const zs=创建集（xs）；返回凹面（xs）(滤波器（x=>zs.has（x）? 假的：zs.add（x）)（ys））；}常量unionn=（头，…尾）=>foldl（联合）（头）（尾）；//模拟数据常量xs=[1,2,2,3,4,5]；常量=[0,1,2,3,3,4,5,6,6]；常数zs=[0,1,2,3,4,5,6,7,8,9]；//我们来了console.log（unionn（xs，ys，zs））；

事实证明unionn只是foldl（又名Array.protocol.reduce），它将union作为其缩减器。注意：由于实现没有使用额外的累加器，所以当您在没有参数的情况下应用它时，它会抛出错误。

2016-09-05 19:37:50

看起来接受的答案是我测试中最慢的；

注意，我正在按Key合并2个对象数组

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>JS Bin</title>
</head>
<body>
<button type='button' onclick='doit()'>do it</button>
<script>
function doit(){
    var items = [];
    var items2 = [];
    var itemskeys = {};
    for(var i = 0; i < 10000; i++){
        items.push({K:i, C:"123"});
        itemskeys[i] = i;
    }

    for(var i = 9000; i < 11000; i++){
        items2.push({K:i, C:"123"});
    }

    console.time('merge');
    var res = items.slice(0);

    //method1();
    method0();
    //method2();

    console.log(res.length);
    console.timeEnd('merge');

    function method0(){
        for(var i = 0; i < items2.length; i++){
            var isok = 1;
            var k = items2[i].K;
            if(itemskeys[k] == null){
                itemskeys[i] = res.length;
                res.push(items2[i]);
            }
        }
    }

    function method1(){
        for(var i = 0; i < items2.length; i++){
            var isok = 1;
            var k = items2[i].K;

            for(var j = 0; j < items.length; j++){
                if(items[j].K == k){
                    isok = 0;
                    break;
                }
            }

            if(isok) res.push(items2[i]);
        }  
    }

    function method2(){
        res = res.concat(items2);
        for(var i = 0; i < res.length; ++i) {
            for(var j = i+1; j < res.length; ++j) {
                if(res[i].K === res[j].K)
                    res.splice(j--, 1);
            }
        }
    }
}
</script>
</body>
</html>

2016-04-15 19:22:17

为什么不使用对象？看起来你在尝试建立一套模型。然而，这并不能维持秩序。

var set1 = {"Vijendra":true, "Singh":true}
var set2 = {"Singh":true,  "Shakya":true}

// Merge second object into first
function merge(set1, set2){
  for (var key in set2){
    if (set2.hasOwnProperty(key))
      set1[key] = set2[key]
  }
  return set1
}

merge(set1, set2)

// Create set from array
function setify(array){
  var result = {}
  for (var item in array){
    if (array.hasOwnProperty(item))
      result[array[item]] = true
  }
  return result
}

2009-10-18 08:51:09

为此……这里有一个单行解决方案：

const x = [...new Set([['C', 'B'],['B', 'A']].reduce( (a, e) => a.concat(e), []))].sort()
// ['A', 'B', 'C']

不是特别可读，但它可能会帮助某人：

将初始累加器值设置为空数组的reduce函数应用于空数组。reduce函数使用concat将每个子数组附加到累加器数组上。其结果作为构造函数参数传递，以创建新的Set。排列运算符用于将集合转换为数组。sort（）函数应用于新数组。

2017-12-03 21:48:29

对于ES6，只有一行：

a = [1, 2, 3, 4]
b = [4, 5]
[...new Set(a.concat(b))]  // [1, 2, 3, 4, 5]

2018-09-22 09:10:26

如何在JavaScript中合并两个数组并消除重复项

推荐文章

最新文章

标签