Преобразовать вложенный объект

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

Базовое решение

Одна возможность:

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}) возвращает [['a', 'b', 'c'], ['a', 'b', 'd'], ['a', 'b', 'e'], ['a', 'f'], ['g']]. Основная функция использует это, чтобы найти пути к листам, объединить их в одну строку и создать объект, у которого эти ключи связаны с соответствующим значением из вашего исходного объекта.

Answer 2

Вы можете использовать динамический подход для любого уровня вложенности объектов, сохраняя путь и базовый объект и фактический объект.

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; }

Answer 3

Для этого можно использовать Object.entries () и lower () .

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);