Самый быстрый способ расширить массив вложенных объектов в массив путей (lodash)

Question

У меня есть синтаксис запроса, который необходимо применить к объекту json и вернуть массив допустимых путей в объекте json.

Например, с запросом как таковым:

People.[].Dependents.[]

И следующий объект JSON:

{
    "People": [
        {
            "FirstName": "John",
            "LastName": "Doe",
            "Dependents": [
                {
                    "Name": "John First Dep"
                },
                {
                    "Name": "John Second Dep"
                }
            ]
        },
        {
            "FirstName": "Jane",
            "LastName": "Smith",
            "Dependents": [
                {
                    "Name": "Jane First Dep"
                }
            ]
        }
    ]
}

Результат будет:

[
    "People.0.Dependents.0",
    "People.0.Dependents.1",
    "People.1.Dependents.0",
]

В настоящее время я пытаюсь сделать это максимально лаконично. Любая попытка, которую я предпринял до настоящего времени, приводила к слишком большому количеству кода, и за ним невероятно трудно следовать Я что-то упускаю из виду?

Редактировать: Текущий код:

function expandQuery(data, path) {
    const parts = path.split("[]").map(s => _.trim(s, "."));
    const [outer, ...right] = parts;

    const inner = _.join(right, ".[].");

    let groupData = _.get(data, outer, []);
    if (!_.isArray(groupData)) {
        groupData = [groupData];
    }
    const groupLength = groupData.length;

    let items = [];
    for (let ind = 0; ind < groupLength; ind++) {
        items.push(outer + "." + ind.toString() + "." + inner);
    }

    const result = [];

    for (let ind = 0; ind < items.length; ind++) {
        const item = items[ind];
        if (item.includes("[]")) {
            result.push(...expandQuery(data, item));
        } else {
            result.push(_.trim(item, "."));
        }
    }
    return result;
}

Я специально ищу, чтобы сделать это короче.

Answer 1

Я тоже попробую, учтите, что когда вы используете _.get(object,'path.with.point') и в именах ключей вашего объекта есть точки, ваш код будет ломаться, я предпочитаю использовать _.get(object,['path','with','point']).

const data = {"People":[{"FirstName":"John","LastName":"Doe","Dependents":[{"Name":"John First Dep","a":[1,2]},{"Name":"John Second Dep","a":[3]}]},{"FirstName":"Jane","LastName":"Smith","Dependents":[{"Name":"Jane First Dep","a":[1]}]}]};

const flatten = arr =>
  arr.reduce((result, item) => result.concat(item))
const ARRAY = {}
const getPath = (obj, path) => {
  const recur = (result, path, item, index) => {
    if (path.length === index) {
      return result.concat(path)
    }
    if (item === undefined) {
      throw new Error('Wrong path')
    }
    if (path[index] === ARRAY) {
      const start = path.slice(0, index)
      const end = path.slice(index + 1, path.length)
      return item.map((_, i) =>
        recur(result, start.concat(i).concat(end), item, index)
      )
    }
    return recur(result, path, item[path[index]], index + 1)
  }
  const result = recur([], path, obj, 0)
  const levels = path.filter(item => item === ARRAY).length - 1
  return levels > 0
    ? [...new Array(levels)].reduce(flatten, result)
    : result
}

console.log(
  getPath(data, ['People', ARRAY, 'Dependents', ARRAY, 'a', ARRAY])
)

Answer 2

Чтобы сгладить глубоко вложенный массив, вы можете использовать _.flattenDeep. Однако, если вы не против оставить lodash, вы можете сделать что-то вроде следующего:

function getNextToken(path) {
  let token = path.trim();
  let rest = '';

  const separatorPos = path.indexOf('.');
  if (separatorPos > -1) {
    token = path.substr(0, separatorPos).trim();
    rest = path.substr(separatorPos + 1).trim();
  }

  return { token, rest };
}


const expandQuery = (data, path) => {
  const expand = (data, path, found = []) => {
    if (data === undefined) {
      return [];
    }

    const { token, rest } = getNextToken(path);
    switch (token) {
      // Got to the end of path
      case '':
        return [found.join('.')];

      // Got an array
      case '[]':
        if (data.constructor !== Array) {
          return [];
        }

        const foundPaths = [];
        let i;
        for (i = 0; i < data.length; ++i) {
          // Flatten out foundPaths
          foundPaths.push.apply(
            foundPaths,
            expand(data[i], rest, [...found, i])
          );
        }
        return foundPaths;

      // Got a property name
      default:
        return expand(data[token], rest, [...found, token]);
    }
  };
  
  return expand(data, path);
};

const query = 'People.[].Dependents.[]';
const input = {
  "People": [{
      "FirstName": "John",
      "LastName": "Doe",
      "Dependents": [{
          "Name": "John First Dep"
        },
        {
          "Name": "John Second Dep"
        }
      ]
    },
    {
      "FirstName": "Jane",
      "LastName": "Smith",
      "Dependents": [{
        "Name": "Jane First Dep"
      }]
    }
  ]
};
console.log(expandQuery(input, query));

Вероятно, не самый короткий, но он проверяет типы данных. Также null значения считаются совпадением. Если вы хотите игнорировать их, вы можете проверить, если data === null.

Answer 3

Еще один дубль:)

var _ = require('lodash');
var test = {
    "People": [
        {
            "FirstName": "John",
            "LastName": "Doe",
            "Dependents": [
                {
                    "Name": "John First Dep"
                },
                {
                    "Name": "John Second Dep"
                }
            ]
        },
        {
            "FirstName": "Jane",
            "LastName": "Smith",
            "Dependents": [
                {
                    "Name": "Jane First Dep"
                }
            ]
        }
    ]
}

function mapper(thing, prefix, paths) {
    if (_.isObject(thing)) {
        _.forEach(thing, function(value, key) {mapper(value, prefix+key+'.', paths);});
    } else if (_.isArray(thing)) {
        for (var i = 0; i < thing.length; i++) mapper(value, prefix+i+'.', paths);
    } else {
        paths.push(prefix.replace(/\.$/, ''));
    }
}

var query = 'People.[].Dependents.[]';
var paths = [];
var results;

query = new RegExp(query.replace(/\[\]/g,'\\d'));
mapper(test, '', paths); // Collect all paths
results = _.filter(paths, function(v) {return query.test(v);}); // Apply query
console.log(results);

Answer 4

Это делает то, что вы хотите, но не намного проще / короче, чем ваше решение.

function getPaths (collection, query) {
    let tokens = query.split(".")

    function walkPath (collection, [currentToken, ...restTokens], paths) {
        if (!currentToken) { // no more tokens to follow
            return paths.join(".")
        }
        if (currentToken === "[]") { // iterate array
            const elemPaths = _.range(collection.length)
            return elemPaths.map(elemPath => walkPath(collection[elemPath], restTokens, [...paths, elemPath]))
        }
        else {
            return walkPath(collection[currentToken], restTokens, [...paths, currentToken])
        }
    }

    return _.flattenDeep(walkPath(collection, tokens, []))
}

Также отсутствует обработка ошибок.
Может быть, это вам пригодится.