Javascript 连接以访问对象属性

可能重复：

我想动态生成对对象属性的访问

如果我试图访问

mydata[I].val.name

我会得到

somename

如果我像

mydata[I]+bar[j]

（其中bar[j]='.val.name'）那样尝试，它会失败

我如何动态地创建这样的东西？这样我就可以使用用户生成的值访问对象的任何属性了

---

一些代码：

如果我有一个对象，我希望能够遍历它的属性，收集我感兴趣的属性。理想情况下，我希望如下所示：

var processData = function (data, keys, values) {
  var returnData = [], i, j, k;
  var parsedData = JSON.parse(data);
  var keys = keys || null;
  var values = values || null;
  var datalen = parsedData.length;

  for (i = 0; i < datalen; i++) {
      returnData[i] = {};
      for(j = 0; j< keys.length; j++){
          for(k = 0; k < values.length; k++){
              returnData[i][keys[j]] = parsedData[i] + values;
          }
      }
  }

  return returnData;
};

但这不起作用，在控制台中，我看到的是

foo=“[object object].val.name”

，而不是预期的

foo=“ACME Industries”

，如果您尝试：

new Object() + '.john.doe'

它将作为字符串连接，因此您将得到

“[object object].john.doe”

---

您应该创建一个可以处理动态属性名的函数（有很多这样的函数）。您还可能希望将

“.foo.bar”

语法作为字符串松开（除非您计划使用

eval（）

），而只使用数组。

如果您想坚持将下标构造为带有点的字符串的模式，则必须使用自己的查找函数，如下所示：

function descend(object, sub) {
    var handle = object,
        stack = sub.split('.'),
        history = [],
        peek;

    while (handle[stack[0]]) {
        if (peek) {
            history.push(peek);
        }
        peek = stack.shift();
        handle = handle[peek];
    }

    if (stack.length > 0) {
        history.push(peek);
        throw "Traversal error, could not descend to '" + stack.join('.') + "' from '" + history.join('.') + "'.";
    }

    return handle;
}

var x = {
    a: {
        b: {
            c: 15
        },
        d: 4
    }
};

console.log(descend(x, "a"));
console.log(descend(x, "a.b"));
console.log(descend(x, "a.b.c"));
console.log(descend(x, "a.d"));

function processData(data, keys, values) {
    if (keys.length !== values.length) {
        throw "Mismatched keys and value lookups";
    }

    var i,
        len = keys.length,
        gathered = {},
        k,
        scratch,
        v;

    for (i = 0; i < len; i += 1) {
        k = descend(data, keys[i]);
        scratch = values[i].split('.');
        scratch.shift();
        v = descend(k, scratch.join('.'));
        gathered[keys[i]] = v;
    }

    return gathered;
}

var data = {
    foo: {
        val: {
            name: "ACME Industries"
        }
    },
    bar: {
        val: {
            date: (new Date())
        }
    }
};
var keys = ["foo","bar"];
var values = [".val.name", ".val.date"];
processData(data, keys, values);

功能下降（对象、子对象）{
变量句柄=对象，
stack=sub.split（'.'），
历史=[]，
偷看；
while（句柄[堆栈[0]]）{
如果（偷看）{
历史。推（看）；
}
peek=stack.shift（）；
把手=把手[窥视]；
}
如果（堆栈长度>0）{
历史。推（看）；
抛出“遍历错误，无法从“+”历史记录中下降到“+”堆栈中的“+”连接（“）+”；
}
返回手柄；
}
变量x={
a:{
b:{
c:15
},
d:4
}
};
控制台日志（下降（x，“a”）；
控制台日志（下降（x，“a.b”）；
控制台日志（下降（x，“a.b.c”）；
控制台日志（下降（x，“a.d”）；
函数processData（数据、键、值）{
if（keys.length！==values.length）{
抛出“不匹配的键和值查找”；
}
var i，
len=键。长度，
聚集={}，
K
划痕
v
对于（i=0；i

---

请注意：如果没有这种类型的查找，这将比不上编码的性能。

如果我理解正确，您需要使用

mydata[i]["val"]["name"]

所以，我会用这样的方法：

var result =getItemByValuesPath(myData[i],values);
alert(result);

function getItemByValuesPath(item, values)
{
    var result = item;

    var vals = values.split(".");
    for(var j=0; j<values.length; j++)
    {
        if(result==undefined)
            {
                    return null;
            }
    result = result[values[j]];
    }
}

var result=getItemByValuesPath（myData[i]，值）；
警报（结果）；
函数getItemByValuesPath（项，值）
{
var结果=项目；
var VAL=值。拆分（“.”）；
对于（var j=0；jc）您可以发布一个您正在使用的对象的示例吗？我也会注意将对象和参数命名为相同的名称，它看起来很混乱，可能会导致问题。^^^^同意。
mydata[I]+bar[j]
正在连接这些值。我已更新了我的答案，以使用问题末尾的查询，并演示了它的工作原理。添加：untested processData（）function tested processData（）函数如果这种类型的查找不起作用，会是什么类型？使用数组作为堆栈而不是带点的字符串的查找至少会有一点起作用。
var result =getItemByValuesPath(myData[i],values);
alert(result);

function getItemByValuesPath(item, values)
{
    var result = item;

    var vals = values.split(".");
    for(var j=0; j<values.length; j++)
    {
        if(result==undefined)
            {
                    return null;
            }
    result = result[values[j]];
    }
}