删除对象数组Javascript中的重复项

我有一个对象数组

list = [{x:1,y:2}, {x:3,y:4}, {x:5,y:6}, {x:1,y:2}]

我正在寻找一种有效的方法（如果可能的话）

O（log（n））

）来删除重复项并最终

list = [{x:1,y:2}, {x:3,y:4}, {x:5,y:6}]

我尝试了

\uq.uniq

甚至

\uq.contains

，但找不到令人满意的解决方案

谢谢

---

编辑：该问题已被确定为另一个问题的副本。我在发帖前看到了这个问题，但它没有回答我的问题，因为它是一个对象数组（而不是2维数组，谢谢Aaron），或者至少另一个问题的解决方案在我的案例中不起作用。

以下内容将起作用：

var a = [{x:1,y:2}, {x:3,y:4}, {x:5,y:6}, {x:1,y:2}];

var b = _.uniq(a, function(v) { 
    return v.x && v.y;
})

console.log(b);  // [ { x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 } ]

香草JS版本：

const list=[{x:1，y:2}，{x:3，y:4}，{x:5，y:6}，{x:1，y:2}]；
功能重复数据消除（arr）{
返回arr.reduce（函数（p，c）{
//从对象值创建标识id
var id=[c.x，c.y]。连接（“|”）；
//如果在临时数组中找不到id
//将对象添加到输出数组中
//并将密钥添加到临时数组中
如果（p.temp.indexOf（id）=-1）{
p、 向外推（c）；
p、 温度推送（id）；
}
返回p；
//返回已消除重复数据的阵列
}, {
温度：[]，
输出：[]
}).退出；
}
console.log（重复数据消除（列表））检查是否已在O（n）中的临时对象中后筛选数组


var list=[{x:1，y:2}，{x:3，y:4}，{x:5，y:6}，{x:1，y:2}]，
过滤=函数（数组）{
var o={}；
返回数组.filter（函数（a）{
var k=a.x+'|'+a.y；
如果（！o[k]）{
o[k]=正确；
返回true；
}
});
}（名单）；
document.write（“”+JSON.stringify（filtered，0,4）+“”）普通javascript（ES2015），使用


const list=[{x:1，y:2}，{x:3，y:4}，{x:5，y:6}，{x:1，y:2}]；
constuniq=newset（list.map（e=>JSON.stringify（e））；
const res=Array.from（uniq.map）（e=>JSON.parse（e））；
document.write（JSON.stringify（res））
我将使用
Arrayr.prototype.reduce
和
Arrayr.prototype.spread运算符的组合

1。显式解决方案。基于对数组对象包含的完整知识

list = list.reduce((r, i) => 
  !r.some(j => JSON.stringify(i) === JSON.stringify(j)) ? [...r, i] : r
, [])

这里我们对比较对象结构有严格的限制：
{x:N，y:M}
。而
[{x:1，y:2}，{x:1，y:2，z:3}]
将被过滤到
[{x:1，y:2}]

2。通用解决方案，
JSON.stringify（）。比较对象可以具有任意数量的任意属性

list = list.reduce((r, i) => 
  !r.some(j => !Object.keys(i).some(k => i[k] !== j[k])) ? [...r, i] : r
, [])

这种方法对属性顺序有限制，因此不会过滤
[{x:1，y:2}，{y:2，x:1}]

3。通用解决方案，
Object.keys（）。顺序不重要

list = list.reduce((r, i) => 
  !r.some(j => Object.keys(i).length === Object.keys(j).length 
    && !Object.keys(i).some(k => i[k] !== j[k])) ? [...r, i] : r
, [])

这种方法还有另一个限制：比较对象必须具有相同的键列表。
因此，
[{x:1，y:2}，{x:1}]
将被过滤，尽管存在明显的差异

4。通用解决方案，
Object.keys（）

list = list.filter((elem, index, self) => self.findIndex(
    (t) => {return (t.x === elem.x && t.y === elem.y)}) === index)

使用最后一种方法时，将根据关键帧的数量、关键帧本身和关键帧值对对象进行比较

我创建了一个用于玩它的工具。
尝试使用以下工具：

arr.filter((v,i,a)=>a.findIndex(t=>(t.x === v.x && t.y===v.y))===i)

ES6+的一行程序

如果要通过x和y查找uniq：

arr.filter((v,i,a)=>a.findIndex(t=>(JSON.stringify(t) === JSON.stringify(v)))===i)

如果要按所有属性查找唯一性：

 _.uniqBy(list, e => { return e.x && e.y })

使用lodash，您可以使用以下一种衬里：

请注意，这不是一个二维数组，而是一个对象数组。谢谢！对我来说，它比Andy的解决方案快吗？除非你处理1000个元素中的10个，否则性能不应该是个问题。我想你必须权衡一下加载一个单独的库（如果你的堆栈中还没有lodash）或者仅仅使用一个稍微详细一点的香草函数的成本。这也是我想补充的：-）@AndyDon认为这不能正常工作，例如1&&2==2&&2如果输入是[{x:1，y:2}，{x:2.y:2}]，那么结果将是[{x:1，y:2}]-第二个对象将被删除，即使它不是重复的
stringify
和
parse
看起来并不是实现这一点的最有效的方法。在ES2015中编写代码时不应该使用var@AminJafari即使在2020年，var的使用也不存在任何问题。只要注意范围界定，var是绝对好的。虽然这个答案不是最有效的，但它符合OP的要求question@SeaWarrior404我知道，这就是我投票的原因：）在可以使用constIt's perfect的地方使用var不是一个好的实践。谢谢你的提问，你能不能用
Object.is（）
来比较你的过滤器？你能解释一下第四种方法中发生了什么，特别是数组部分和一些比较吗？这对我来说有点难understand@SeaWarrior4044方法是键/值比较和长度比较的组合，键/值比较是第3页中的第二个“部分”，长度比较是第一个“部分”，它迭代地将初始数组中每个对象的键的长度与初始数组中所有其他对象的键的长度进行比较，以确保列表中的所有项具有相同数量的字段。如果给定对象与列表中的其他对象具有相同数量的字段，则会将其发送到键值比较（第二个“some”）。如果没有，它将立即被过滤掉。您不需要在每次迭代时重新创建数组。您可以改用
r.push（i）
<代码>如果（！r.some（j=>JSON.stringify（i）==JSON.stringify（j）））r.push（i）；返回r
对通用解决方案竖起大拇指，这正是我所需要的！
 _.uniqBy(list, e => { return e.x && e.y })