返回所有深度对象的好方法'；使用javascript中的值创建嵌套键

我需要访问并返回对象中所有深度嵌套的键，并基于键返回它们

比如我有

const chatSettings = {
  name: {
    questions: {
      question: 'What\'s your name?',
      fields: [
        {
          field: 'textinput',
          type: 'text',
          key: 'firstname',
          label: 'First name'
        },
        {
          field: 'textinput',
          type: 'text',
          key: 'lastname',
          label: 'Last name'
        },
      ]
    }
  },
  email: {
    questions: {
      question: 'Okay. {{username}}. Now type your email addess',
      fields: [
        {
          field: 'textinput',
          type: 'email',
          key: 'email',
          label: 'Email'
        }
      ]
    }
  }
}

我需要类似于，

getAllValuesForKey（聊天设置，'key'）

，它将返回

['firstname'，'lastname'，'email']

---

考虑到这些对象中的某些对象甚至可能没有此键，您知道如何以高性能的方式执行此操作吗？

您可以使用

reduce

方法创建递归函数并返回数组

const data={“name”：{“questions”：{“questions”：“你叫什么名字？”，“fields”：[{“field”：“textinput”，“type”：“text”，“key”：“firstname”，“label”：“firstname”}，{“field”：“textinput”，“type”：“text”，“key”：“lastname”，“label”：“lastname”}}，}，“email”：{“questions”：{“questions”：“好的。{{username}。现在键入你的电子邮件地址”，“fields:{“fields”：“fields”：“textinput”：“textinput”，“类型”：“电子邮件”，“键”：“电子邮件”，“标签”：“电子邮件”}]}}
函数查找深度（数据、键）{
返回Object.keys（数据）.reduce（（r，e）=>{
if（数据类型[e]=“object”）r.push（…查找深度（数据[e]，键））
if（key==e）r.push（数据[e]）
返回r
}, [])
}
log（find_deep（data，'key'））

您可以使用带有类型检查的递归函数并减少对象

函数getValues（对象、键）{
返回对象&&typeof对象==='object'
对象
.条目（对象）
.reduce（（r[k，v]）=>r.concat（k==key？v:getValues（v，key）），[]））
: [];
}
var chatSettings={name:{questions:{question:{你叫什么名字？}，字段：[{field:'textinput'，type:'text'，key:'firstname'，label:'firstname'}，{field:'textinput'，type:'text'，key:'lastname'，label:{questions:{question:'ok.{{{{username}}。现在键入你的电子邮件地址，字段：[{字段：'textinput'，键入：'email'，键：'email'，标签：'email'}]}，
values=getValues（聊天室设置，'key'）；
console.log（值）；

const chatSettings={
姓名：{
问题:{
问题：“你叫什么名字？”，
字段：[
{
字段：“textinput”，
键入：“文本”，
关键字：“firstname”，
标签：“名字”
},
{
字段：“textinput”，
键入：“文本”，
关键字：“lastname”，
标签：“姓氏”
},
]
}
},
电邮：{
问题:{
问题：“{username}}好的。现在键入您的电子邮件地址”，
字段：[
{
字段：“textinput”，
键入：“电子邮件”，
关键字：“电子邮件”，
标签：“电子邮件”
}
]
}
}
}
函数getAllValuesByKey（对象，键）{
让值=[]
if（数组isArray（obj））{
对象forEach（o=>{
let value=getAllValuesByKey（o，键）
如果（value&&value.length>0）{
值=值。concat（值）
}
})
}else if（对象的类型=='object'）{
Object.keys（obj.forEach）（k=>{
if（k==键）{
值。推送（对象[k]）
}
if（Array.isArray（obj[k]）| | obj[k]的类型=='object'）{
let value=getAllValuesByKey（对象[k]，键）
如果（value&&value.length>0）{
值=值。concat（值）
}
}
})
}
返回值
}
log（getAllValuesByKey（chatSettings，'key'））

您可以编写一个遍历对象的函数（可能是递归的）你也可以使用像Lodash这样的库。到目前为止你做了什么？迭代对象的键/值对，如果值是一个对象，用这个对象调用函数，否则如果键匹配搜索条件，将它添加到匹配列表中-我想这是一个基本算法，但是如果你搜索一个键呢其值是对象而不是原语（例如，如果搜索

问题

），该对象是否应包括在匹配列表中？使用

对象。条目