Javascript 按id匹配2个数组（用户[用户id作为键]到订单[订单id数组的值]）

我有一个“用户”数组和一个“订单”数组。 我想列出每个用户id的所有订单id

var users = {
    0: {
        user_id: 111,
        user_name: "user111",
        isActive: 0
    },
    1: {
        user_id: 112,
        user_name: "use112",
        isActive: 1
    },
    2: {
        user_id: 113,
        user_name: "use113",
        isActive: 0
    },
    ...
}; 

var orders = {  
    888: {
        order_id: 888, 
        user_id: 111
    }, 
    889: {
        order_id: 889, 
        user_id: 111
    }, 
    890: {
        order_id: 890, 
        user_id: 113
    }
};

让我得到这个结果的最佳实践（在效率方面）是什么 订单（订单id数组的值）的用户id（作为键的用户id）：

必须使用“user”对象/数组，因为我的user变量是一个过滤的用户列表，userToOrder数组应该获取一些特定用户的所有订单ID，并从中创建一个新对象

• 没有循环，只有纯es6功能
• 尝试避免使用

  .forEach（）

  进行这种练习，除非这是不可能的
• 除非有“香草es6”的例子，否则没有loadash答案

这是我最后的尝试，但没有成功：

let userToOrdersArray = users.map( function(user) {

    /*Object.values(orders).reduce((newObj, orderData) => {
        newObj[user.user_id][] = orderData.order_id;
    }, {});*/

    Object.values(orders).filter(function(orderData) {
        return (orderData.user_id === user.user_id); 
    });

});

console.log(userToOrdersArray); 

你可以使用这个方法

var用户={
111: {
用户id:111，
用户名：“user111”，
i活动：0
},
112: {
用户id:112，
用户名：“use112”，
行动：1
},
113: {
用户识别号：113，
用户名：“use113”，
i活动：0
},
};
风险值订单={
888: {
订单号：888，
用户识别码：111
},
889: {
订单号：889，
用户识别码：111
},
890: {
订单号：890，
用户识别码：113
}
};
//获取所有属性值
var res=对象值（订单）
//迭代值
.reduce（函数（obj，{user\u id，order\u id}）{//使用解构功能提取属性
//检查用户数组中是否存在用户id
if（用户中的用户id）{
//定义ID的数组（如果以前未定义）
obj[user_id]=obj[user_id]| |[]；
//将值推送到数组
obj[用户id]。推送（订单id）；
}
//返回对象
返回obj；
//将初始值设置为对象
}, {})
console.log（res）

我在这里假设，对于

用户

对象，键始终等于

用户id

属性

const用户={
111: {
用户id:111，
用户名：“user111”，
i活动：0
},
112: {
用户id:112，
用户名：“use112”，
行动：1
},
113: {
用户识别号：113，
用户名：“use113”，
i活动：0
},
};
常量命令={
888: {
订单号：888，
用户识别码：111
},
889: {
订单号：889，
用户识别码：111
},
890: {
订单号：890，
用户识别码：113
}
};
const-groupOrdersByUsers=（usersArr，ordersar）=>usersArr.map（id=>（{[id]：ordersar.filter（（{user\u id}）=>user\u id==id}））；
log（groupOrdersByUsers（Object.key（用户）、Object.value（订单））这应该可以做到

const用户={
0: {
用户id:111，
用户名：“user111”，
i活动：0
},
1: {
用户id:112，
用户名：“use112”，
行动：1
},
2: {
用户识别号：113，
用户名：“use113”，
i活动：0
},
}
常数顺序={
888: {
订单号：888，
用户识别码：111
}, 
889: {
订单号：889，
用户识别码：111
}, 
890: {
订单号：890，
用户识别码：113
}
}
const getOrderIdsFromUserId=（用户id，订单）=>
对象。值（顺序）。减少(
（订单号，订单）=>
order.user\u id==user\u id？[order.order\u id，…order\u id]：order\u id，
[]
)
常数f=（用户、订单）=>
对象。值（用户）。减少(
（y，用户）=>({
Y
[user.user\u id]：getOrderIdsFromUserId（user.user\u id，订单），
}),
{},
)
console.log（f（users，orders））
不完全是“纯功能性的”-您的减速机正在原地对累加器进行变异（`obj[user\u id]=obj[user\u id]|【】；obj[user\u id].push（order\u id）；`），而不是返回一个新值（新对象）。但是它不会在users对象之后进行过滤。@mbojko：它没有变异，如果定义了它，它只是重新分配，或者它将分配一个新数组，因为value
push（）
正在变异。@mbojko:是的，他想将它们分组在一起。user
112
呢？你应该知道，你正在使用的那些数字键会被转换成字符串。我建议看一下，因为它是专门为这类数据和这些任务设计的。你说得对，先生！我只是不确定你的答案是更有效的一个，还是帖子评论中提到的另一个选项（使用if语句）。哦，糟糕，正确的用户id是“用户行”（user.user_id）中的一个。最有效的可能是旧的“for”循环。不过不太漂亮。（为了两者兼备，最好做SQL方面的工作，这是SQL的生命之源……）
let userToOrdersArray = users.map( function(user) {

    /*Object.values(orders).reduce((newObj, orderData) => {
        newObj[user.user_id][] = orderData.order_id;
    }, {});*/

    Object.values(orders).filter(function(orderData) {
        return (orderData.user_id === user.user_id); 
    });

});

console.log(userToOrdersArray);