Javascript 从另一个数组创建数组'；s匹配的对象值

我正试图了解

.reduce（）

的一些更高级的用法，但还有很长的路要走。当前的问题让我有些不知所措

假设我有一个如下的对象数组：

const people = [
    {
        name: "Henry",
        id: "1934",
        wormsEaten: 4
    },
    {
        name: "Melinda",
        id: "9283",
        wormsEaten: 0
    },
    {
        name: "James",
        id: "1029",
        wormsEaten: 4
    },
    {
        name: "Charles",
        id: "7210",
        wormsEaten: 3
    },
    {
        name: "Sasha",
        id: "4431",
        wormsEaten: 3
    },
]

[
    [
        {
            name: "Henry",
            id: "1934",
            wormsEaten: 4
        },
        {
            name: "James",
            id: "1029",
            wormsEaten: 4
        }
    ],
    [
        {
            name: "Melinda",
            id: "9283",
            wormsEaten: 0
        }
    ],
    [
        {
            name: "Charles",
            id: "7210",
            wormsEaten: 3
        },
        {
            name: "Sasha",
            id: "4431",
            wormsEaten: 3
        }
    ]
]

现在，我想为每个匹配的

wormsaten

值创建一个新的数组，即一个如下所示的数组：

const people = [
    {
        name: "Henry",
        id: "1934",
        wormsEaten: 4
    },
    {
        name: "Melinda",
        id: "9283",
        wormsEaten: 0
    },
    {
        name: "James",
        id: "1029",
        wormsEaten: 4
    },
    {
        name: "Charles",
        id: "7210",
        wormsEaten: 3
    },
    {
        name: "Sasha",
        id: "4431",
        wormsEaten: 3
    },
]

[
    [
        {
            name: "Henry",
            id: "1934",
            wormsEaten: 4
        },
        {
            name: "James",
            id: "1029",
            wormsEaten: 4
        }
    ],
    [
        {
            name: "Melinda",
            id: "9283",
            wormsEaten: 0
        }
    ],
    [
        {
            name: "Charles",
            id: "7210",
            wormsEaten: 3
        },
        {
            name: "Sasha",
            id: "4431",
            wormsEaten: 3
        }
    ]
]

我的伪代码思维大脑说的是：

people.reduce((accumulator, currentPerson) => {
    if(accumulator.wormsEaten === currentPerson.wormsEaten) {
        return [
          …
        ]
    }
})

---

但这大概就是我能走的路。我觉得我还有很长的路要走，如果有人能帮我找到正确的方向，我会非常感激。

用

wormsEaten

const people=[{姓名：“亨利”，身份证：“1934”，沃姆塞滕：4}，{姓名：“梅琳达”，身份证：“9283”，沃姆塞滕：0}，{姓名：“詹姆斯”，身份证：“1029”，沃姆塞滕：4}，{姓名：“查尔斯”，身份证：“7210”，沃姆塞滕：3}，{姓名：“萨沙”，身份证：“4431”，沃姆塞滕：3}]
const result=people.reduce（（累加器，当前人员）=>{
累加器[currentPerson.wormsEaten]=累加器[currentPerson.wormsEaten]| |[]
累加器[currentPerson.WormSeten]。推送（currentPerson）
回流蓄能器
}, {})
console.log（Object.values（result））

通过使用

wormsEaten进行分组


const people=[{姓名：“亨利”，身份证：“1934”，沃姆塞滕：4}，{姓名：“梅琳达”，身份证：“9283”，沃姆塞滕：0}，{姓名：“詹姆斯”，身份证：“1029”，沃姆塞滕：4}，{姓名：“查尔斯”，身份证：“7210”，沃姆塞滕：3}，{姓名：“萨沙”，身份证：“4431”，沃姆塞滕：3}]
const result=people.reduce（（累加器，当前人员）=>{
累加器[currentPerson.wormsEaten]=累加器[currentPerson.wormsEaten]| |[]
累加器[currentPerson.WormSeten]。推送（currentPerson）
回流蓄能器
}, {})
console.log（Object.values（result））
分组后的排序效率会更高，因为数组更短


const people=[{name:“Melinda”，id:“9283”，wormsEaten:0}，{name:“James”，id:“1029”，wormsEaten:4}，{name:“Charles”，id:“7210”，wormsEaten:3}，{name:“Sasha”，id:“4431”，wormsEaten:3}，{name:“Henry”，id:“1934”，wormsEaten:-9}]；
const result={}；
for（const person of people）{
（结果[person.wormsEaten]？？=[]）.push（{…person}）；
}
const sortedResult=Object.values（result）.sort（（[a]，[b]）=>a.wormsEaten-b.wormsEaten）
console.log（sortedResult）
.as控制台包装{max height:100%！important；top:0；}
分组后排序效率会更高，因为您的数组更短


const people=[{name:“Melinda”，id:“9283”，wormsEaten:0}，{name:“James”，id:“1029”，wormsEaten:4}，{name:“Charles”，id:“7210”，wormsEaten:3}，{name:“Sasha”，id:“4431”，wormsEaten:3}，{name:“Henry”，id:“1934”，wormsEaten:-9}]；
const result={}；
for（const person of people）{
（结果[person.wormsEaten]？？=[]）.push（{…person}）；
}
const sortedResult=Object.values（result）.sort（（[a]，[b]）=>a.wormsEaten-b.wormsEaten）
console.log（sortedResult）
。作为控制台包装{max height:100%！important；top:0；}
这真是太聪明了！现在我开始明白了。在reduce之前，我已经尝试在这个函数上实现了一个排序函数，但是由于
wormsEaten
可以包含负数，所以输出变成（假设我有值4、0、3和-9）0、3、4和-9。我首先让a
people.sort（（a，b）=>a.wormsEaten-b.wormsEaten）
（这给了我正确的顺序）。但是减少似乎改变了它？这是为什么？正整数对象属性是按升序数字顺序排序的，因此当使用对象进行分组时，生成的
object.values（）
遵循属性的顺序。为了避免更改排序，您可以分组到一个
映射中或直接分组到一个数组中。@ErikBlomqvist检查更新的答案这确实很聪明！现在我开始明白了。在reduce之前，我已经尝试在这个函数上实现了一个排序函数，但是由于
wormsEaten
可以包含负数，所以输出变成（假设我有值4、0、3和-9）0、3、4和-9。我首先让a
people.sort（（a，b）=>a.wormsEaten-b.wormsEaten）
（这给了我正确的顺序）。但是减少似乎改变了它？这是为什么？正整数对象属性是按升序数字顺序排序的，因此当使用对象进行分组时，生成的
object.values（）
遵循属性的顺序。为了避免更改排序，您可以分组到
映射中或直接分组到数组中。@ErikBlomqvist检查更新的答案