如何在JavaScript中清晰地表示JSON中格式良好的名称、键和值？

我正在尝试向我的用户输出一些JSON。但是，JSON的格式可能不同，JSON的深度也可能不同。它可能在1-5层深的任何地方

一些JSON示例：

[
  {
    "name": "Previous DNS Records",
    "value": [
      {
        "host": "***.co.uk",
        "class": "IN",
        "ttl": 3573,
        "type": "TXT",
        "txt": "ANY obsoletedSee draft-ietf-dnsop-refuse-any",
        "entries": [
          "ANY obsoleted",
          "See draft-ietf-dnsop-refuse-any"
        ]
      }
    ]
  },
  {
    "name": "New DNS Records",
    "value": [
      {
        "host": "***.co.uk",
        "class": "IN",
        "ttl": 3516,
        "type": "TXT",
        "txt": "ANY obsoletedSee draft-ietf-dnsop-refuse-any",
        "entries": [
          "ANY obsoleted",
          "See draft-ietf-dnsop-refuse-any"
        ]
      }
    ]
  }
]

我需要循环并以某种形式向我的用户显示键和值，无论是使用

还是

，键是其中的名称和值

---

然而，因为我不知道JSON的深度，也不知道该值是字符串还是JSON本身，所以这很棘手。这就是说，这是一个非常常见的用例，所以我想知道是否有一个库或内置的JS方法可以帮助我，但我不知道。

你可以使用我的simnpleJIterator iLife和每个节点一起玩。还预定义了“宽度第一”。
但DepthFirst似乎更适合这里：

函数demoPrint（）{
var it=new JIterator（DemoJSON（））；
做{
var el=it.Current（）；
if（el.HasOwnKey（））{
if（el.HasStringValue（））{
console.log（“Level”+it.Level+“|”+el.key+'\t'+el.value）；
}否则{
console.log（“Level”+it.Level+“|”+el.key+”⤦");
}
}else if（el.HasStringValue（））{
console.log（“Level”+it.Level+“|”+el.value）；
}
}而（it.DepthFirst（））；
}
函数DemoJSON（）{
返回[
{
“名称”：“以前的DNS记录”，
“价值”：[
{
“主持人”：“***.co.uk”，
“类”：“IN”，
“ttl”：3573，
“类型”：“TXT”，
“txt”：“任何废弃见ietf dnsop草案拒绝任何”，
“条目”：[
“任何过时的”，
“见ietf dnsop草案拒绝任何”
]
}
]
},
{
“名称”：“新DNS记录”，
“价值”：[
{
“主持人”：“***.co.uk”，
“类”：“IN”，
“ttl”：3516，
“类型”：“TXT”，
“txt”：“任何废弃见ietf dnsop草案拒绝任何”，
“条目”：[
“任何过时的”，
“见ietf dnsop草案拒绝任何”
]
}
]
}];
}
// https://github.com/eltomjan/ETEhomeTools/blob/master/HTM_HTA/JSON_Iterator_IIFE.js
"严格使用",；
var JNode=（函数（jsNode）{
函数JNode（_parent，_pred，_key，_value）{
this.parent=\u parent；
this.pred=_pred；
this.node=null；
this.next=null；
this.key=\u key；
this.value=_值；
}
JNode.prototype.HasOwnKey=function（）{返回this.key&&（typeof this.key！=“number”）；}
JNode.prototype.HasStringValue=function（）{return！（this.value instanceof Object）；}
返回JNode；
})();
var JIterator=（函数（json）{
变量根，当前，maxLevel=-1；
函数JIterator（json，父级）{
如果（parent==未定义）parent=null；
var pred=null，localCurrent；
for（json中的var子级）{
var obj=json[child]instanceof Object；
if（json instanceof Array）child=parseInt（child）；//非关联数组
如果（！root）root=localCurrent=newjnode（父、空、子、json[child]）；
否则{
localCurrent=newjnode（父、pred、子、obj？（（json[child]instanceof Array）？[]：{}）：json[child]）；
}
如果（pred）pred.next=localCurrent；
如果（parent&&parent.node==null）parent.node=localCurrent；
pred=本地电流；
如果（obj）{
var memPred=pred；
JIterator（json[child]，pred）；
pred=memPred；
}
}
如果（这个）{
电流=根；
这个水平=0；
}
}
JIterator.prototype.Current=函数（）{return Current；}
JIterator.prototype.SetCurrent=函数（newCurrent）{current=newCurrent；}
JIterator.prototype.Parent=函数（）{
var retVal=current.parent；
如果（retVal==null）返回false；
这是一级；
返回电流=返回值；
}
JIterator.prototype.Pred=函数（）{
var retVal=current.pred；
如果（retVal==null）返回false；
返回电流=返回值；
}
JIterator.prototype.Node=函数（）{
var retVal=current.node；
如果（retVal==null）返回false；
这个.Level++；
返回电流=返回值；
}
JIterator.prototype.Next=函数（）{
var retVal=current.next；
如果（retVal==null）返回false；
返回电流=返回值；
}
JIterator.prototype.Key=函数（）{return current.Key；}
JIterator.prototype.KeyDots=函数（）{return（typeof（current.key）==“number”）？“”（current.key+“：”）；}
JIterator.prototype.Value=函数（）{return current.Value；}
JIterator.prototype.Reset=函数（）{
电流=根；
这个水平=0；
}
JIterator.prototype.RawPath=函数（）{
var步骤=[]，级别=当前；
做{
if（level！=null&&level.value对象实例）{
push（level.key+（数组的level.value实例？[]：“{}”）；
}否则{
如果（level！=null）步进。推（level.key）；
否则就断了；
}
level=level.parent；
}while（level！=null）；
var retVal=“”；
retVal=steps.reverse（）；
返回返回；
}
JIterator.prototype.Path=函数（）{
var步骤=[]，级别=当前；
做{
if（level！=null&&level.value对象实例）{
变量大小=0；
var items=level.node；
如果（typeof（level.key）=“number”）步数按（'['+level.key+']'）；
否则{
while（项目）{
大小++；
items=items.next；
}
变量类型=（数组的level.value实例？