Question

我试图找出是否有一种简单的方法来获取对象的所有“路径”（由Lodash定义）的列表。

也就是说：

getPaths({ a: 3, b: { c: 4, d: 0 }})

=> 
[
  ['a'],
  ['b', 'c'],
  ['b', 'd']
]

Lodash是否有这样的机制？还是创建一个简单的方法？

Answer 1

您可以通过减少给定的嵌套路径或采用空的占位符[[]]来减少实际密钥，而无需存储到实际对象的访问路径来获取路径。

function getPaths(object) {
    return object && typeof object === 'object' && Object.keys(object).reduce((p, k) => 
        (getPaths(object[k]) || [[]]).reduce((r, a) =>
            [...r, [k, ...a]], p), []);
}

console.log(getPaths({ a: 3, b: { c: 4, d: 0 } }));

Answer 2

没有开箱即用的方法，但是您可以递归使用_.transform()来获取路径：

const getPaths = o =>
  _.transform(o, (acc, v, k) => {

    const keys = _.isObject(v) && !_.isEmpty(v) ? 
      _.map(getPaths(v), sk => _.concat(k, ...sk))
      :
      [[k]];
  
    acc.push(...keys);
  }, []);


const result = getPaths({ a: 3, b: { c: 4, d: 0 }, e: {}, f: [{ g: {h: 5}}] });

console.log(result);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

Answer 3

您可以按以下方式使用递归方法。

const getPaths = (obj, arr = [], res = []) => {
  Object.entries(obj).forEach(([key, value]) => {
    if (typeof value === 'object' && value) getPaths(value, [...arr, key], res)
    else res.push([...arr, key])
  });
  return res;
}


console.log(getPaths({ a: 3, b: { c: 4, d: 0 }}));

Answer 4

递归函数：

function getPaths(obj, prefix) {
  let result = Object.keys(obj).map(key => {
    if (typeof obj[key] == "object" && obj[key] != null) {
      return getPaths(obj[key], key);
    } else {
      return prefix ? [prefix, key] : key;
    }
  });
  return result;
}

console.log(getPaths({ a: 3, b: { c: 4, d: 0 }}));

Answer 5

好吧，如果没有包含的方法，这是我的答案：

function getPaths(obj, prefix = []) {
  return Object.keys(obj).reduce((arr, key) => {
    const path = [...prefix, key];
    const content = typeof obj[key] === 'object' ? getPaths(obj[key], path) : [path];
    return [...arr, ...content];
  }, []);
}
       
console.log(getPaths({ a: 3, b: { c: 4, d: 0, e: { f: 9} }}));
;

获取对象的所有Lodash路径的数组

5 个答案: