Javascript 如何在物体中保留一些深道具？

如何在物体中保留一些深道具

下面是一个示例对象

    const sample_object = {
      prop1: {
        subprop1: {
          anothersubprop1: {
            properties: {realprop: {properties: {type: 'real_value', unwantedProps1: {}, unwantedProps2: {}}}
            $ref: {},
          },
          unwantedAnotherSubProp1: {},
          ...
        },
        unwantedSubProp1: {},
        ...
      },
      unwantedProp1: {},
      prop2: {
        subprop1: {
          anothersubprop1: {
            properties: {realprop: {type: 'real_value'}},
            $ref: {},
          },
          unwantedAnotherSubProp1: {},
          ...
        },
        unwantedSubProp1: {},
        unwantedSubProp2: {},
        subprop2: {
          anothersubprop1: {
            properties: {realprop: {type: 'real_value'}},
            $ref: {},
          },
          anothersubprop2: {
            properties: {
              properties: {realprop: {type: 'real_value'}},
              $ref: {},
            },
            unwantedAnotherSubProp1: {},
            unwantedAnotherSubProp2: {},
            $ref: {},
          },
          ...
        },
        unwantedSubProp3: {},
        unwantedSubProp4: {},
        ...
      },
      unwantedProp2: {},
      prop3: {
        subprop1: {
          anothersubprop1: {
            properties: {realprop: {type: 'real_value'}},
            $ref: {},
          },
        },
        subprop2: {
          anothersubprop1: {
            properties: {},
            $ref: {},
          },
          unwantedAnotherSubProp1: {},
        },
        unwantedSubProp1: {},
        unwantedSubProp2: {},
        ...
      },
      unwantedProp3: {},
...
      properties: {realprop: {type: 'real_value'}},
      $ref: {},
    };

如何在移除所有其他道具的同时只保留以下道具

            properties: {realprop: {type: 'real_value'}},
            $ref: {},

//请注意，上述两个道具中不需要的所有道具也将被移除。

还要注意的是，在上面两个我们需要更换的必要道具中

properties: {realprop: {type: 'real_value'}}

进入：

properties: {realprop: 'real_value', name: 'Real Value', size: 10}

因此，最终需要的道具将具有：

properties: {realprop: 'real_value', name: 'Real Value', size: 10},
$ref: {},

我们在这里添加了一个名为name的额外属性（这将是值'real_value'（来自realprop:'real_value'）的句子大小写形式）以及大小（这将是所有值的常量）

预期结果如下：

 const expected_object = {
      prop1: {
        subprop1: {
          anothersubprop1: {
            properties: {realprop: 'real_value', name: 'Real Value'},
            $ref: {},
          },
          ...
        },
        ...
      },
      prop2: {
        subprop1: {
          anothersubprop1: {
            properties: {realprop: 'real_value', name: 'Real Value', size: 10},
            $ref: {},
          },
          ...
        },
        subprop2: {
          anothersubprop1: {
            properties: {realprop: 'real_value', name: 'Real Value', size: 10},
            $ref: {},
          },
          anothersubprop2: {
            properties: {
              properties: {realprop: 'real_value', name: 'Real Value', size: 10},
              $ref: {},
            },
            $ref: {},
          },
          ...
        },
        ...
      },
      prop3: {
        subprop1: {
          anothersubprop1: {
            properties: {realprop: 'real_value', name: 'Real Value', size: 10},
            $ref: {},
          },
        },
        subprop2: {
          anothersubprop1: {
            properties: {realprop: 'real_value', name: 'Real Value', size: 10},
            $ref: {},
          },
        },
        ...
      },
...
      properties: {realprop: 'real_value', name: 'Real Value', size: 10},
      $ref: {},
    };

如果可以使用lodash或任何其他类似库，请建议 或任何自定义代码

---

<强> Update：我做了一个小的更新。请考虑太< /强>

< p>一个递归的方法来解决这个问题是迭代每个层直到你得到一个没有孩子的属性。

const treeTrim = (obj) => {
    let result = {}
    Object.keys(obj).forEach(e => {
        if (saveList.has(e)) {
            result[e] = obj[e]
        }

        else if (typeof (obj[e] == "object") && Object.keys(obj[e]).length > 0) {
            result[e] = treeTrim(obj[e])
        }
    })
    return result
}

const capitalize = (s) => {
    if (typeof s !== 'string') return ''
    return s.charAt(0).toUpperCase() + s.slice(1)
}

const formatProperties = (obj) => {
    let result = {}
    Object.keys(obj).forEach(e => {

        if (e === "properties" && Object.keys(obj[e]).length > 0) {
            if (obj[e].realprop && obj[e].realprop.type) {
                const value = obj[e].realprop.type
                let capitalizeValue = value.replace("_", " ").split(" ")
                capitalizeValue = capitalizeValue.map(e =>  { return capitalize(e) }).join(" ")
                result[e] = { realprop: value, name: capitalizeValue, size: capitalizeValue.length }
            }
            else {
                result[e] = obj[e]
            }
        }
        else if (typeof (obj[e] == "object") && Object.keys(obj[e]).length > 0) {
            result[e] = formatProperties(obj[e])
        }
    })
    return result
}

运行示例：

const sample\u对象={
建议1：{
次级方案1：{
另一个次级方案1：{
属性：{realprop:{type:'real_value'}}，
$ref:{}，
},
unwantedanothersubsp1:{}，
},
unwantedSubProp1:{}，
},
unwantedProp1:{}，
提案2：{
次级方案1：{
另一个次级方案1：{
属性：{realprop:{type:'real_value'}}，
$ref:{}，
},
unwantedanothersubsp1:{}，
},
unwantedSubProp1:{}，
unwantedSubProp2:{}，
次级方案2：{
另一个次级方案1：{
属性：{realprop:{type:'real_value'}}，
$ref:{}，
},
另一个例子是：{
特性：{
属性：{realprop:{type:'real_value'}}，
$ref:{}，
},
unwantedanothersubsp1:{}，
unwantedanotherp2:{}，
$ref:{}，
},
},
unwantedSubProp3:{}，
unwantedSubProp4:{}，
},
unwantedProp2:{}，
提案3：{
次级方案1：{
另一个次级方案1：{
属性：{realprop:{type:'real_value'}}，
$ref:{}，
},
},
次级方案2：{
另一个次级方案1：{
属性：{}，
$ref:{}，
},
unwantedanothersubsp1:{}，
},
unwantedSubProp1:{}，
unwantedSubProp2:{}，
},
unwantedProp3:{}，
属性：{realprop:{type:'real_value'}}，
$ref:{}，
};
const saveList=新集合（[“$ref”，“properties”]）
常量treeTrim=（obj）=>{
让结果={}
Object.keys（obj.forEach）（e=>{
if（saveList.has（e））{
结果[e]=obj[e]
}
else if（typeof（obj[e]=“object”）&&object.keys（obj[e]）.length>0）{
结果[e]=treeTrim（obj[e]）
}
})
返回结果
}
常量大写=（s）=>{
if（typeof s！=“string”）返回“”
返回s.charAt（0）.toUpperCase（）+s.slice（1）
}
常量formatProperties=（obj）=>{
让结果={}
Object.keys（obj.forEach）（e=>{
如果（e==“属性”&&Object.keys（obj[e]）。长度>0）{
if（obj[e].realprop&&obj[e].realprop.type）{
const value=obj[e].realprop.type
让capitalizeValue=value.replace（“u“，”）.split（“”）
capitalizeValue=capitalizeValue.map（e=>{return capitalize（e）}）.join（“”）
结果[e]={realprop:value，name:capitalizeValue，size:capitalizeValue.length}
}
否则{
结果[e]=obj[e]
}
}
else if（typeof（obj[e]=“object”）&&object.keys（obj[e]）.length>0）{
结果[e]=formatProperties（对象[e]）
}
})
返回结果
}
log（formattroperties（treeTrim（sample_object）））

