Js或ES6当字段具有2个或更多嵌套级别时，按路径字符串获取对象字段，如myObj.one.two.three.field

Question

如果我有一个总是相同的基础对象：project但有时我必须动态访问它的字段，如果它可以是1个或多个嵌套对象，我该如何访问它的字段，例如：

function (myPath){
  return project[myPath];

}

在project["oneField"]

中使用myPath("oneField")时，此功能正常

但是当它嵌套到更多级别时它不起作用：

myPath("one.two.fieldName")不起作用：project["one.two.fieldName"]

不喜欢这样：project."one.two.fieldName"

Answer 1

你可以这样做（ES6）：

＆＃13;

＆＃13;

function getVal(project, myPath){
    return myPath.split('.').reduce ( (res, prop) => res[prop], project );
}

// sample data
var project = { one: { two: { fieldName: 'gotcha' } } };

// get inner field value
console.log( getVal(project, 'one.two.fieldName') );

＆＃13;

＆＃13;

＆＃13;

Answer 2

选项＃1（不推荐） - 使用eval功能：

var projects = {
  a : {
    b : {
      c : 1
    }
  }
}
function get(myPath) {
  debugger;
  return eval("projects." + myPath)
}
console.log(get('a.b.c'))

选项＃2 - 由.拆分并遍历对象中的元素：

var projects = {
  a: {
    b : { 
      c : '1'
    }
  }
}

function get(path) {
  if (path.indexOf('.')) {
    subs = path.split(".")
    ret = projects;
    for (var i = 0; i < subs.length; i++) {
      ret = ret[subs[i]]
    }
    return ret;
  } else {
    return projects[path];
  }
}

console.log(get('a'))
console.log(get('a.b'))
console.log(get('a.b.c'))

Answer 3

通常如果我做这样的事情，我会使用递归函数：

var data = {a: {b: {c: 5}}};

function getValue(obj, key) {
    var parts = key.split('.');
    return obj 
        && (parts.length === 1 
            && obj[key] || getValue(obj[parts[0]], parts.slice(1).join('.'))) 
    || null;
}

console.log(getValue(data, "a.b.c"));

JSFiddle

它写得有点简洁，但基本上如果它有一个带有点的键，它会将它调低一个级别。如果它得到的obj不存在，它将返回null。否则，一旦它下降到最后一级，它将返回它找到的值。

更广泛，可能更容易理解的版本是：

function getValue(obj, key) {
    var parts = key.split('.');
    if (!obj) {
        return null;
    } else if (parts.length === 1) {
        return obj[key];
    }

    return getValue(obj[parts.slice(1).join('.')], key);
}