按特定顺序查找对象数组中的元素

Question

如何按特定的权重顺序找到对象数组元素？

当前权重为admin>acc_holder>manager。如果角色数组有角色admin，它会返回角色roleId，如果没有，它会找到角色acc_holder，那么manager是最后一个。我已经在底部写了代码，但它很难看，就像回调地狱。

角色对象数组：

[
{
role: "manager",
roleId: 2,
},
{
role: "admin",
roleId: 4,
},
{
role: "acc_holder",
roleId: 3,
},
]

代码：

const roleAdmin = roleArr.find((role) => {
if (role.role === process.env.ROLE_ADMIN) {
roleReturn = {
role: role.role,
roleId: role.roleId,
}
}
})
if (!roleAdmin) {
const roleAccHolder = roleArr.find((role) => {
if (role.role === process.env.ROLE_ACC_HOLDER) {
roleReturn = {
role: role.role,
roleId: role.roleId,
}
}
})
if (!roleAccHolder) {
const roleManager = roleArr.find((role) => {
if (role.role === process.env.ROLE_MANAGER) {
roleReturn = {
role: role.role,
roleId: role.roleId,
}
}
})
}
}

有人能帮我改进功能吗？

Answer 1

我在下面解释了两种方法。

但有一件小事需要你记住

role_array是否始终包含唯一的角色记录，或者同一角色是否存在多个记录？如果是这样的话，你想要的行为是什么？你想拿第一个还是最后一个。？

---

方法1(循环时保持最高角色(只需在记录上循环一次，并保持当前的最高角色。在这种方法中，如果存在多个具有相同角色的记录，那么您将始终获得最后一个。在这种情况下，时间复杂度的顺序将是O(n)

// global variable
// ROLE_WEIGHTS = {[process.env.ROLE_ADMIN]: 1, [process.env.ROLE_MANAGER]: 2, [process.env.ROLE_ACC_HOLDER]: 3};
ROLE_WEIGHTS = {'admin': 1, 'acc_holder': 2, 'manager': 3};
// main method
function getHighestRole(role_array = []) {
let highest_role = role_array[0];
role_array.forEach((record) => {
if (ROLE_WEIGHTS[highest_role.role] > ROLE_WEIGHTS[record.role]) {
highest_role = record
}
})
return highest_role;
}
role_array = [ { role: "manager", roleId: 2 }, { role: "admin", roleId: 4 }, { role: "acc_holder", roleId: 3 } ];
console.log(getHighestRole(role_array));
role_array = [ { role: "manager", roleId: 2 }, { role: "acc_holder", roleId: 3 } ];
console.log(getHighestRole(role_array));

---

方法2(先排序并获取(根据角色的权重对角色数组进行排序并获取第一个元素。在这种方法中，如果存在多个具有相同角色的记录，您将始终获得第一个。在这种情况下，时间复杂度的顺序将是排序算法。

// global variable
// ROLE_WEIGHTS = {[process.env.ROLE_ADMIN]: 1, [process.env.ROLE_MANAGER]: 2, [process.env.ROLE_ACC_HOLDER]: 3};
ROLE_WEIGHTS = {'admin': 1, 'acc_holder': 2, 'manager': 3};
// main method
function getHighestRole(role_array = []) {
return role_array.sort((a, b) => (ROLE_WEIGHTS[a.role] - ROLE_WEIGHTS[b.role]))[0];
}
role_array = [ { role: "manager", roleId: 2 }, { role: "admin", roleId: 4 }, { role: "acc_holder", roleId: 3 } ];
console.log(getHighestRole(role_array));
role_array = [ { role: "manager", roleId: 2 }, { role: "acc_holder", roleId: 3 } ];
console.log(getHighestRole(role_array));

Answer 2

这应该有效：

const roleArr = [{
role: "manager",
roleId: 2,
},
{
role: "admin",
roleId: 4,
},
{
role: "acc_holder",
roleId: 3,
},
]
// const roleOrders = [process.env.ROLE_ADMIN, process.env.ROLE_ACC_HOLDER, process.env.ROLE_MANAGER];
const roleOrders = ['admin', 'acc_holder', 'manager'];
const selectedRole = roleOrders.reduce((result, findRole) => {
return result || roleArr.find(({
role
}) => role === findRole)
}, null);
console.log(selectedRole);

您可以定义角色顺序，找到与值匹配的数组成员，并在已经找到结果时跳过该过程。