一个具有lodash函数集的示例

const removeUnwanted = (obj, props = [], funcs = {}) => {
   const res = {}
   const readProps = (currentObj, path = '') => {
      if (typeof currentObj !== 'object') return 
      for (const key in currentObj) {
         if (props.includes(key)) {
            let value = currentObj[key]
            if (funcs[key]) value = funcs[key](value)
            _.set(res, path + key, value)
         } else {
            readProps(currentObj[key], path + key + '.')
         }
      } 
   }

   readProps(obj)
   return res
}

const transformProperties = (prop) => {
   if (prop.realprop) return { 
      realprop: prop.realprop.type
      size: prop.realprop.type.length
   }
   return prop
}

removeUnwanted(obj, ['properties', 'ref'], { properires: transformProperties })

没有lodash集函数可以是这样的

function setByPath(obj, path, value) {
  let currentOnj = obj
  const parts = path.split('.')
  const key = parts.pop()
  parts.forEach(p => {
    if (!currentObj[p]) currentOnj[p] = {}
    currentObj = currentObj[p]
  })
  currentObj[key] = value
}

范例

---

谢谢你的时间。我做了一个小小的更新。你能更新代码吗？我已经做了更新。请检查一下。请考虑小的更新：{RealPROP:RealOnValue`，名称：“实际值”，大小：10 }“消息”：“’*’指的是UMD全局，但当前文件是一个模块。考虑添加一个导入。”，@mex，考虑到，如何设置名称属性你可以找到自己的我guess@mex，请自己找到如何管理l；odash模块或自己编写set函数。这不是一项复杂的任务，它来自lodash。对。我以为它是一个占位符。