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

如何解决按特定顺序在对象数组中查找元素

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

当前权重为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,}
        }
    })
    if (!roleAccHolder) {
        const roleManager = roleArr.find((role) => {
            if (role.role === process.env.ROLE_MANAGER) {
                roleReturn = {
                    role: role.role,}
            }
        })
    }
}

有人可以帮助我改善功能吗？

解决方法

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

但是您需要记住一点小事情

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: 3 } ];
console.log(getHighestRole(role_array));

---

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

// global variable
// ROLE_WEIGHTS = {[process.env.ROLE_ADMIN]: 1,'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: 3 } ];
console.log(getHighestRole(role_array));

,

这应该有效：

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);

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