Используйте имена динамических переменных в JavaScript

В PHP вы можете делать удивительные / ужасные вещи, как это:

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

Есть ли способ сделать что-то подобное с Javascript?

Например, если у меня есть, var name = 'the name of the variable';я могу получить ссылку на переменную с именем name?

Поскольку ECMA- / Javascript - это все Objectsи Contexts(которые также являются некими объектами), каждая переменная хранится в так называемой переменной (или в случае функции, объекта активации). ).

Так что если вы создаете переменные, как это:

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

В глобальной области видимости (= НЕТ контекста функции) вы неявно записываете эти переменные в глобальный объект (= windowв браузере).

К ним можно получить доступ, используя обозначение «точка» или «скобка»:

var name = window.a;

или

var name = window['a'];

Это работает только для глобального объекта в данном конкретном случае, так как переменная объекта из глобального объекта является windowсамим объектом. В контексте функции у вас нет прямого доступа к объекту активации . Например:

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

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

new foobar();

newсоздает новый экземпляр самоопределяемого объекта (контекста). Без newобъема функции также будет global(= окно). Этот пример предупредит undefinedи 1соответственно. Если бы мы заменили this.a = 1; this.b = 2на:

var a = 1,
    b = 2;

Оба выхода оповещения будут неопределенными. В этом сценарии переменные aи bбудут храниться в объекте активации, из foobarкоторого мы не можем получить доступ (конечно, мы можем получить доступ к ним напрямую, вызвав aи b).

eval это один из вариантов.

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

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

Вы можете использовать объект окна, чтобы добраться до него.

window['myVar']

window имеет ссылку на все глобальные переменные и глобальные функции, которые вы используете.

Просто не знаю, какой плохой ответ набирает столько голосов. Это довольно простой ответ, но вы делаете его сложным.

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

Попробуй это...

Это пример:

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

Другой пример :

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

alert(coco); // display : riko

Таким образом, значение « кокос » myVariable становится переменной кокос .

Потому что все переменные в глобальной области видимости являются свойствами объекта Window.

В Javascript вы можете использовать тот факт, что все свойства являются парами ключ-значение. Энди уже упоминал об этом, но я не думаю, что его ответ показывает, как его можно использовать.

Обычно вы не пытаетесь создать переменную для хранения имени переменной, но пытаетесь сгенерировать имена переменных и затем использовать их. PHP делает это с помощью $$varнотации, но Javascript не нужен, потому что ключи свойств взаимозаменяемы с ключами массива.

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

дает 123. Обычно вы хотите построить переменную, поэтому существует косвенное направление, поэтому вы можете сделать это и наоборот.

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

2019

TL; DR

• eval оператор может запустить строковое выражение в контексте, который он вызвал, и вернуть переменные из этого контекста;
• literal objectТеоретически это можно сделать с помощью write:, {[varName]}но оно заблокировано по определению.

Поэтому я сталкиваюсь с этим вопросом, и все здесь просто играют, не предлагая реального решения. но у @Axel Heider хороший подход.

Решение есть eval. почти самый забытый оператор. (думаю, что большинство из них with())

evalОператор может динамически запускать выражение в контексте, который он вызвал. и вернуть результат этого выражения. мы можем использовать это, чтобы динамически возвращать значение переменной в контексте функции.

пример:

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

Обратите внимание, что я всегда пишу явно, выражение evalбудет выполняться. Чтобы избежать ненужных сюрпризов в коде. evalочень сильный, но я уверен, что вы уже знаете, что

Кстати, если бы это было законно, мы могли бы использовать literal objectдля захвата имени и значения переменной, но мы не можем объединить сокращенные имена и значение свойства, к сожалению, недопустимо

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

    var capture = {[varName]}

}

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

Если вы не хотите использовать глобальный объект, такой как окно или глобальный (узел), вы можете попробовать что-то вроде этого:

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

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

Мне нужно было нарисовать несколько FormData на лету, и способ объекта работал хорошо

var forms = {}

Затем в моих циклах мне нужно было создать данные формы, которые я использовал

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

Это альтернатива для тех, кому нужно экспортировать переменную с динамическим именем

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

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

Другая альтернатива - просто создать объект, ключи которого называются динамически.

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

// consume it like this
vars[someVariable];

что они имеют в виду, нет, вы не можете. нет способа сделать это. так что можно было сделать что-то вроде этого

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

}

иметь функцию создания, аналогичную той, что реализована в ECMAScript 5.

eval () не работал в моих тестах. Но добавление нового кода JavaScript в дерево DOM возможно. Итак, вот функция, которая добавляет новую переменную:

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)

Хотя у этого есть принятый ответ, я хотел бы добавить наблюдение:

В ES6 использование let не работает :

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

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

Однако использование var работает

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

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

Я надеюсь, что это может быть полезно для некоторых.

использовать объект тоже здорово.

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