Javascript 通过JSON循环-特殊方式

我得到了一个非常大的嵌套JSON对象，如下所示：

让我的数据={
人物：{
玩家：{
玩家1:{输入：“玩家1”，测试：“A”}，
玩家2:{输入：“玩家2”，测试：“B”}，
玩家3:{类型：“玩家3”，测试：“C”}
},
敌人：{
步行：{
敌方步行1:{类型：“敌方步行”，测试：“…”}，
敌方步行2:{类型：“敌方步行B”，测试：“…”}，
敌方步行3:{类型：“敌方步行”，测试：“…”}
}
}
},
区块：{
墙：{
wall_1:{类型：“wallA”，测试：“…”}，
wall_2:{类型：“wallB”，测试：“…”}，
},
障碍：{
砖块：{
brick1:{类型：“brickA”，测试：“…”}，
brick2:{类型：“brickC”，测试：“…”}，
}
}
}
}

我只需要创建一个带有标志的递归函数（此处为

叶

），以指示是否还有嵌套对象

您可以跟踪使用函数参数的位置（

path

）。对于每个递归步骤，只需将键添加到路径

这将在适当的位置改变对象，但是使用相同的技术创建一个新对象应该不难，如果这是您想要的

let myData={character:{player:{player1:{type:“player1”，test:“A”}，player2:{type:“player2”，test:“B”}，player3:{type:“player3”，test:“C”}，敌方：{敌方}行走：{type:{type:“敌方}，test A”，test：“…”，敌方}，行走{type:{{wall:{wall_1:{type:“wallA”，test:“…”}，wall_2:{type:“wallB”，test:“…”}，障碍：{brick:{brick1:{type:“brickA”，test:“…”}，brick2:{type:“brickC”，test:“…”}，}
功能漫游（obj，路径=“”）{
让叶=真
Object.keys（obj.forEach）（key=>{
如果（对象的类型[键]=“对象”）{
行走（obj[关键点]，路径+'/'+关键点）
leaf=false//此对象有子对象，因此不要添加'src'属性
}
})
if（leaf）obj['src']=path
}
步行（myData）
log（myData）

如果找不到其他嵌套对象，可以创建一个新对象并将路径存储为

src

函数getUpdate（对象，路径=[]）{ 返回Object.assign（…对象 .条目（对象） .map（（[k，v]）=>v&&typeof v==='object' ？{[k]：getUpdate（v，path.concat（k））} ：{[k]：v，src:path.join（'/'）} ) ); } var object={character:{player:{player1:{type:“player1”，test:{A”}，player2:{type:“player2”，test:{B”}，player3:{type:“player3”，test:{C”}，敌方：{敌方}步行{1:{type:{type:“敌方}，test A:“}，敌方}，步行}，test 2:{type:{敌方}，test，砌块：{wall:{wall_1:{type:“wallA”，test:“…”}，wall_2:{type:“wallB”，test:“…”}，障碍：{brick:{brick1:{type:“brickA”，test:“…”}，brick2:{type:“brickC”，test:“…”}； console.log（getUpdate（object））；

---

.as控制台包装{max height:100%！important；top:0；}

在所有叶子中假设一个公共属性，如

type

，可以检查该属性

const setpath=（o，path=''）=>{
Object.keys（o.forEach）（k=>{
const currPath=path？`${path}/${k}`:k；
if（'type'在o[k]中）{
o[k].src=currPath；
}否则{
设置路径（o[k]，currPath）
}
})
}
设置路径（myData）
console.log（myData）

让myData={
人物：{
玩家：{
玩家1：{
类型：“player1”，
测试：“A”
},
玩家2：{
类型：“player2”，
测试：“B”
},
玩家3：{
类型：“player3”，
测试：“C”
}
},
敌人：{
步行：{
敌人(步行)1:{
类型：“敌方步行”，
测试：“…”
},
敌人(步行)2:{
类型：“敌方步行”，
测试：“…”
},
敌人(步行)3:{
类型：“敌方步行”，
测试：“…”
}
}
}
},
区块：{
墙：{
墙1：{
类型：“wallA”，
测试：“…”
},
墙2：{
类型：“wallB”，
测试：“…”
},
},
障碍：{
砖块：{
砖块1：{
类型：“brickA”，
测试：“…”
},
砖块2：{
类型：“brickC”，
测试：“…”
},
}
}
}
}

这是一个纯功能实现。它不修改输入，而是返回一个新对象，在所有具有

类型

字段的对象上设置了

路径

const addPath = (o = {}, path = []) =>
  // non-object? return input
  Object (o) !== o
    ? o

  // object has 'type'? assign 'path'
  : o.type !== undefined
    ? { ...o, path: [...path, o.type] .join ('/') }

  // otherwise: recur on each value with updated path
  : Object
      .entries (o)
      .reduce
        ( (acc, [key, value]) =>
            ({ ...acc, [key]: addPath (value, [...path, key]) })
        , {}
        )

在下面的浏览器中验证结果

const addPath=（o={}，path=[]）=>
对象（o）！==o
？o
：o.type！==未定义
？{…o，路径：[…路径，o.type].join（'/'）}
：对象
.条目（o）
减少
（（acc，[键，值]）=>
（{…acc[key]：addPath（值，[…path，key]））
, {}
)
让myData={
人物：{
玩家：{
玩家1:{输入：“玩家1”，测试：“A”}，
玩家2:{输入：“玩家2”，测试：“B”}，
玩家3:{类型：“玩家3”，测试：“C”}
},
敌人：{
步行：{
敌方步行1:{类型：“敌方步行”，测试：“…”}，
敌方步行2:{类型：“敌方步行B”，测试：“…”}，
敌方步行3:{类型：“敌方步行”，测试：“…”}
}
}
},
区块：{
墙：{
wall_1:{类型：“wallA”，测试：“…”}，
wall_2:{类型：“wallB”，测试：“…”}，
},
障碍：{
砖块：{
brick1:{类型：“brickA”，测试：“…”}，
brick2:{类型：“brickC”，测试：“…”}，
}
}
}
}
console.log（addPath（myData））

要获取新对象还是更新的对象