Javascript es6-如何删除对象数组中的重复项，除了最后一个重复项？

我有一个数组：

var arr = [
  {price: 5, amount: 100},
  {price: 3, amount: 50},
  {price: 10, amount: 20},
  {price: 3, amount: 75},
  {price: 7, amount: 15},
  {price: 3, amount: 65},
  {price: 2, amount: 34}
]

var arr = [
  {price: 5, amount: 100},
  {price: 3, amount: 50},
  {price: 10, amount: 20},
  {price: 3, amount: 75},
  {price: 7, amount: 15},
  {price: 3, amount: 65},
  {price: 2, amount: 34}
]

var results = arr.reduce<{ [price: string] : typeof arr[0] }>((p, e)=> {
    p[e.price] = e
    return p;
}, {});

var resultsAsArray = Object.keys(results)
     .map(k=>results[k])
     .sort((a, b) => b.price - a.price);

我想删除价格相同的重复项，只保留最后一个重复项，然后根据价格从高到低对数组进行排序。以下是我想要的结果：

var result = [
  {price: 10, amount: 20},
  {price : 7, amount: 15},
  {price: 5, amount: 100},
  {price: 3, amount: 65},
  {price: 2, amount: 34}
]

---

您可以使用

Array.reduce

在数组中聚合结果：

var arr = [
  {price: 5, amount: 100},
  {price: 3, amount: 50},
  {price: 10, amount: 20},
  {price: 3, amount: 75},
  {price: 7, amount: 15},
  {price: 3, amount: 65},
  {price: 2, amount: 34}
]

var arr = [
  {price: 5, amount: 100},
  {price: 3, amount: 50},
  {price: 10, amount: 20},
  {price: 3, amount: 75},
  {price: 7, amount: 15},
  {price: 3, amount: 65},
  {price: 2, amount: 34}
]

var results = arr.reduce<{ [price: string] : typeof arr[0] }>((p, e)=> {
    p[e.price] = e
    return p;
}, {});

var resultsAsArray = Object.keys(results)
     .map(k=>results[k])
     .sort((a, b) => b.price - a.price);

var-arr=[
{价格：5，金额：100}，
{价格：3，金额：50}，
{价格：10，金额：20}，
{价格：3，金额：75}，
{价格：7，金额：15}，
{价格：3，金额：65}，
{价格：2，金额：34}
]
var结果=arr.REDUCT（（p，e）=>{
p[e.价格]=e
返回p；
}, {});
var resultsarray=Object.keys（结果）
.map（k=>results[k]）
.排序（（a，b）=>b.price-a.price）；

如果定义了数组项的类型，则可以将arr[0]的类型替换为数组项的类型

---

解决方案的思想是，如果多次遇到同一个键，则将结果累积到以价格为键的对象中，旧值将被覆盖，最终，对于给定的价格，您将只有最后一个值。

使用

reduce

将其转换为对象，首先删除重复项，最后一个重复项应覆盖前一个

var obj = arr.reduce( ( acc, c ) =>  Object.assign(acc, {[c.price]:c.amount}) , {});

将其转换回数组并进行排序

var output = Object.keys( obj )
              .map( s => ({ price : s, amount : obj[ s ] }) )
              .sort( ( a, b )  => b.price - a.price );

演示

var-arr=[
{价格：5，金额：100}，
{价格：3，金额：50}，
{价格：10，金额：20}，
{价格：3，金额：75}，
{价格：7，金额：15}，
{价格：3，金额：65}，
{价格：2，金额：34}
];
var obj=arr.reduce（（acc，c）=>Object.assign（acc，{[c.price]：c.amount}），{}）；
var输出=Object.keys（obj）
.map（s=>（{price:s，amount:obj[s]}））
.排序（（a，b）=>b.price-a.price）；
控制台日志（输出）我会使用reduceRight和splice删除重复项。它不会创建任何无用的中间对象，只是沿途发现的唯一价格列表：


var-arr=[
{价格：5，金额：100}，
{价格：3，金额：50}，
{价格：10，金额：20}，
{价格：3，金额：75}，
{价格：7，金额：15}，
{价格：3，金额：65}，
{价格：2，金额：34}
]
方向减速器右（（acc，obj，i）=>{
附件[obj.价格]？阵列拼接（i，1）：附件[obj.价格]=真；
返回acc；
}，Object.create（null））；
arr.sort（（a，b）=>b.price-a.price）；
console.log（arr）
但是您的结果中没有重复的对象……这对我来说效率很低，因为它创建了许多不必要的中间对象和调用，并且需要知道输入对象的整个结构，而不仅仅是price属性。使用reduceRight，可以从原始阵列拼接副本，只创建一个附加对象作为价格指数。然后可以对缩减后的数组进行排序。@RobG那么，为了提高效率，您决定对数组进行变异吗？OP说“……我想删除重复项”而不是“我想复制数组及其所有值（对象），然后构建另一个筛选出特定值的数组”，这就是它的作用。；-）