Javascript는 변수를 개체 이름으로 사용

변수 값을 사용하여 개체에 액세스하고 싶습니다.

myobject라는 개체가 있다고 가정 해 보겠습니다.

이 이름으로 변수를 채우고 변수를 사용하여 개체에 액세스하고 싶습니다.

예:

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

글로벌 :

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({});

변수 이름 주위에 대괄호를 사용하십시오.

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

전역 변수입니까? 그렇다면 실제로 window개체의 일부 이므로 window[objname].value.

함수에 국한된 경우 원하는 작업을 수행하는 좋은 방법이 없다고 생각합니다.

개체는 일부 범위에 있으므로 거의 항상 다음 구문을 통해 변수에 액세스 할 수 있습니다.

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]
})();

다음을 사용할 수 있습니다 eval.

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

일반적으로이 작업을 수행 할 수 없습니다. 창 범위를 제외하고는 다음을 작성할 수 있습니다. window[objname].value = 'value';

지역 변수에 대한 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]);
}

참조 자바 스크립트 : 객체 참조와 같은 문자열을 해석?

개체가 일부 네임 스페이스에있는 경우 즉. 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;
}

그런 다음 새 개체를 만들거나 무엇이든 할 수 있습니다. 통해 괄호에 유의하십시오.

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

이 아이디어는 비슷한 질문에서 차용되었습니다. 이름이 문자열로있을 때 JavaScript 함수를 실행하는 방법

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

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

window [objname]을 사용할 때 objname이 전역 변수인지 확인하십시오. 그렇지 않으면 언젠가 작동하고 때로는 실패합니다. window [objname] .value.

제가 답변을하면서 겪었던 문제 중 하나는 객체가 단일 레벨이라고 가정한다는 것입니다. 예를 들면

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];

다음과 같이 개체 속성을 설정할 수 있습니다.

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

가능한 변수 이름 목록을 이미 알고있는 경우 속성 이름이 개체 이름과 동일한 새 Object (iconObj)를 만들어보십시오. 아래 예제에서 iconLib 변수는 'ZondIcons'또는 'MaterialIcons'의 두 문자열 값을 보유합니다. . propertyName은 ZondIcons 또는 MaterialsIcon 객체의 속성입니다.

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

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

var device = 'test';

console.log(micro[device]);