要动态访问属性，只需使用方括号[]，如下所示:

const something = {bar: "Foobar!"}; const userInput = 'bar'; console.log ([userInput])

这个问题

这个解决方案有个大问题!(我很惊讶其他答案还没有提到这一点)。通常你只想访问你自己放在对象上的属性，你不想获取继承的属性。

这里有一个关于这个问题的例子。这里我们有一个看似无辜的程序，但它有一个微妙的错误-你能发现它吗?

const agesOfUsers = {sam: 16, sally: 22} const username = prompt('输入用户名:') if (agesOfUsers[username] !== undefined) { console.log(' ${username}是${agesOfUsers[username]}年') }其他{ Console.log (' ${username}未找到') ｝

当提示输入用户名时，如果你提供“toString”作为用户名，它会给你以下消息:“toString is function toString(){[原生代码]}years old”。问题是agesOfUsers是一个对象，因此会自动从基object类继承某些属性，如. tostring()。您可以在这里查找所有对象继承的属性的完整列表。

解决方案

请使用Map数据结构。映射的存储内容不会受到原型问题的影响，因此它们为这个问题提供了一个干净的解决方案。

const agesOfUsers = new Map() agesOfUsers。设置(“山姆”,16) agesOfUsers。设置(“莎莉”,2) console.log(agesOfUsers.get('sam')) // 16

使用具有空原型的对象，而不是默认原型。你可以使用object. create(null)来创建这样一个对象。这种类型的对象不会受到这些原型问题的影响，因为您已经显式地创建了它，它不会继承任何东西。

const agesOfUsers = Object.create(null) agesOfUsers。山姆= 16 agesOfUsers。莎莉= 22; console.log(agesOfUsers['sam']) // 16 console.log(agesOfUsers['toString']) // undefined - toString没有被继承

You can use Object.hasOwn(yourObj, attrName) to first check if the dynamic key you wish to access is directly on the object and not inherited (learn more here). This is a relatively newer feature, so check the compatibility tables before dropping it into your code. Before Object.hasOwn(yourObj, attrName) came around, you would achieve this same effect via Object.prototype.hasOwnProperty.call(yourObj, attrName). Sometimes, you might see code using yourObj.hasOwnProperty(attrName) too, which sometimes works but it has some pitfalls that you can read about here.

//尝试输入属性名"toString" //你会看到它被正确处理。 Const user = {name: 'sam'，年龄:16} const propName = prompt('输入属性名:') 如果对象。hasOwn(user, propName)) { console.log(' ${propName} = ${user[propName]} ') }其他{ console.log(' ${propName}未找到') ｝

如果你知道你试图使用的键永远不会是一个继承属性的名称(例如，可能它们是数字，或者它们都有相同的前缀，等等)，你可以选择使用原始的解决方案。

这是我的解决方案:

function resolve(path, obj) {
    return path.split('.').reduce(function(prev, curr) {
        return prev ? prev[curr] : null
    }, obj || self)
}

使用例子:

resolve("document.body.style.width")
// or
resolve("style.width", document.body)
// or even use array indexes
// (someObject has been defined in the question)
resolve("part.0.size", someObject) 
// returns null when intermediate properties are not defined:
resolve('properties.that.do.not.exist', {hello:'world'})

我遇到过这样的情况，我想把对象属性的“地址”作为数据传递给另一个函数，并填充对象(使用AJAX)，从地址数组进行查找，并在另一个函数中显示。我不能使用点表示法而不做字符串杂技，所以我认为一个数组可能是很好的传递代替。我最终做了一些不同的事情，但似乎与这篇文章有关。

这是一个类似于我想要数据的语言文件对象的示例:

const locs = {
  "audioPlayer": {
    "controls": {
      "start": "start",
      "stop": "stop"
    },
    "heading": "Use controls to start and stop audio."
  }
}

我希望能够传递一个数组，如:["audioPlayer"， "controls"， "stop"]来访问语言文本，在这种情况下是"stop"。

我创建了这个小函数，它查找“最不特定的”(第一个)地址参数，并将返回的对象重新分配给自己。然后它准备查找下一个最特定的地址参数(如果存在的话)。

function getText(selectionArray, obj) {
  selectionArray.forEach(key => {
    obj = obj[key];
  });
  return obj;
}

用法:

/* returns 'stop' */
console.log(getText(["audioPlayer", "controls", "stop"], locs)); 

/* returns 'use controls to start and stop audio.' */
console.log(getText(["audioPlayer", "heading"], locs)); 

其他人已经提到了“点”和“方”语法，所以我想以类似的方式介绍访问函数和发送参数。

Code jsfiddle

var obj = {method:function(p1,p2,p3){console.log("method:",arguments)}}

var str = "method('p1', 'p2', 'p3');"

var match = str.match(/^\s*(\S+)\((.*)\);\s*$/);

var func = match[1]
var parameters = match[2].split(',');
for(var i = 0; i < parameters.length; ++i) {
  // clean up param begninning
    parameters[i] = parameters[i].replace(/^\s*['"]?/,'');
  // clean up param end
  parameters[i] = parameters[i].replace(/['"]?\s*$/,'');
}

obj[func](parameters); // sends parameters as array
obj[func].apply(this, parameters); // sends parameters as individual values

有两种方法访问对象的属性:

点符号:something.bar 括号符号:something['bar']

括号之间的值可以是任何表达式。因此，如果属性名称存储在变量中，则必须使用括号表示:

Var something = { 栏:“foo” }; Var foo = 'bar'; //两者x = something[foo]和something[foo] = x正常工作 console.log ((foo)); console.log (something.bar)

ES5 //检查深嵌套变量

这段简单的代码可以检查嵌套深度的变量/值是否存在，而不需要检查每个变量…

var getValue = function( s, context ){
    return Function.call( context || null, 'return ' + s )();
}

Ex. -嵌套很深的对象数组:

a = [ 
    {
      b : [
          {
             a : 1,
             b : [
                 {
                    c : 1,
                    d : 2   // we want to check for this
                 }
             ]
           }
      ]
    } 
]

而不是:

if(a && a[0] && a[0].b && a[0].b[0] && a[0].b[0].b && a[0].b[0].b[0] && a[0].b[0].b[0].d && a[0].b[0].b[0].d == 2 )  // true

我们现在可以:

if( getValue('a[0].b[0].b[0].d') == 2 ) // true

干杯!