Javascript 递归返回嵌套键数组

尝试创建一个函数，该函数返回对象的键数组，包括嵌套在其中的对象。我的代码如下所示：

function keyCount(obj, arr) {
  if (arr == undefined){
    arr = []
  }
  let keys = Object.keys(obj);
  let length = keys.length;
  for (i = 0; i <= length; i++){
    if (Object.keys(obj)[i] !== undefined){
      arr.push(Object.keys(obj)[i]);
    }
  }
  for (i = 0; i <= length; i++){
    if (typeof(obj[Object.keys(obj)[i]]) === "object" && obj[Object.keys(obj)[i]] !== null && Object.keys(obj)[i] !== undefined){
      let nestedobj = obj[Object.keys(obj)[i]];
      keyCount(nestedobj,arr)
    }
  }
  return (arr);
}

应返回：

[1,2,5,3,4,6,7,8,9,10,11,12,13]

但只返回：

[1,2,5,3,4]

---

您可以获取关键点并检查该值是否为对象，然后也获取该关键点

函数getKeys（对象）{
返回对象
.keys（对象）
.reduce（（r，k）=>r.concat（k，对象[k]&&typeof对象[k]=='object'？getKeys（对象[k]）：[]，[]）；
}
var object={1:“a”，2:{3:“b”，4:“c”}，5:{6:“d”，7:“e”，8:{9:“f”，10:“g”}，11:{12:“h”，13:“i”}；
log（getKeys（object））
.as控制台包装{max height:100%！important；top:0；}
您的代码存在各种问题。最重要的是，这会导致递归调用改变循环条件。你很幸运没有得到一个无限循环

function keyCount(obj, arr) {
  "use strict";
//^^^^^^^^^^^^^ prevent mistakes with forgotten declarations
  if (arr == undefined){
    arr = []
  }
  const keys = Object.keys(obj);
//^^^^^ prefer const over let when you don't assign
  const length = keys.length;
  for (let i = 0; i < length; i++) {
//                 ^^^ don't use <=
//     ^^^ i needs to be a local variable!
    // if (keys[i] !== undefined)
//  ^^^ no longer necessary when having fixed the loop
      arr.push(keys[i]);
//             ^^^^ don't call Object.keys again
  }
  for (let i = 0; i < length; i++) {
//     ^^^          ^ same as above
    const nestedobj = obj[keys[i]]; // move this up here
//                        ^^^^ same as above
    if (typeof nestedobj === "object" && nestedobj !== null  ) {
//            ^         ^ typeof is not a function          ^ same as above
      keyCount(nestedobj, arr);
    }
  }
  return arr;
}

功能键计数（obj、arr）{
“严格使用”；
//^^^^^^^^^^^^^防止忘记声明的错误
if（arr==未定义）{
arr=[]
}
常量键=对象键（obj）；
//^^^^^不分配时，更喜欢常量而不是let
常量长度=keys.length；
for（设i=0；i让obj1={
1:“a”，
2:{
3:“b”，
4:“c”}，
5:{
6：“d”，
7：“e”，
8: {
9：“f”，
10：“g”}，
11:{
12：“h”，
13.“我”
}
}
};
var-keyArray=[]；
功能获取键（obj）{
//从当前级别获取密钥
var keys=Object.keys（obj）；
//迭代每个键，将其添加到我们的keyArray[]
对于（var i=0，x=keys.length；i，由于到目前为止发布的答案不处理圆形对象，下面是一个：


功能获取键（obj）{
let seen=新的弱集（），
keys=新集合（），
队列=[obj]；
while（queue.length）{
设obj=queue.shift（）；
如果（！obj | | typeof obj！='object'| | seen.has（obj））
继续；
见。添加（obj）；
for（让[k，v]为对象项（obj））{
添加（k）；
排队推送（v）；
}
}
返回[…键]；
}
//
怪人={a:1，b:2，c:3}
怪人。自我=怪人；
console.log（getKeys（weirdo））
可能重复@Durga这里他只要求密钥，这个问题在问题主题中有其他含义。请添加一些数据和想要的结果。检查@Durga提到的链接你真的不应该重复调用
Object.keys（obj）
。这就是您为！@georg创建的
let keys
变量，对吗？之前它由check
对象[k]
保护。@Leafyshark如果我理解您的评论：从object.keys（obj1）开始，然后循环这些结果只会使代码下降两级（顶层和下一级扫描）。使用递归循环，代码可以挖掘对象嵌套数据的深度。谢谢，这非常有帮助！
function keyCount(obj, arr) {
  "use strict";
//^^^^^^^^^^^^^ prevent mistakes with forgotten declarations
  if (arr == undefined){
    arr = []
  }
  const keys = Object.keys(obj);
//^^^^^ prefer const over let when you don't assign
  const length = keys.length;
  for (let i = 0; i < length; i++) {
//                 ^^^ don't use <=
//     ^^^ i needs to be a local variable!
    // if (keys[i] !== undefined)
//  ^^^ no longer necessary when having fixed the loop
      arr.push(keys[i]);
//             ^^^^ don't call Object.keys again
  }
  for (let i = 0; i < length; i++) {
//     ^^^          ^ same as above
    const nestedobj = obj[keys[i]]; // move this up here
//                        ^^^^ same as above
    if (typeof nestedobj === "object" && nestedobj !== null  ) {
//            ^         ^ typeof is not a function          ^ same as above
      keyCount(nestedobj, arr);
    }
  }
  return arr;
}