Question

转换...的最佳方法是什么？

const obj = {
  A: { B: [0, 0, 0, 0] },
  D: {
    B: [0, 0, 0, 0],
    C: [0, 0, 0, 0]
  }
}

到

const obj = {
  "A - B": [0, 0, 0, 0],
  "D - B": [0, 0, 0, 0],
  "D - C": [0, 0, 0, 0]
}

感谢您的关注

编辑：我不好。我解决了问题。需要所有对的嵌套对象。深度恒定

Answer 1

您可以使用Object.entries()和reduce()来做到这一点。

const obj = {
  A: {
    B: [0, 0, 0, 0]
  },
  D: {
    B: [0, 0, 0, 0],
    C: [0, 0, 0, 0]
  }
};

var result = Object.entries(obj).reduce((acc, [key, value]) => {
  Object.entries(value).forEach(([subKey, subValue]) => {
    acc[key + ' - ' + subKey] = subValue;
  });

  return acc;
}, {});

console.log(result);

Answer 2

基本解决方案

一种可能性：

const MikeRecordInd = data.findIndex(v => v.name === 'Mike')
const JohnRecord = data.find(v => v.name === 'John')

if (data[MikeRecordInd].value !== JohnRecord.value) {
  newData = [...data]
  newData[MikeRecordInd] = { name: 'Mike', value: JohnRecord.value }
}

更深的路径

但是创建一个可以在任何深度递归工作的版本并不难。

const convert = (obj) => 
  Object.entries (obj)
    .reduce ((a, [k1, v]) => Object .keys (v) .reduce ((a, k2) => ({
      ...a,
      [`${k1} - ${k2}`]: v [k2]
    }), a), {})

const obj = {A: { B: [0, 0, 0, 0] }, D: {B: [0, 0, 0, 0], C: [0, 0, 0, 0]}}

console .log (convert (obj))

这使用帮助功能。 // helper const findLeafPaths = (o, path = [[]]) => typeof o == 'object' && !(Array.isArray(o)) ? Object .entries (o) .flatMap ( ([k, v]) => findLeafPaths (v, path).map(p => [k, ...p]) ) : path // main function const convert= (obj) => findLeafPaths (obj) .reduce ((a, ps) => ({ ...a, [ps.join(' - ')]: ps .reduce ((o, p) => (o || {}) [p], obj) }), {}) // demonstration const obj = { A: { B: [0, 0, 0, 0] }, D: { B: [0, 0, 0, 0], C: [0, 0, 0, 0], E: { F: 42 } } } console .log (convert (obj))找到对象中所有叶节点的路径：findLeafPaths返回findLeafPaths({a: {b: {c: 1, d: 2, e: 3}, f: 4}, g: 5})。主要功能使用它来查找叶子路径，将它们连接为单个字符串，并创建一个对象，该对象具有与原始对象中的适当值相关联的那些键。

Answer 3

通过存储路径和基础对象以及实际对象，您可以对嵌套对象的任何部门采取动态方法。

function deleteNested(object, path = [], base = object) {
    Object.entries(object).forEach(([k, v]) => {
        if (v && typeof v === 'object' && !Array.isArray(v)) {
            deleteNested(v, [...path, k], base);
        } else {
            base[[...path, k].join(' - ')] = v;
            delete base[path[0]];
        }
    });
}

const obj = { A: { B: [0, 0, 0, 0] }, D: { B: [0, 0, 0, 0], C: [0, 0, 0, 0] } };

deleteNested(obj);
console.log(obj);

.as-console-wrapper { max-height: 100% !important; top: 0; }

转换嵌套对象

3 个答案:

基本解决方案

更深的路径