检查嵌套对象在javascript中是否只包含单个键值对

我想检查一个深度嵌套的对象是否由单个键值对组成，如果是，它应该返回true，否则返回false

例如，我希望下面的代码返回

true

var test = {
              level1:
                {
                  level2:
                     {
                       level3:'level3'
                     }
                } 
            };

var test3 = 
{
  level1: {
    level2: {
      level3: {
        level4: {
          1: "1",
          2: "2",
          3: "3",
          4: "4"
        }
      }
    }
  }
}

下面的代码返回

false

var test2 = {
                level1: {
                  level2: {'a': '1', 'b': 2},
                  level3: {'a': '2', 'c': 4}
                }
            };

此外，下面的代码应返回

true

var test = {
              level1:
                {
                  level2:
                     {
                       level3:'level3'
                     }
                } 
            };

var test3 = 
{
  level1: {
    level2: {
      level3: {
        level4: {
          1: "1",
          2: "2",
          3: "3",
          4: "4"
        }
      }
    }
  }
}

我为它做了以下程序，但它不起作用

function checkNested(obj) {
  if(typeof(obj) === 'object') {
    if(Object.keys(obj).length === 1) {
      var key = Object.keys(obj);
      checkNested(obj[key])
    } else { 
      return(false);
    }
  }
  return(true);
}

---

有人能建议我如何实现它吗？

使用

var key=Object.keys（obj）

，

key

成为一个数组（包含一个键），因此

obj[key]

没有意义。您可以将

[key]

解构为：

const [key] = Object.keys(obj);
return checkNested(obj[key])

（确保

返回

递归调用）

或者，更好的方法是使用

Object.values

，因为您实际上并不关心键：

var测试={
第1级：{
第2级：{
三级：“三级”
}
}
};
var test2={
第1级：{
二级：“二级”，
三级：“三级”
}
};
函数检查嵌套（obj）{
if（类型（对象）=“对象”）{
常量值=对象值（obj）；
如果（values.length！==1）{
返回false；
}
返回checkNested（值[0]）；
}
返回true；
}
console.log（checkNested（test））；
log（checkNested（test2））带有
var key=Object.key（obj）
，
key
成为一个数组（包含一个键），因此
obj[key]
没有意义。您可以将
[key]
解构为：

const [key] = Object.keys(obj);
return checkNested(obj[key])

（确保
返回
递归调用）

或者，更好的方法是使用
Object.values
，因为您实际上并不关心键：


var测试={
第1级：{
第2级：{
三级：“三级”
}
}
};
var test2={
第1级：{
二级：“二级”，
三级：“三级”
}
};
函数检查嵌套（obj）{
if（类型（对象）=“对象”）{
常量值=对象值（obj）；
如果（values.length！==1）{
返回false；
}
返回checkNested（值[0]）；
}
返回true；
}
console.log（checkNested（test））；
log（checkNested（test2））对于下面的代码，您的代码返回false，var test3={level1:{level2:{level3:{level4:{1:“1”，2:“2”，3:“3”，4:“4”}}}}}}}是的，因为它有多个嵌套的键值对。嗨，我更新了我的问题，我希望代码即使对于test3也返回true，对于
test3
，它确实返回false。（正如您的第一条评论所指出的）我的错，我希望它返回true，即使在test3这样的情况下，您的代码对于下面的代码返回false，var test3={level1:{level2:{level3:{level4:{1:'1'，2:'2'，3:'3'，4:'4'}}}}}是的，因为它有多个嵌套的键值对。嗨，我更新了我的问题，我希望代码返回true，即使对于test3，
test3
，它也返回false。（正如您的第一条评论所指出的）我的错，我希望它返回true，即使在test3这样的情况下也是如此