Question

我们说我有以下javascript对象

var obj = {
            a:{
                b:"value",
                c:{
                    d:"value2"
                }
            }
        }

使用＆＃34; d＆＃34;输入时会有什么功能？对象（例如，function getPath(obj, d)），输出＆＃34; a.c.d＆＃34;串？我尝试了各种各样的事情，包括object-path，但它似乎并没有为此设计

Answer 1

您可以使用迭代和递归方法。

function getPath(object, key) {

    function iter(o, p) {
        if (typeof o === 'object') {
            return Object.keys(o).some(function (k) {
                return iter(o[k], p.concat(k));
            });
        }
        if (p[p.length - 1] === key) {
            path = p;
            return true;
        }
    }

    var path = [];
    iter(object, []);
    return path.join('.');
}

console.log(getPath({ d: { d: { d: { d: 'val' } } } }, 'd'));
console.log(getPath({ a: { b: 'value', c: { d: 'value2' } } }, 'd'));

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

Answer 2

我有一个很大的乐趣，使这一个，它生成一个列表，可以从对象中生成每个可能的路径，并返回以正确的键结尾的最长的路径，它返回一个未找到的空字符串：

function getPath(obj, key) {
    paths = []

    function getPaths(obj, path) {
        if (obj instanceof Object && !(obj instanceof Array)) {
            for (var k in obj){
                paths.push(path + "." + k)
                getPaths(obj[k], path + "." + k)
            }
        }
    }

    getPaths(obj, "")
    return paths.map(function(p) {
        return p.slice(p.lastIndexOf(".") + 1) == key ? p.slice(1) : ''
    }).sort(function(a, b) {return b.split(".").length - a.split(".").length;})[0];
}

var obj = { a:{ b:"value", c:{ d:"value2"}}};
console.log(getPath(obj, "b"))
console.log(getPath(obj, "c"))
console.log(getPath(obj, "d"))

var obj = { d:{ d:"value", d:{ d:"value2"}}};
console.log(getPath(obj, "d"))

Answer 3

您可以使用递归函数迭代对象，并保存路径，如：

function getPath(object, keyValue, path) {
  for (var k in object) {
    if (k === keyValue) {
      return path + '.' + k;
    }
    else if (typeof object[k] === 'object') {
      return getPath(object[k], keyValue, path !== '' ? path + '.' + k : k);
    }
  }
}

var obj = {
    a:{
        b:"value",
        c:{
            d:"value2"
        }
    }
};

var path = getPath(obj, 'd', '');
console.log(path);

Answer 4

你走了。您要使用的功能是findLongestPath：

＆＃13;

var obj = {
    a:{
        b:"value",
        c:{
            d:"value2"
        }
    }
};

function findAllPaths(obj, property, startString = '') {
  var pathStrings = [];
  Object.keys(obj).forEach(key => {
    if(typeof obj[key] === 'object') {
      pathStrings.push(...findAllPaths(obj[key], property, startString + key + '.'));
      return;
    }
    
    pathStrings.push(startString + key);
  });
  
  return pathStrings;
}

function findLongestPath(obj, property) {
  return findAllPaths(obj, property)
    .filter(str => str.split('').reverse().join('').slice(0, property.length) === property.split('').reverse().join(''))
    .reduce((longest, next) => longest.length >= next.length ? longest : next, '');
}

console.log(findLongestPath(obj, 'd'));

＆＃13;

findAllPaths是一个递归函数，它遍历对象并生成所有可能对象路径的数组。 findLongestPath过滤这些字符串以确保最后一个属性与给定的属性匹配，然后返回最长的属性。

从javascript对象属性创建路径

4 个答案: