Javascript verwendet Variable als Objektname

Ich möchte den Wert einer Variablen verwenden, um auf ein Objekt zuzugreifen.

Angenommen, ich habe ein Objekt namens myobject.

Ich möchte eine Variable mit diesem Namen füllen und die Variable verwenden, um auf das Objekt zuzugreifen.

Beispiel:

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

Global:

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

console.log(this[anObjectName]);

Global: v2

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

console.log(myObject)

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

Lokal: v2

(function() {  
    var scope = this;

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

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

Verwenden Sie eine eckige Klammer um den Variablennamen.

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

Ist es eine globale Variable? Wenn ja, sind diese tatsächlich Teil des windowObjekts, sodass Sie dies tun können window[objname].value.

Wenn es sich um eine lokale Funktion handelt, gibt es meines Erachtens keinen guten Weg, um das zu tun, was Sie wollen.

Das Objekt ist in einem bestimmten Bereich vorhanden, sodass Sie fast immer über diese Syntax auf die Variable zugreifen können:

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

Der einzige Ort, an dem dies schwierig wird, ist, wenn Sie sich in einem geschlossenen Bereich befinden und Zugriff auf eine lokale Variable der obersten Ebene wünschen. Wenn Sie so etwas haben:

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

Sie können dies umgehen, indem Sie evalstattdessen auf die aktuelle Bereichskette zugreifen ... aber ich empfehle es nicht, es sei denn, Sie haben viele Tests durchgeführt und wissen , dass dies der beste Weg ist, um Dinge zu erledigen .

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

Ihre beste Wette ist , einen Verweis auf einen Namen haben , in einem immer-going-to-be-es - Objekt (wie thisim globalen Bereich oder ein privates Top-Level - Variable in einem lokalen Bereich) und setzte alles anderes drin.

So:

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

Sie könnten verwenden eval:

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

Sie können dies im Allgemeinen nicht tun, außer im Fensterbereich, in dem Sie schreiben können window[objname].value = 'value';

Ich denke, Shaz 'Antwort für lokale Variablen ist schwer zu verstehen, obwohl sie für nicht rekursive Funktionen funktioniert. Hier ist ein anderer Weg, den ich für klarer halte (aber es ist immer noch seine Idee, genau dasselbe Verhalten). Es wird auch nicht dynamisch auf die lokalen Variablen zugegriffen, sondern nur auf die Eigenschaft der lokalen Variablen.

Im Wesentlichen wird eine globale Variable verwendet (die an das Funktionsobjekt angehängt ist).

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

Dies entspricht im Wesentlichen dem Erstellen einer globalen Datei zum Speichern der Variablen, sodass Sie als Eigenschaft darauf zugreifen können. Ein Global zu erstellen, um dies zu tun, ist so ein Hack.

Hier ist ein sauberer Hack, der keine globalen Variablen erstellt, sondern stattdessen eine lokale Variable verwendet.

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

Siehe Javascript: Zeichenfolge als Objektreferenz interpretieren?

Stellen Sie bei Verwendung des Fensters [Objektname] sicher, dass es sich bei dem Objektnamen um globale Variablen handelt. Andernfalls wird irgendwann funktionieren und manchmal fehlschlagen. window [objname] .value.

Wenn sich das Objekt in einem Namespace befindet, z. Company.Module.Components.FooSie können diese Funktion verwenden:

CoffeeScript:

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

Resultierte 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;
}

Dann können Sie ein neues Objekt erstellen oder was auch immer tun. Beachten Sie die Eltern durch.

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

Diese Idee stammt aus einer ähnlichen Frage: Wie man eine JavaScript-Funktion ausführt, wenn ich ihren Namen als Zeichenfolge habe

Eine der Herausforderungen, die ich mit den Antworten hatte, war die Annahme, dass das Objekt eine einzelne Ebene war. Beispielsweise,

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

funktioniert gut, aber

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

funktioniert nicht.

Am Ende habe ich eine Funktion für den Zugriff auf mehrstufige Objekte erstellt:

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

Im zweiten Szenario kann ich dann die Zeichenfolge an diese Funktion übergeben, um das gesuchte Objekt zurückzugewinnen:

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

Sie können eine Objekteigenschaft folgendermaßen festlegen:

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

Wenn Sie die Liste der möglichen Variablennamen bereits kennen, erstellen Sie ein neues Objekt (iconObj), dessen Eigenschaftsname mit den Objektnamen identisch ist. Im folgenden Beispiel enthält die Variable iconLib zwei Zeichenfolgenwerte, entweder 'ZondIcons' oder 'MaterialIcons'. . propertyName ist die Eigenschaft von ZondIcons oder MaterialsIcon.

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

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

-> [etwas: {etwasElse: 'test'}];

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

var device = 'test';

console.log(micro[device]);