Javascript 过滤数组并获取最大值​；javascrip中每组对象的嵌套数组

我想从条件为count\u buyer大于0的嵌套数组中进行筛选，然后在维护嵌套数组层次结构的同时从买家处获取最大购买金额

我有这样一个数组中的数据

var data = [
      {
        'product':'laptop',
        'count_buyer':3,
        'buyers':[
              { 'name': 'Vins', 'purchase_amount': 27 },
              { 'name': 'Jan', 'purchase_amount': 38 },
              { 'name': 'Alex', 'purchase_amount': 80 },
        ]
      },
      {
        'product':'televisor',
        'count_buyer':2,
        'buyers':[
              { 'name': 'Carl', 'purchase_amount': 25 },
              { 'name': 'Digi', 'purchase_amount': 40 }
        ]
      },
      {
        'product':'ropa varon',
        'count_buyer':0,
        'buyers':[]
      }
    ];

首先，我想过滤买家数组中的对象

[     
      {
        'product':'laptop',
        'count_buyer':3,
        'buyers':[
              { 'name': 'Vins', 'purchase_amount': 27 },
              { 'name': 'Jan', 'purchase_amount': 38 },
              { 'name': 'Alex', 'purchase_amount': 80 },
        ]
      },
      {
        'product':'televisor',
        'count_buyer':2,
        'buyers':[
              { 'name': 'Carl', 'purchase_amount': 25 },
              { 'name': 'Digi', 'purchase_amount': 40 }
        ]
      },
]

然后过滤条件为最大购买金额的最大买家数量

[     
      {
        'product':'laptop',
        'count_buyer':3,
        'buyers':[
              { 'name': 'Alex', 'purchase_amount': 80 },
        ]
      },
      {
        'product':'televisor',
        'count_buyer':2,
        'buyers':[
              { 'name': 'Digi', 'purchase_amount': 40 }
        ]
      },
]

这是我的密码

var数据=[
{
“产品”：“笔记本电脑”，
“买方计数”：3，
‘买家’：[
{'name'：'Vins'，'purchase_amount'：27}，
{'name'：'Jan'，'purchase\u amount'：38}，
{'name'：'Alex'，'purchase\u amount'：80}，
]
},
{
‘产品’：‘电视机’，
“买方计数”：2，
‘买家’：[
{'name'：'Carl'，'purchase\u amount'：25}，
{'name'：'Digi'，'purchase\u amount'：40}
]
},
{
“产品”：“ropa varon”，
“计数买家”：0，
‘买家’：[]
}
];
var filter0=data.filter（count=>count.count\u买方>0）
var max=filter0.filter（buye=>buye.buyers.reduce（函数（上一个，当前）{
退货（上一次采购金额>当前采购金额）？上一次：当前
}));
console.log（max）

在

.reduce

之后，一旦您找到了拥有最大

购买金额的买家，请创建一个新的
买家
数组，并将该结果作为其一项

使用
.map
和对象扩展/静止以避免对现有数据进行变异，您可以使用：


var数据=[
{
“产品”：“笔记本电脑”，
“买方计数”：3，
‘买家’：[
{'name'：'Vins'，'purchase_amount'：27}，
{'name'：'Jan'，'purchase\u amount'：38}，
{'name'：'Alex'，'purchase\u amount'：80}，
]
},
{
‘产品’：‘电视机’，
“买方计数”：2，
‘买家’：[
{'name'：'Carl'，'purchase\u amount'：25}，
{'name'：'Digi'，'purchase\u amount'：40}
]
},
{
“产品”：“ropa varon”，
“计数买家”：0，
‘买家’：[]
}
];
常量输出=数据
.filter（（{bullers}）=>bullers.length）
.map（{买家，…rest}）=>{
const maxBuyer=buyer.reduce（（a，b）=>a.purchase\u amount>b.purchase\u amount？a:b）；
返回{…rest，买家：[maxBuyer]}；
});
控制台日志（输出）我编写这个库是为了简化我们将要使用的方法，一次完成：传感器。如果你不知道它们是什么，我写了一个速成班。首先，我将向你展示如何通过两次传球，即

[…产品]=>[…有买家的产品]

[…与买家合作的产品]=>[…与买家合作的产品]

const{transform，pipe，assign，map，filter，reduce，get，gt}=require（'rubico'））
const GETMax买方=（y，席）= > Y.Y:席
const getProductsWithMaxBuyer=管道([
过滤器（gt（get（'bullers.length'），0）），//[…产品]=>[…与买家的产品]
地图（分配）({
买家：烟斗([
获取（'bullers'），//product=>product.bullers
reduce（getMaxBuyer），//买家=>[max\u买家]
])，//将[max_buyer]结果分配给产品上的“买家”属性
}))//[…有买家的产品]=>[…有买家的产品]
])
getProductsWithMaxBuyer（数据）/*与买家创建一个中间数组“product”`
[
{
产品:"手提电脑",，
买方：3，
买家：{姓名：'Alex'，购买金额：80}
},
{
产品:"电视",，
买方：2，
买家：{name:'Digi'，购买金额：40}
}
]
*/

这就是你一次完成的方式

[…产品]=>[…与买家合作的产品]

变换(
getProductsWithMaxBuyer，
[],
)（数据）/*=>[不创建任何中间数组，所有操作都是一次通过
{
产品:"手提电脑",，
买方：3，
买家：{姓名：'Alex'，购买金额：80}
},
{
产品:"电视",，
买方：2，
买家：{name:'Digi'，购买金额：40}
}
] */

这里的区别在于使用rubico函数的上下文。他们足够聪明，知道自己是否应该像传感器一样工作。如果您想阅读更多内容，请查看和
有一种方法可以使用map和filter一次性完成此操作