Как вернуть массив путей к значению во вложенном объекте JavaScript?

Question

Я пытаюсь преобразовать объект, который может иметь различные уровни вложенности:

const obj = {
    some: {
        thing: {
            good: 'yo'
        },
        one: 'else'
    },
    something: {
        bad: 'oy'
    },
    somethingtasty: 'mmm'
}

в массив объектов, содержащий исходный путь к значению и значение:

const arr = [{
        path: 'some.thing.good',
        value: 'yo'
    }, {
        path: 'some.one',
        value: 'else
    }, {
        path: 'something.bad',
        value: 'oy'
    }, {
        path: 'somethingtasty',
        value: 'mmm'
    }]

Я нашел полезный ответ на SO на похожий вопрос, касающийся объектов разной вложенности:

https://stackoverflow.com/a/2631198

Но это не решает

• a: как обрабатывать переменные вложенные глубины
• b: как обращаться с переменными ключами

Я также пытался посмотреть, есть ли у lodash метод (или методы), который может помочь, например:

https://github.com/node4good/lodash-contrib/blob/master/docs/_.object.selectors.js.md#getpath

или

https://lodash.com/docs/4.17.11#flatMapDeep

Но это не поможет, если я не знаю путь к значениям, которые мне нужно получить.

Есть ли в javascript способ проходить через объект и сохранять его ключи и значение в массиве?

Answer 1

Вы можете сделать это, используя метод reduce для создания рекурсивной функции.

const obj = {"some":{"thing":{"good":"yo"},"one":"else"},"something":{"bad":"oy"},"somethingtasty":"mmm"}

function paths(obj, prev = "") {
  return Object.keys(obj).reduce((r, e) => {
    const path = prev + (prev ? '.' + e : e);
    const value = obj[e];

    if (typeof value == 'object') {
      r.push(...paths(value, path))
    } else {
      r.push({path,value})
    }

    return r
  }, [])
}

const result = paths(obj)
console.log(result)

Answer 2

Вы можете использовать итеративный и рекурсивный подход.

function getPathes(object, temp = '') {
    return Object
        .entries(object)
        .reduce(
            (r, [key, value]) => 
                (path =>  r.concat(value && typeof value === 'object'
                    ? getPathes(value, path)
                    : { path, value }))
                (temp + (temp && '.') + key),
            []
        );
}

const obj = { some: { thing: { good: 'yo' }, one: 'else' }, something: { bad: 'oy' }, somethingtasty: 'mmm' };

console.log(getPathes(obj));

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

Answer 3

const obj = {
    some: {
        thing: {
            good: 'yo'
        },
        one: 'else'
    },
    something: {
        bad: 'oy'
    },
    somethingtasty: 'mmm'
}

const deepLinkFinder = (obj) => {
    let arr = []
    const getKeyPath = (obj, path) => {
        for (const key of Object.keys(obj)) {
            if (typeof obj[key] === 'object')
                getKeyPath(obj[key], path ?
                    `${path}.${key}` :
                    `${key}`)
            else
                arr.push({
                    path: path ?
                        `${path}.${key}` :
                        `${key}`,
                    value: obj[key]
                })
        }
    }
    getKeyPath(obj)
    return arr
}

console.log(deepLinkFinder(obj))

Answer 4

Один из возможных подходов заключается в рекурсивной итерации по Object.entries:

const obj = {
    some: {
        thing: {
            good: 'yo'
        },
        one: 'else'
    },
    something: {
        bad: 'oy'
    },
    somethingtasty: 'mmm'
};
const getNested = (obj, propArr) => {
  const [prop, value] = Object.entries(obj)[0];
  propArr.push(prop);
  if (typeof value === 'object') {
    return getNested(value, propArr);
  }
  return { path: propArr.join('.'), value };
};
const arr = Object.entries(obj)
  .map(([top, value]) => 
    typeof value === 'object' ? getNested(obj, [top]) : ({ path: top, value })
  );
console.log(arr);