Javascript utilise une variable comme nom d'objet

Je souhaite utiliser la valeur d'une variable pour accéder à un objet.

Disons que j'ai un objet nommé myobject.

Je veux remplir une variable avec ce nom et utiliser la variable pour accéder à l'objet.

Exemple:

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

Global:

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

console.log(this[anObjectName]);

Mondial: v2

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

console.log(myObject)

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

Local: v2

(function() {  
    var scope = this;

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

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

Utilisez un crochet autour du nom de la variable.

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

Est-ce une variable globale? Si tel est le cas, ils font en fait partie de l' windowobjet, vous pouvez donc le faire window[objname].value.

Si c'est local à une fonction, je ne pense pas qu'il y ait un bon moyen de faire ce que vous voulez.

L'objet existe dans une certaine portée, vous pouvez donc presque toujours accéder à la variable via cette syntaxe:

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

Le seul endroit où cela devient délicat est lorsque vous êtes dans une portée fermée et que vous souhaitez accéder à une variable locale de niveau supérieur. Lorsque vous avez quelque chose comme ça:

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

Vous pouvez contourner cela en utilisant à la evalplace pour accéder à la chaîne de portée actuelle ... mais je ne le recommande pas à moins que vous n'ayez fait beaucoup de tests et que vous savez que c'est la meilleure façon de faire les choses.

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

Votre meilleur pari est d'avoir une référence à un nom dans un objet qui va toujours être là (comme thisdans la portée globale ou une variable de premier niveau privée dans une portée locale) et d'y mettre tout le reste.

Donc:

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

Vous pouvez utiliser eval:

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

Vous ne pouvez pas faire cela en général, sauf au niveau de la fenêtre, où vous pouvez écrire window[objname].value = 'value';

Je pense que la réponse de Shaz pour les variables locales est difficile à comprendre, bien qu'elle fonctionne pour les fonctions non récursives. Voici une autre façon dont je pense que c'est plus clair (mais c'est toujours son idée, exactement le même comportement). Il n'accède pas non plus aux variables locales de manière dynamique, mais uniquement à la propriété de la variable locale.

Essentiellement, il utilise une variable globale (attachée à l'objet de fonction)

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

Ce qui revient essentiellement à créer un global pour stocker la variable, afin que vous puissiez y accéder en tant que propriété. Créer un global pour ce faire est un tel hack.

Voici un hack plus propre qui ne crée pas de variables globales, il utilise une variable locale à la place.

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

Voir Javascript: interpréter la chaîne comme référence d'objet?

Lorsque vous utilisez la fenêtre [nom_obj], veuillez vous assurer que le nom_obj est une variable globale. Sinon, cela fonctionnera parfois et échouera parfois. window [nom_obj] .valeur.

Si l'objet est dans un espace de noms, c'est-à-dire. Company.Module.Components.Foovous pouvez utiliser cette fonction:

CoffeeScript:

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

Résultat 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;
}

Ensuite, vous pouvez créer un nouvel objet ou faire n'importe quoi. Notez les parenthèses.

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

Cette idée est empruntée à une question similaire: comment exécuter une fonction JavaScript quand j'ai son nom sous forme de chaîne

L'un des défis que j'ai eu avec les réponses est qu'il supposait que l'objet était un seul niveau. Par exemple,

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

fonctionne bien, mais

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

ne marche pas.

Ce que j'ai fini par faire, c'est créer une fonction pour accéder aux objets à plusieurs niveaux:

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

Dans le deuxième scénario, je peux alors passer la chaîne à cette fonction pour récupérer l'objet que je recherche:

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

Vous pouvez définir une propriété d'objets de cette façon:

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

Si vous connaissez déjà la liste des noms de variables possibles, essayez de créer un nouvel objet (iconObj) dont le nom des propriétés est le même que les noms d'objet, ici dans l'exemple ci-dessous, la variable iconLib contiendra deux valeurs de chaîne, soit 'ZondIcons' ou 'MaterialIcons' . propertyName est la propriété de l'objet ZondIcons ou MaterialsIcon.

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

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

-> [quelque chose: {somethingElse: 'test'}];

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

var device = 'test';

console.log(micro[device]);