Javascript 返回由多个对象属性分组的另一个对象的对象数组

我有这样一个对象数组：

let users = [
{
user :{
    idUser: 2,
    name: "Alain",
    age: 23
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
group: {
    idGroup: 3,
    nomGroup: 'RH personnes'    
}
},
{
user :{
    idUser: 2,
    name: "Alain",
    age: 23
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
group: {
    idGroup: 8,
    nomGroup: 'Finance personnes'    
}
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
group: {
    idGroup: 3,
    nomGroup: 'RH personnes'    
}
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'GEST',
    label: 'RH Helper'
},
group: {
    idGroup: 3,
    nomGroup: 'RH personnes'    
}
},
];

 results = [
 {
user :{
    idUser: 2,
    name: "Alain",
    age: 23
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
groups: [{
    idGroup: 3,
    nomGroup: 'RH personnes'    
},
{
    idGroup: 8,
    nomGroup: 'Finance personnes'    
}]
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
groups: [{
    idGroup: 3,
    nomGroup: 'RH personnes'    
}]
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'GEST',
    label: 'RH Helper'
},
groups: [{
    idGroup: 3,
    nomGroup: 'RH personnes'    
}]
},

我想返回这个由用户id从用户对象和代码角色从角色对象中摸索出的对象数组，其中包含新的关键组，每个id用户和代码角色都有一个组数组，如下所示：

let users = [
{
user :{
    idUser: 2,
    name: "Alain",
    age: 23
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
group: {
    idGroup: 3,
    nomGroup: 'RH personnes'    
}
},
{
user :{
    idUser: 2,
    name: "Alain",
    age: 23
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
group: {
    idGroup: 8,
    nomGroup: 'Finance personnes'    
}
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
group: {
    idGroup: 3,
    nomGroup: 'RH personnes'    
}
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'GEST',
    label: 'RH Helper'
},
group: {
    idGroup: 3,
    nomGroup: 'RH personnes'    
}
},
];

 results = [
 {
user :{
    idUser: 2,
    name: "Alain",
    age: 23
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
groups: [{
    idGroup: 3,
    nomGroup: 'RH personnes'    
},
{
    idGroup: 8,
    nomGroup: 'Finance personnes'    
}]
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'ADM',
    label: 'Administrator'
},
groups: [{
    idGroup: 3,
    nomGroup: 'RH personnes'    
}]
},
{
user :{
    idUser: 8,
    name: "Jhon",
    age: 33
},
role: {
    codeRole: 'GEST',
    label: 'RH Helper'
},
groups: [{
    idGroup: 3,
    nomGroup: 'RH personnes'    
}]
},

])

我试过用reduce，但我找不到怎么做

谢谢你的帮助

试试下面的方法

内部还原功能

查找结果对象中是否已存在组密钥

如果不存在，则创建新对象并添加到返回对象

将组从当前对象添加到分组对象

返回结果对象

注意：在

reduce

中，第二个参数是返回对象

让用户=[{
用户：{
idUser:2，
姓名：“阿兰”，
年龄:23
},
角色：{
代码角色：“ADM”，
标签：“管理员”
},
组：{
IDG组：3，
名称组：“右侧人员”
}
},
{
用户：{
idUser:2，
姓名：“阿兰”，
年龄:23
},
角色：{
代码角色：“ADM”，
标签：“管理员”
},
组：{
idGroup:8，
nomGroup:“财务人员”
}
},
{
用户：{
idUser:8，
姓名：“Jhon”，
年龄:33
},
角色：{
代码角色：“ADM”，
标签：“管理员”
},
组：{
IDG组：3，
名称组：“右侧人员”
}
},
{
用户：{
idUser:8，
姓名：“Jhon”，
年龄:33
},
角色：{
代码角色：“GEST”，
标签：“右侧辅助对象”
},
组：{
IDG组：3，
名称组：“右侧人员”
}
},
];
函数groupBy（r，u）{
//查找您的组密钥是否已存在。
让obj=r.find（x=>x.user.idUser==u.user.idUser&&x.role.codeRole==u.role.codeRole）；
//如果不存在，则创建新对象并添加到返回对象。
如果（！obj）{
obj={
用户：美国用户，
角色：美国角色，
组：[]
};
r、 推（obj）；
}
//将组从当前对象添加到分组对象
对象组推送（u组）；
//返回结果对象
返回r；
}
//在reduce中，第二个参数是返回对象。
让结果=[]；
用户。减少（分组、结果）；
控制台日志（结果）使用
reduce
和
findIndex
。在reduce回调函数中，使用
findIndex
查找累加器中是否存在具有相同
idUser
和
codeRole
的对象。如果存在，则更新
组
数组并从组中推送值

如果不存在，则创建新对象并在数组中推送
group
的值


让用户=[{
用户：{
idUser:2，
姓名：“阿兰”，
年龄:23
},
角色：{
代码角色：“ADM”，
标签：“管理员”
},
组：{
IDG组：3，
名称组：“右侧人员”
}
},
{
用户：{
idUser:2，
姓名：“阿兰”，
年龄:23
},
角色：{
代码角色：“ADM”，
标签：“管理员”
},
组：{
idGroup:8，
nomGroup:“财务人员”
}
},
{
用户：{
idUser:8，
姓名：“Jhon”，
年龄:33
},
角色：{
代码角色：“ADM”，
标签：“管理员”
},
组：{
IDG组：3，
名称组：“右侧人员”
}
},
{
用户：{
idUser:8，
姓名：“Jhon”，
年龄:33
},
角色：{
代码角色：“GEST”，
标签：“右侧辅助对象”
},
组：{
IDG组：3，
名称组：“右侧人员”
}
},
];
让newData=users.reduce（（acc，curr）=>{
const isuserinclude=acc.findIndex（item=>curr.user.idUser===item.user.idUser&&curr.role.codeole===item.role.codeole）；
如果（isUserIncluded===-1）{
常量tempArray=[]；
临时数组推送（当前组）
acc.push（{…curr，
组：tempArray
})
}否则{
acc[isUserIncluded].group.push（当前组）
}
返回acc；
}, []);
console.log（newData）
什么与您的代码不兼容？