Use nombres de variables dinámicas en JavaScript

En PHP puedes hacer cosas increíbles / horrendas como esta:

$a = 1;
$b = 2;
$c = 3;
$name = 'a';
echo $$name;
// prints 1

¿Hay alguna forma de hacer algo así con Javascript?

Por ejemplo, si tengo una, var name = 'the name of the variable';¿puedo obtener una referencia a la variable con nombre name?

Dado que ECMA- / Javascript se trata Objectsy Contexts(que también son una especie de Objeto), cada variable se almacena en una variable llamada Variable- (o en el caso de una Función, Objeto de Activación ).

Entonces, si creas variables como esta:

var a = 1,
    b = 2,
    c = 3;

En el ámbito Global (= contexto de función NO), usted escribe implícitamente esas variables en el objeto Global (= windowen un navegador).

Se puede acceder a ellos utilizando la notación "punto" o "paréntesis":

var name = window.a;

o

var name = window['a'];

Esto sólo funciona para el objeto global en este caso particular, debido a que el objeto variable del objeto global es el windowobjeto en sí. Dentro del contexto de una función, no tiene acceso directo al objeto de activación . Por ejemplo:

function foobar() {
   this.a = 1;
   this.b = 2;

   var name = window['a']; // === undefined
   alert(name);
   name = this['a']; // === 1
   alert(name);
}

new foobar();

newcrea una nueva instancia de un objeto autodefinido (contexto). Sin newel alcance de la función también sería global(= ventana). Este ejemplo alertaría undefinedy 1respectivamente. Si reemplazáramos this.a = 1; this.b = 2con:

var a = 1,
    b = 2;

Ambas salidas de alerta estarían indefinidas. En ese escenario, las variables ay bse almacenarían en el Objeto de Activación desde el foobarcual no podemos acceder (por supuesto, podríamos acceder a ellas directamente llamando ay b).

eval Es una opción.

var a = 1;
var name = 'a';

document.write(eval(name)); // 1

Puede usar el objeto de ventana para llegar a él.

window['myVar']

window tiene una referencia a todas las variables globales y funciones globales que está utilizando.

Simplemente no sé qué mala respuesta obtiene tantos votos. Es una respuesta bastante fácil, pero la haces compleja.

// If you want to get article_count
// var article_count = 1000;
var type = 'article';
this[type+'_count'] = 1000;  // in a function we use "this";
alert(article_count);

a = 'varname';
str = a+' = '+'123';
eval(str)
alert(varname);

Prueba esto...

Esto es un ejemplo :

for(var i=0; i<=3; i++) {
    window['p'+i] = "hello " + i;
}

alert(p0); // hello 0
alert(p1); // hello 1
alert(p2); // hello 2
alert(p3); // hello 3

Otro ejemplo :

var myVariable = 'coco';
window[myVariable] = 'riko';

alert(coco); // display : riko

Entonces, el valor " coco " de myVariable se convierte en un coco variable .

Porque todas las variables en el ámbito global son propiedades del objeto Window.

En Javascript puede usar el hecho de que todas las propiedades son pares de valores clave. jAndy ya mencionó esto, pero no creo que su respuesta muestre cómo se puede explotar.

Por lo general, no está intentando crear una variable para contener un nombre de variable, sino que está tratando de generar nombres de variables y luego usarlos. PHP lo hace con $$varnotación, pero Javascript no lo necesita porque las claves de propiedad son intercambiables con las claves de matriz.

var id = "abc";
var mine = {};
mine[id] = 123;
console.log(mine.abc);

da 123. Por lo general, desea construir la variable, razón por la cual existe la indirección, por lo que también puede hacerlo al revés.

var mine = {};
mine.abc = 123;
console.log(mine["a"+"bc"]);

2019

TL; DR

• eval el operador puede ejecutar una expresión de cadena en el contexto que llamó y devolver variables de ese contexto;
• literal objectteóricamente puede hacerlo escribiendo: {[varName]}pero bloqueado por definición.

Así que me encuentro con esta pregunta y todos aquí solo juegan sin aportar una solución real. pero @Axel Heider se acerca bien.

La solución es eval. operador casi olvidado. (creo que la mayoría es with())

evalEl operador puede ejecutar dinámicamente la expresión en el contexto al que llamó. y devuelve el resultado de esa expresión. podemos usar eso para devolver dinámicamente el valor de una variable en el contexto de la función.

ejemplo:

function exmaple1(){
   var a = 1, b = 2, default = 3;
   var name = 'a';
   return eval(name)
}

example1() // return 1


function example2(option){
  var a = 1, b = 2, defaultValue = 3;

  switch(option){
    case 'a': name = 'a'; break;
    case 'b': name = 'b'; break;
    default: name = 'defaultValue';
  }
  return eval (name);
}

example2('a') // return 1
example2('b') // return 2
example2() // return 3

Tenga en cuenta que siempre escribo explícitamente la expresión evalse ejecutará. Para evitar sorpresas innecesarias en el código. evales muy fuerte pero estoy seguro de que ya lo sabes

Por cierto, si fuera legal, podríamos usar literal objectpara capturar el nombre y el valor de la variable, pero no podemos combinar los nombres de propiedad calculados y el valor de la propiedad, por desgracia, no es válido

functopn example( varName ){
    var var1 = 'foo', var2 ='bar'

    var capture = {[varName]}

}

example('var1') //trow 'Uncaught SyntaxError: Unexpected token }`

Si no desea utilizar un objeto global como window o global (nodo), puede intentar algo como esto:

var obj = {};
obj['whatever'] = 'There\'s no need to store even more stuff in a global object.';

console.log(obj['whatever']);

Necesitaba dibujar múltiples FormData sobre la marcha y la forma de objeto funcionó bien

var forms = {}

Luego, en mis bucles, donde sea que necesitaba crear un formulario de datos que utilicé

forms["formdata"+counter]=new FormData();
forms["formdata"+counter].append(var_name, var_value);

Esta es una alternativa para aquellos que necesitan exportar una variable con nombre dinámico

export {
  [someVariable]: 'some value',
  [anotherVariable]: 'another value',
}

// then.... import from another file like this:
import * as vars from './some-file'

Otra alternativa es simplemente crear un objeto cuyas claves se denominen dinámicamente

const vars = { [someVariable]: 1, [otherVariable]: 2 };

// consume it like this
vars[someVariable];

lo que quieren decir es no, no puedes. No hay forma de hacerlo. así que era posible que pudieras hacer algo como esto

function create(obj, const){
// where obj is an object and const is a variable name
function const () {}

const.prototype.myProperty = property_value;
// .. more prototype

return new const();

}

tener una función de creación como la implementada en ECMAScript 5.

eval () no funcionó en mis pruebas. Pero es posible agregar un nuevo código JavaScript al árbol DOM. Entonces, aquí hay una función que agrega una nueva variable:

function createVariable(varName,varContent)
{
  var scriptStr = "var "+varName+"= \""+varContent+"\""

  var node_scriptCode = document.createTextNode( scriptStr )
  var node_script = document.createElement("script");
  node_script.type = "text/javascript"
  node_script.appendChild(node_scriptCode);

  var node_head = document.getElementsByTagName("head")[0]
  node_head.appendChild(node_script);
}

createVariable("dynamicVar", "some content")
console.log(dynamicVar)

Aunque esto tiene una respuesta aceptada, me gustaría agregar una observación:

En ES6, el uso let no funciona :

/*this is NOT working*/
let t = "skyBlue",
    m = "gold",
    b = "tomato";

let color = window["b"];
console.log(color);

Sin embargo usando var trabajos

/*this IS working*/
var t = "skyBlue",
    m = "gold",
    b = "tomato";

let color = window["b"];
console.log(color);

Espero que esto pueda ser útil para algunos.

use Object también es genial.

var a=123
var b=234
var temp = {"a":a,"b":b}
console.log(temp["a"],temp["b"]);