Question

我有一个这样的对象：

let accessArray = [{
      id: 1,
      restrictions: [{
         canAccess: true,
         users: [{
            name: 'user',
            accessLevel: [10, 20, 30]
         }]
      }]
   },
   {
      id: 2,
      restrictions: [{
         canAccess: true,
         users: [{
            name: 'user2',
            accessLevel: [10, 20]
         }]
      }]
   }
]

我想知道如何过滤以仅获取包含accessArray 30 的accessLevel个项目，在示例中，该项目是带有id = 1的项目谢谢。

Answer 1

您可以编写嵌套的some：

const accessArray = [{id:1,restrictions:[{canAccess:true,users:[{name:'user',accessLevel:[10,20,30]}]}]},{id:2,restrictions:[{canAccess:true,users:[{name:'user2',accessLevel:[10,20]}]}]}]

const level = 30;

function getAccess(level) {
  return accessArray.filter(a => 
              a.restrictions.some(b => 
                  b.users.some(c => c.accessLevel.includes(level))))
}

console.log(getAccess(30))

（这假设嵌套数组至少为空[]，而它们都不是null或undefined）

Answer 2

我怀疑这些限制，并且用户数组可以包含多个元素，而不总是一个元素，因此您可以执行以下操作：

let accessArray = [{
    id: 1,
    restrictions: [{
      canAccess: true,
      users: [{
        name: 'user',
        accessLevel: [10, 20, 30]
      }]
    }]
  },
  {
    id: 2,
    restrictions: [{
      canAccess: true,
      users: [{
        name: 'user2',
        accessLevel: [10, 20]
      }]
    }]
  }
]

let output = accessArray.filter( obj =>
  obj.restrictions.some( restriction =>
    restriction.users.some( user =>
      user.accessLevel.includes(30)
    )
  )
)

console.log(output)

在此示例中，如果任何个用户具有accessLevel 30，则返回true。如果您需要 all 个用户具有accessLevel 30，则替换.some与.every。

Answer 3

您可以迭代所有对象并查找想要的键，并且该键的值是一个数组，然后检查该值，否则对所有其他找到的对象再次调用该函数。

这在不知道所需嵌套属性的路径的情况下起作用。它适用于任何深度。

const
    has = (key, value) => function iter(o) {
        return Object.entries(o).some(([k, v]) => 
            k === key && Array.isArray(v) && v.includes(value) ||
            v && typeof v === 'object' && iter(v)
        );
    };

var array = [{ id: 1, restrictions: [{ canAccess: true, users: [{ name: 'user', accessLevel: [10, 20, 30] }] }] }, { id: 2, restrictions: [{ canAccess: true, users: [{ name: 'user2', accessLevel: [10, 20] }] }] }],
    result = array.filter(has('accessLevel', 30));

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 4

您可以使用过滤器功能仅返回所需的内容：

let accessArray = [{
    id: 1,
    restrictions: [{
      canAccess: true,
      users: [{
        name: 'user',
        accessLevel: [10, 20, 30]
      }]
    }]
  },
  {
    id: 2,
    restrictions: [{
      canAccess: true,
      users: [{
        name: 'user2',
        accessLevel: [10, 20]
      }]
    }]
  }
]

console.log(accessArray.filter(a => a.restrictions.some(b => b.users.some( c => c.accessLevel.includes(30)))))

Answer 5

这将检查多个限制对象中的多个用户

accessArray.filter(arr => {
    return arr.restrictions.filter(re => {
        return re.users.filter(user => user.accessLevel.includes(30)).length>0;
    }).length>0;
})

或单行

accessArray.filter(arr => arr.restrictions.filter(re => re.users.filter(user => user.accessLevel.includes(30)).length>0).length>0)

Answer 6

accessArray.filter(arr => arr.restrictions.filter(re => re.users.filter(user => user.accessLevel.includes(30))))

如何基于4级嵌套数组过滤数组？

6 个答案: