如果您有非常大的列表，则不执行此操作，因为已经记录了许多解决方案，所以这不适合合并，但我用此解决方案解决了我的问题（因为大多数数组过滤解决方案都适用于简单数组）

const uniqueVehiclesServiced = 
  invoice.services.sort().filter(function(item, pos, ary) {
    const firstIndex = invoice.services.findIndex((el, i, arr) => el.product.vin === item.product.vin)

  return !pos || firstIndex == pos;
});

这是我需要合并（或返回两个数组的并集）时使用的函数。

var union = function (a, b) {
  for (var i = 0; i < b.length; i++)
    if (a.indexOf(b[i]) === -1)
      a.push(b[i]);
  return a;
};

var a = [1, 2, 3, 'a', 'b', 'c'];
var b = [2, 3, 4, 'b', 'c', 'd'];

a = union(a, b);
//> [1, 2, 3, "a", "b", "c", 4, "d"]

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

var array3 = union(array1, array2);
//> ["Vijendra", "Singh", "Shakya"]

这很快，可以整理任意数量的数组，并且可以处理数字和字符串。

function collate(a){ // Pass an array of arrays to collate into one array
    var h = { n: {}, s: {} };
    for (var i=0; i < a.length; i++) for (var j=0; j < a[i].length; j++)
        (typeof a[i][j] === "number" ? h.n[a[i][j]] = true : h.s[a[i][j]] = true);
    var b = Object.keys(h.n);
    for (var i=0; i< b.length; i++)
        b[i]=Number(b[i]);
    return b.concat(Object.keys(h.s));
}

> a = [ [1,2,3], [3,4,5], [1,5,6], ["spoon", "fork", "5"] ]
> collate( a )

[1, 2, 3, 4, 5, 6, "5", "spoon", "fork"]

如果你不需要区分5和“5”，那么

function collate(a){
    var h = {};
    for (i=0; i < a.length; i++) for (var j=0; j < a[i].length; j++)
        h[a[i][j]] = typeof a[i][j] === "number";
    for (i=0, b=Object.keys(h); i< b.length; i++)
        if (h[b[i]])
            b[i]=Number(b[i]);
    return b;
}
[1, 2, 3, 4, "5", 6, "spoon", "fork"]

可以。

如果你不介意（或者更愿意）所有值都以字符串结尾，那么就这样：

function collate(a){
    var h = {};
    for (var i=0; i < a.length; i++)
        for (var j=0; j < a[i].length; j++)
            h[a[i][j]] = true;
    return Object.keys(h)
}
["1", "2", "3", "4", "5", "6", "spoon", "fork"]

如果您实际上不需要数组，但只想收集唯一值并对其进行迭代，那么（在大多数浏览器（和node.js）中）：

h = new Map();
for (i=0; i < a.length; i++)
    for (var j=0; j < a[i].length; j++)
        h.set(a[i][j]);

这可能更好。

Array.prototype.add = function(b){
    var a = this.concat();                // clone current object
    if(!b.push || !b.length) return a;    // if b is not an array, or empty, then return a unchanged
    if(!a.length) return b.concat();      // if original is empty, return b

    // go through all the elements of b
    for(var i = 0; i < b.length; i++){
        // if b's value is not in a, then add it
        if(a.indexOf(b[i]) == -1) a.push(b[i]);
    }
    return a;
}

// Example:
console.log([1,2,3].add([3, 4, 5])); // will output [1, 2, 3, 4, 5]

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作为其缩减器。注意：由于实现没有使用额外的累加器，所以当您在没有参数的情况下应用它时，它会抛出错误。

对于大型输入，更好的选择是对数组进行排序。然后合并它们。

function sortFunction(a, b) {
        return a - b;
}

arr1.sort(sortFunction);
arr2.sort(sortFunction);

function mergeDedup(arr1, arr2) {

    var i = 0, j = 0, result = [];
    while (i < arr1.length && j < arr2.length) {

        if (arr1[i] < arr2[j]) {
            writeIfNotSameAsBefore(result, arr1[i]);
            i++;
        }
        else if (arr1[i] > arr2[j]) {
            writeIfNotSameAsBefore(result, arr2[j]);
            j++;
        }
        else {
            writeIfNotSameAsBefore(result, arr1[i]);
            i++;
            j++;
        }

    }

    while (i < arr1.length) {
        writeIfNotSameAsBefore(result, arr1[i]);
        i++;
    }

    while (j < arr2.length) {
        writeIfNotSameAsBefore(result, arr2[j]);
        j++;
    }
    return result;
}

function writeIfNotSameAsBefore(arr, item) {
    if (arr[arr.length - 1] !== item) {
        arr[arr.length] = item;
    }
    return arr.length;
}

排序将采用O（nlogn+mlogm），其中n和m是数组的长度，O（x）用于合并，其中x=Max（n，m）；