Javascript 在组中查找最低级别并合并

在我的应用程序中，类似的级别被分组到一个数组中，我需要获取该组中的最低级别，并替换为所有对象中的最低级别。我没能得到想要的结果

输入

let results =  [ [{LEVEL:2,NAME:"ADAMS"},{LEVEL:3,NAME:"JAMES"}],
                 [{LEVEL:4,NAME:"SHYAM"}],
                 [{LEVEL:6,NAME:"JIM"},{LEVEL:7,NAME:"ARUN"}]
                ]

 output =  [{LEVEL:2,NAME:"ADAMS"},
            {LEVEL:2,NAME:"JAMES"},
            {LEVEL:4,NAME:"SHYAM"} ,   
            {LEVEL:6,NAME:"JIM"},
            {LEVEL:6,NAME:"ARUN"}
           ]  

输出

let results =  [ [{LEVEL:2,NAME:"ADAMS"},{LEVEL:3,NAME:"JAMES"}],
                 [{LEVEL:4,NAME:"SHYAM"}],
                 [{LEVEL:6,NAME:"JIM"},{LEVEL:7,NAME:"ARUN"}]
                ]

 output =  [{LEVEL:2,NAME:"ADAMS"},
            {LEVEL:2,NAME:"JAMES"},
            {LEVEL:4,NAME:"SHYAM"} ,   
            {LEVEL:6,NAME:"JIM"},
            {LEVEL:6,NAME:"ARUN"}
           ]  

代码

result = results.reduce((r, a) => {

a.forEach(({LEVEL,NAME}) => {
        var min = r.find(q => q.LEVEL > LEVEL);
        if (!min) r.push({LEVEL,NAME});

});
return r;
}, []);
console.log(result)

---

使用

Array.flatMap（）

进行迭代，并将每个子数组项映射到最小

级别

值

您可以使用

Array.map（）

获得

级别的数组，然后在
Math.min（）
中展开它们以获得最小值（请参阅
getMinLevel（）
函数）


const results=[[{LEVEL:2，NAME:“ADAMS”}，{LEVEL:3，NAME:“JAMES”}]，{LEVEL:4，NAME:“SHYAM”}]，{LEVEL:6，NAME:“JIM”}，{LEVEL:7，NAME:“ARUN”}]
const getMinLevel=arr=>Math.min（…arr.map（o=>o.LEVEL））
const result=results.flatMap（arr=>{
常量级别=getMinLevel（arr）
返回arr.map（o=>({
……哦，
水平仪
}))
})
console.log（result）
使用
Array.flatMap（）
迭代，并将每个子数组项映射到最小
级别
值

您可以使用
Array.map（）
获得
级别的数组，然后在
Math.min（）
中展开它们以获得最小值（请参阅
getMinLevel（）
函数）


const results=[[{LEVEL:2，NAME:“ADAMS”}，{LEVEL:3，NAME:“JAMES”}]，{LEVEL:4，NAME:“SHYAM”}]，{LEVEL:6，NAME:“JIM”}，{LEVEL:7，NAME:“ARUN”}]
const getMinLevel=arr=>Math.min（…arr.map（o=>o.LEVEL））
const result=results.flatMap（arr=>{
常量级别=getMinLevel（arr）
返回arr.map（o=>({
……哦，
水平仪
}))
})
console.log（result）
对于每个组，您必须循环两次。一次查找min
级别，然后再次应用该min。我使用了这里的函数来迭代这些数组，还使用了一些速记
（组[0]|{LEVEL:0}）
检查
0
是否是
group
的有效索引，如果不是，只使用
级别为
0
的默认对象以避免错误<代码>最小值>结果级别？结果水平：min检查
min
是否大于
result.LEVEL
。如果是这样，它将生成
result.LEVEL
。否则，它将产生当前
min


let结果=[
[{级别：2，名称：“亚当斯”}，{级别：3，名称：“詹姆斯”}，
[{级别：4，名称：“SHYAM”}]，
[{级别：6，名称：“JIM”}，{级别：7，名称：“ARUN”}]
];
结果：forEach（（组）=>{
var min=（组[0]|{LEVEL:0}）；
group.forEach（（result）=>{min=min>result.LEVEL？result.LEVEL:min；}）；
group.forEach（（result）=>{result.LEVEL=min；}）；
});
控制台日志（结果）对于每个组，您必须循环两次。一次查找min
级别，然后再次应用该min。我使用了这里的函数来迭代这些数组，还使用了一些速记
（组[0]|{LEVEL:0}）
检查
0
是否是
group
的有效索引，如果不是，只使用
级别为
0
的默认对象以避免错误<代码>最小值>结果级别？结果水平：min检查
min
是否大于
result.LEVEL
。如果是这样，它将生成
result.LEVEL
。否则，它将产生当前
min


let结果=[
[{级别：2，名称：“亚当斯”}，{级别：3，名称：“詹姆斯”}，
[{级别：4，名称：“SHYAM”}]，
[{级别：6，名称：“JIM”}，{级别：7，名称：“ARUN”}]
];
结果：forEach（（组）=>{
var min=（组[0]|{LEVEL:0}）；
group.forEach（（result）=>{min=min>result.LEVEL？result.LEVEL:min；}）；
group.forEach（（result）=>{result.LEVEL=min；}）；
});
控制台日志（结果）
如果您仍然想使用
reduce
和
forEach
组合，那么我想您可以执行以下操作：


常量名称=[
[{级别：2，名称：“亚当斯”}，{级别：3，名称：“詹姆斯”}，
[{级别：4，名称：“SHYAM”}]，
[{级别：6，名称：“JIM”}，{级别：7，名称：“ARUN”}，
];
const result=names.reduce（（累加器，元素）=>{
要素forEach（e=>{
const smallestNumber=Math.min.apply（Math，elem.map（a=>a.LEVEL））；
push（{LEVEL:smallestNumber，NAME:e.NAME}）；
});
回流蓄能器；
}, []);
控制台日志（结果）
如果您仍然想使用
reduce
和
forEach
组合，那么我想您可以执行以下操作：


常量名称=[
[{级别：2，名称：“亚当斯”}，{级别：3，名称：“詹姆斯”}，
[{级别：4，名称：“SHYAM”}]，
[{级别：6，名称：“JIM”}，{级别：7，名称：“ARUN”}，
];
const result=names.reduce（（累加器，元素）=>{
要素forEach（e=>{
const smallestNumber=Math.min.apply（Math，elem.map（a=>a.LEVEL））；
push（{LEVEL:smallestNumber，NAME:e.NAME}）；
});
回流蓄能器；
}, []);
控制台日志（结果）最好解释你的答案，而不仅仅是提供代码。否则OP就不一定能学到任何东西。你说得绝对正确。我正在写解释，而你却在评论。请检查更新的答案。最好是解释你的答案，而不仅仅是提供代码。否则OP就不一定能学到任何东西。你说得绝对正确。我正在写解释，而你却在评论。请检查更新的答案。