JavaScript：从对象数组的对象数组中，提取属性值作为数组

我有一个JavaScript对象数组，其结构如下：

somedata={
傅：{
酒吧：[
{
巴兹：[
{
someprop:‘a’
},
{
一些道具：“b”
},
{
一些道具：“c”
}
]
},
{
巴兹：[
{
一些道具：“d”
},
{
一些道具：“e”
},
{
一些道具：“f”
}
]
}
]
}
}

我想从这个JavaScript对象中提取

someprop

字段作为数组

['a'，'b'，'c'，'d'，'e'，'f']

目前，这是我将

someprop

字段提取为数组的代码逻辑：

const result=[]
somedata.foo.bar.forEach（x=>{
x、 baz.forEach（y=>{
结果：推动（y.someprop）
})
})
console.log（结果）//打印[“a”、“b”、“c”、“d”、“e”、“f”]

我试图通过创建一个函数来提高代码的可重用性：

函数提取阵列（数据、阵列、道具）{
让结果=[]
data.forEach（x=>{
x[arr].forEach（y=>{
结果。推送（y[prop]）
})
})
返回结果；
}
console.log（extractToArray（somedata.foo.bar，'baz'，sometrop'））

但有没有更简洁、优雅、更干净的方法来实现这一点

---

---

注意：涵盖对象数组，但这是关于对象数组中的对象数组（因此简单的

映射

解决方案不起作用）。

您可以创建递归函数，在任何级别上查找道具并返回数组

const somedata={“foo”：{“bar”：[{“baz”：[{“someprop”：“a”}，{“someprop”：“b”}，{“someprop”：“c”}，{“baz”：[{“someprop”：“d”}，{“someprop”：“e”}，{“someprop”：“f”}]}
函数get（数据、道具）{
常量结果=[]；
for（让我输入数据）{
如果（i==prop）result.push（数据[prop]）；
if（数据类型[i]=“object”）result.push（…get（数据类型[i]，属性））
}
返回结果；
}
log（get（somedata，'someprop'））

您可以创建递归函数，该函数将在任何级别上查找您的道具，并返回数组

const somedata={“foo”：{“bar”：[{“baz”：[{“someprop”：“a”}，{“someprop”：“b”}，{“someprop”：“c”}，{“baz”：[{“someprop”：“d”}，{“someprop”：“e”}，{“someprop”：“f”}]}
函数get（数据、道具）{
常量结果=[]；
for（让我输入数据）{
如果（i==prop）result.push（数据[prop]）；
if（数据类型[i]=“object”）result.push（…get（数据类型[i]，属性））
}
返回结果；
}
log（获取（somedata，'someprop'））

您可以使用它：

const-somedata={foo:{bar:[{baz:[{someprop:a}，{someprop:b}，{someprop:c}}，{baz:[{someprop:d}，{someprop:e}，{someprop:f}}}；
const result=somedata.foo.bar.flatMap（（{baz}）=>baz.map（（{someprop}）=>someprop））；
控制台日志（结果）您可以使用：


const-somedata={foo:{bar:[{baz:[{someprop:a}，{someprop:b}，{someprop:c}}，{baz:[{someprop:d}，{someprop:e}，{someprop:f}}}；
const result=somedata.foo.bar.flatMap（（{baz}）=>baz.map（（{someprop}）=>someprop））；
控制台日志（结果）在一个函数表达式中执行此操作的递归函数：


const extractToArray=（数据，道具）=>对象（数据）！=数据？[] 
：Object.values（data）.flatMap（v=>extractToArray（v，prop））
.concat（数据中的道具？数据[道具]：[]）；
var somedata={foo:{bar:[{baz:[{someprop:'a'}，{someprop:'b'}，{someprop:'c'}]}，{baz:[{someprop:'d'}，{someprop:'e'}，{someprop:'f'}]}
控制台.log（extractToArray（somedata，“sometrop”）在一个函数表达式中执行此操作的递归函数：


const extractToArray=（数据，道具）=>对象（数据）！=数据？[] 
：Object.values（data）.flatMap（v=>extractToArray（v，prop））
.concat（数据中的道具？数据[道具]：[]）；
var somedata={foo:{bar:[{baz:[{someprop:'a'}，{someprop:'b'}，{someprop:'c'}]}，{baz:[{someprop:'d'}，{someprop:'e'}，{someprop:'f'}]}
log（extractToArray（somedata，“someprop”）对于其他有类似问题的人，我使用


var arr=[]，obj={foo:{bar:[{baz:[{someprop:a}，{someprop:b}，{someprop:c}]}，{baz:[{someprop:d}，{someprop:e}，{someprop:f}]}
parse（JSON.stringify（obj），（k，v）=>k==='someprop'和&arr.push（v））
log（arr）
对于其他有类似问题的人，我使用


var arr=[]，obj={foo:{bar:[{baz:[{someprop:a}，{someprop:b}，{someprop:c}]}，{baz:[{someprop:d}，{someprop:e}，{someprop:f}]}
parse（JSON.stringify（obj），（k，v）=>k==='someprop'和&arr.push（v））
console.log（arr）
你说一个
map
解决方案不起作用，但是如果你特别指向数组引用，它就会起作用，这就是你目前正在做的事情。对象是JSON字符串的结果吗？我的意思是说“一个简单的
map
解决方案”不起作用。这里有一个不那么简单的（imho）映射解决方案可以工作：
somedata.foo.bar.map（i=>i.baz.map（i=>i.map（j=>j.someprop））.flat（）
@Slai no它是一个javascript对象，而不是json@kimbaudi在我看来，你最近评论中的解决方案非常优雅。对于现有的嵌套结构，您无法进一步简化。您可以说
map
解决方案不起作用，但如果您特别指向数组引用，它就会起作用，而这正是您目前正在做的。对象是JSON字符串的结果吗？我的意思是说“简单的
map
解决方案”不起作用。这里有一个不那么简单的（imho）映射解决方案可以工作：
somedata.foo.bar.map（i=>i.baz.map（i=>i.map（j=>j.someprop））.flat（）
@Slai no它是一个javascript对象，而不是json@kimbaudi你