这是我的解决方案，它基于object.prop搜索重复的对象，当找到重复的对象时，它会将array1中的值替换为array2值

function mergeSecondArrayIntoFirstArrayByProperty(array1, array2) {
    for (var i = 0; i < array2.length; i++) {
        var found = false;
        for (var j = 0; j < array1.length; j++) {
            if (array2[i].prop === array1[j].prop) { // if item exist in array1
                array1[j] = array2[i]; // replace it in array1 with array2 value
                found = true;
            }
        }
        if (!found) // if item in array2 not found in array1, add it to array1
            array1.push(array2[i]);

    }
    return array1;
}

简单高效的解决方案，运行时间比现有的70多个答案更好：

const ids = array.map(o => o.id)
const filtered = array.filter(({id}, index) => !ids.includes(id, index + 1))

例子：

const arr=[｛id:1，名称：“one”｝，｛id:2，名称：‘two’｝，{id:1，姓名：‘one’｝]常量id=arr.map（o=>o.id）constfiltered=arr.filter（（｛id｝，索引）=>！ids.includes（id，索引+1））console.log（已过滤）

工作原理：

Array.filter（）通过检查先前映射的id数组是否包含当前id来删除所有重复的对象（｛id｝仅将对象销毁为其id）。为了只过滤出实际的重复项，它使用了Array.includes（）的第二个参数fromIndex，索引为+1，这将忽略当前对象和所有先前对象。

由于过滤器回调方法的每一次迭代都将只搜索从当前索引+1开始的数组，这也大大减少了运行时间，因为只有以前未过滤的对象才会被检查。

这显然也适用于任何其他不称为id的键、多个键甚至所有键。

让myData=[{place:“here”，name:“stuff”}，{地点：“there”，名称：“morestuff”}，{地点：“there”，名称：“morestuff”}]；let q=[…new Map（myData.Map（obj=>[JSON.stringify（obj），obj]）.values（）]；控制台日志（q）

一个使用ES6和new Map（）的命令行。

// assign things.thing to myData
let myData = things.thing;

[...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

详细信息：-

对数据列表执行.map（）并将每个单独的对象转换为[key，value]对数组（长度=2），第一个元素（key）将是对象的字符串化版本，第二个元素（value）将是一个对象本身。将上述创建的数组列表添加到新的Map（）中会将键作为字符串化对象，任何相同的键添加都会导致覆盖现有的键。使用.values（）将为MapIterator提供Map中的所有值（在本例中为obj）最后，传播。。。运算符为新数组提供上述步骤中的值。

const objectsMap = new Map();
const placesName = [
  { place: "here", name: "stuff" },
  { place: "there", name: "morestuff" },
  { place: "there", name: "morestuff" },
];
placesName.forEach((object) => {
  objectsMap.set(object.place, object);
});
console.log(objectsMap);

我认为，将reduce与JSON.stringify结合起来以完美地比较对象，并选择性地添加那些尚未在累加器中的对象是一种优雅的方式。

请记住，在极端情况下，JSON.stringify可能会成为一个性能问题，因为阵列有许多对象，而且它们很复杂，但在大多数情况下，这是IMHO的最短路径。

var集合＝〔｛a:1｝，｛a:2｝，{a:1}，｛a：3｝〕var filtered=collection.reduce（（已过滤，项）=>{if（！filtered.some（filteredItem=>JSON.stringify（filtered item）==JSON.sstringify（item）））已过滤推送（项）返回已过滤}, [])console.log（已过滤）

另一种写法相同（但效率较低）：

collection.reduce((filtered, item) => 
  filtered.some(filteredItem => 
    JSON.stringify(filteredItem ) == JSON.stringify(item)) 
      ? filtered
      : [...filtered, item]
, [])

我知道这个问题已经有很多答案了，但请耐心等待。。。

数组中的某些对象可能具有您不感兴趣的其他财产，或者您只想查找只考虑财产子集的唯一对象。

考虑下面的数组。假设您想仅考虑propOne和propTwo来查找此数组中的唯一对象，而忽略可能存在的任何其他财产。

预期结果应仅包括第一个和最后一个对象。代码如下：

常量数组=[{propOne:“a”，propTwo:“b”，第三题：“我没有参与……”},{propOne:“a”，propTwo:“b”，someOtherProperty：“没有人关心这个…”},{propOne:'x'，propTwo:'y'，yetAotherJunk：“我真的一文不值”，这个：“我有一些别人没有的东西”}];常量uniques=[…新集合(array.map（x=>JSON.stringify（（（o）=>({propOne：o.propOne，propTwo:o.propTwo}))（x） ））].map（JSON.parse）；console.log（uniques）；