Question

我想使用变量的值来访问对象。

假设我有一个名为myobject的对象。

我想用这个名字填充一个变量，并使用该变量来访问该对象。

示例：

var objname = 'myobject';
{objname}.value = 'value';

Answer 1

<强>全局：

myObject = { value: 0 };
anObjectName = "myObject";
this[anObjectName].value++;

console.log(this[anObjectName]);

全球：v2

var anObjectName = "myObject";
this[anObjectName] = "myvalue"

console.log(myObject)

本地：v1

(function() {
    var scope = this;

    if (scope != arguments.callee) {
        arguments.callee.call(arguments.callee);
        return false;
    }

    scope.myObject = { value: 0 };
    scope.anObjectName = "myObject";
    scope[scope.anObjectName].value++;

    console.log(scope.myObject.value);
})();

本地：v2

(function() {  
    var scope = this;

    scope.myObject = { value: 0 };
    scope.anObjectName = "myObject";
    scope[scope.anObjectName].value++;

    console.log(scope.myObject.value);    
}).call({});

Answer 2

在变量名称周围使用方括号。

var objname = 'myobject';
{[objname]}.value = 'value';

Answer 3

该对象存在于某个范围内，因此您几乎总能通过以下语法访问该变量：

var objname = "myobject";
containing_scope_reference[objname].some_property = 'some value';

唯一让这个变得棘手的地方是当你处于封闭的范围内并且想要访问顶级局部变量时。当你有这样的事情时：

(function(){
    var some_variable = {value: 25};
    var x = "some_variable";
    console.log(this[x], window[x]); // Doesn't work
})();

你可以绕过它，而不是使用eval来访问当前的范围链...但除非你做了很多测试，否则我不推荐它知道这是最好的办法。

(function(){
    var some_variable = {value: 25};
    var x = "some_variable";
    eval(x).value = 42;
    console.log(some_variable); // Works
})();

您的最佳投注是在一个永远存在的对象中引用一个名称（如全局范围内的this或私有顶级对象在本地范围内变量）并将所有内容放在那里。

因此：

var my_outer_variable = {};
var outer_pointer = 'my_outer_variable';
// Reach my_outer_variable with this[outer_pointer]
// or window[outer_pointer]

(function(){
    var my_inner_scope = {'my_inner_variable': {} };
    var inner_pointer = 'my_inner_variable';
    // Reach my_inner_variable by using
    // my_inner_scope[inner_pointer]
})();

Answer 4

它是全局变量吗？如果是这样，它们实际上是window对象的一部分，因此您可以执行window[objname].value。

如果它是一个功能的本地，我认为没有一个好的方法来做你想要的。

Answer 5

一般情况下你不能这样做，除了在窗口范围内你可以写window[objname].value = 'value';

Answer 6

您可以使用eval：

eval(variablename + ".value = 'value'");

Answer 7

我认为Shaz对局部变量的回答很难理解，尽管它适用于非递归函数。这是另一种我认为更清晰的方式（但它仍然是他的想法，完全相同的行为）。它也不是动态访问局部变量，只是局部变量的属性。

基本上，它使用全局变量（附加到函数对象）

// Here's  a version of it that is more straight forward.
function doIt() {
    doIt.objname = {};
    var someObject = "objname";
    doIt[someObject].value = "value";    
    console.log(doIt.objname);
})();

这与创建存储变量的全局基本相同，因此您可以将其作为属性进行访问。创建一个全局来做这件事就是这样一个黑客。

这是一个更干净的黑客，它不会创建全局变量，而是使用局部变量。

function doIt() {
  var scope = {
     MyProp: "Hello"
  };
  var name = "MyProp";
  console.log(scope[name]);
}

请参阅Javascript: interpret string as object reference?

Answer 8

let players = [];
players[something] = {};
players[something].somethingElse = 'test';
console.log(players);

-> [something：{somethingElse：'test'}];

Answer 9

使用窗口[objname]时，请确保objname是全局变量。否则，有时会工作，有时会失败。窗口[objname表]。价值。

Answer 10

如果对象在某个命名空间中，即。 Company.Module.Components.Foo您可以使用此功能：

CoffeeScript的：

objByName: (name, context = window) ->
    ns = name.split "."
    func = context
    for n, i in ns
        func = func[n]
    return func

结果Js：

objByName: function(name, context) {
  var func, i, n, ns, _i, _len;
  if (context == null) {
    context = window;
  }
  ns = name.split(".");
  func = context;
  for (i = _i = 0, _len = ns.length; _i < _len; i = ++_i) {
    n = ns[i];
    func = func[n];
  }
  return func;
}

然后你可以创建一个新对象或做任何事情。注意通过。（/ p>）

var o = new (objByName('Company.Module.Components.Foo'))
objByName('some.deeply.nested.object').value

这个想法借鉴了类似的问题：How to execute a JavaScript function when I have its name as a string

Answer 11

我在回答中遇到的挑战之一是，它假设对象是单个级别。例如，

const testObj = { testKey: 'testValue' }
const refString = 'testKey';
const refObj = testObj[refString];

工作正常，但是

const testObj = { testKey:
                  { level2Key: 'level2Value' }
                }
const refString = 'testKey.level2Key';
const refObj = testObj[refString];

不起作用。

我最终要做的是构建一个访问多级对象的函数：

objVar(str) {
    let obj = this;
    const parts = str.split('.');
    for (let p of parts) {
        obj = obj[p];
    }
    return obj;
}

然后，在第二种情况下，我可以将字符串传递给此函数以找回我要查找的对象：

const testObj = { testKey:
                  { level2Key: 'level2Value' }
                }
const refString = 'testObj.testKey.level2Key';
const refObj = objVar[refString];

Answer 12

您可以通过以下方式设置对象属性：

var obj = {};
obj.whateverVarName = 'yourVal';
console.log(obj);

Answer 13

如果您已经知道可能的变量名称列表，请尝试创建一个新的Object（iconObj），其属性名称与对象名称相同，在下面的示例中，这里的iconLib变量将包含两个字符串值，即'ZondIcons'或'MaterialIcons'。 propertyName是ZondIcons或MaterialsIcon对象的属性。

   const iconObj = {
    ZondIcons,
    MaterialIcons,
  }
  const objValue = iconObj[iconLib][propertyName]

Answer 14

var micro=[{'test':'hello'}];

var device = 'test';

console.log(micro[device]);

Javascript使用变量作为对象名称

14 个答案: