Получение всех переменных в области видимости

Есть ли способ получить все переменные, которые в настоящее время находятся в области видимости в JavaScript?

Нет. Переменные "в области видимости" определяются "цепочкой областей действия", которая недоступна программно.

Для деталей (довольно много), проверьте спецификацию ECMAScript (JavaScript). Вот ссылка на официальную страницу , где вы можете скачать каноническую спецификацию (а) PDF, и вот один к официальной, вулканизующемуся HTML версии.

Обновление на основе вашего комментария к Camsoft

Переменные в области видимости вашей функции события определяются тем, где вы определяете свою функцию события, а не тем, как они ее вызывают. Но вы можете найти полезную информацию о том, что доступно для вашей функции через thisаргументы и аргументы, выполнив что-то в соответствии с тем, на что указал KennyTM ( for (var propName in ____)), так как это скажет вам, что доступно для различных предоставленных вам объектов ( thisи аргументов; если вы не уверен, какие аргументы они вам дают, вы можете узнать через argumentsпеременную, которая неявно определена для каждой функции).

Таким образом, в дополнение к тому, что находится в области действия, из-за того, где вы определяете свою функцию, вы можете узнать, что еще доступно другими способами, выполнив:

var n, arg, name;
alert("typeof this = " + typeof this);
for (name in this) {
    alert("this[" + name + "]=" + this[name]);
}
for (n = 0; n < arguments.length; ++n) {
    arg = arguments[n];
    alert("typeof arguments[" + n + "] = " + typeof arg);
    for (name in arg) {
        alert("arguments[" + n + "][" + name + "]=" + arg[name]);
    }
}

(Вы можете расширить это, чтобы получить больше полезной информации.)

Вместо этого, однако, я бы, вероятно, использовал отладчик, такой как инструменты разработчика Chrome (даже если вы обычно не используете Chrome для разработки) или Firebug (даже если вы обычно не используете Firefox для разработки), или Dragonfly в Opera или «Инструменты разработчика F12» в IE. И прочитайте все файлы JavaScript, которые они вам предоставляют. И бить их по голове для правильных документов. :-)

Хотя все отвечают « Нет », и я знаю, что «Нет» - правильный ответ, но если вам действительно нужно получить локальные переменные функции, есть ограниченный путь.

Рассмотрим эту функцию:

var f = function() {
    var x = 0;
    console.log(x);
};

Вы можете преобразовать свою функцию в строку:

var s = f + '';

Вы получите источник функции в виде строки

'function () {\nvar x = 0;\nconsole.log(x);\n}'

Теперь вы можете использовать парсер наподобие esprima для разбора кода функции и поиска объявлений локальных переменных.

var s = 'function () {\nvar x = 0;\nconsole.log(x);\n}';
s = s.slice(12); // to remove "function () "
var esprima = require('esprima');
var result = esprima.parse(s);

и найти объекты с:

obj.type == "VariableDeclaration"

в результате (я удалил console.log(x)ниже):

{
    "type": "Program",
    "body": [
        {
            "type": "VariableDeclaration",
            "declarations": [
                {
                    "type": "VariableDeclarator",
                    "id": {
                        "type": "Identifier",
                        "name": "x"
                    },
                    "init": {
                        "type": "Literal",
                        "value": 0,
                        "raw": "0"
                    }
                }
            ],
            "kind": "var"
        }
    ]
}

Я проверил это в Chrome, Firefox и Node.

Но проблема этого метода в том, что у вас просто есть переменные, определенные в самой функции. Например, для этого:

var g = function() {
    var y = 0;
    var f = function() {
        var x = 0;
        console.log(x);
    };
}

у вас просто есть доступ к х, а не к у . Но все же вы можете использовать цепочки вызывающего (arguments.callee.caller.caller.caller) в цикле, чтобы найти локальные переменные вызывающих функций. Если у вас есть все локальные имена переменных, значит, у вас есть переменные области видимости . С именами переменных у вас есть доступ к значениям с простым Eval.

Да и нет. «Нет» почти в каждой ситуации. «Да», но только ограниченным образом, если вы хотите проверить глобальную область. Возьмите следующий пример:

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

for ( var i in window ) {
    console.log(i, typeof window[i], window[i]);
}

Какие выходы, среди 150+ других вещей , следующие:

getInterface function getInterface()
i string i // <- there it is!
c number 3
b number 2
a number 1 // <- and another
_firebug object Object firebug=1.4.5 element=div#_firebugConsole
"Firebug command line does not support '$0'"
"Firebug command line does not support '$1'"
_FirebugCommandLine object Object
hasDuplicate boolean false

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

Лучший вопрос: почему вы хотите знать, какие переменные находятся в области видимости?

В ECMAScript 6 это более или менее возможно, если обернуть код внутри withоператора прокси-объектом. Обратите внимание, что требуется не строгий режим и это плохая практика.

function storeVars(target) {
  return new Proxy(target, {
    has(target, prop) { return true; },
    get(target, prop) { return (prop in target ? target : window)[prop]; }
  });
}
var vars = {}; // Outer variable, not stored.
with(storeVars(vars)) {
  var a = 1;   // Stored in vars
  var b = 2;   // Stored in vars
  (function() {
    var c = 3; // Inner variable, not stored.
  })();
}
console.log(vars);

Прокси-сервер утверждает, что владеет всеми идентификаторами, на которые есть ссылки with, поэтому назначения переменных сохраняются в целевом объекте. Для поиска прокси получает значение из цели прокси или глобального объекта (не родительской области). letи constпеременные не включены.

Вдохновленный этим ответом по Берги .

Ты не можешь

Переменные, идентификаторы объявлений функций и аргументы для кода функции, связаны как свойства объекта Variable , который недоступен.

Смотрите также:

• Цепочка области действия и разрешение идентификатора

Самый простой способ получить доступ к Vars в определенном объеме

1. Откройте Инструменты разработчика> Ресурсы (в Chrome)
2. Откройте файл с помощью функции, которая имеет доступ к этой области (подсказка cmd / ctrl + p, чтобы найти файл)
3. Установите точку останова внутри этой функции и запустите ваш код
4. Когда он останавливается на вашей точке останова, вы можете получить доступ к области видимости через консоль (или окно области видимости)

Примечание: вы хотите сделать это против неунифицированного JS.

Самый простой способ показать все не частные переменные

1. Открытая консоль (в Chrome)
2. Тип: это окно
3. Нажмите Enter

Теперь вы увидите дерево объектов, которое вы можете расширить всеми заявленными объектами.

Как все заметили: нельзя. Но вы можете создать объект и назначить каждый объявленный вами объект этому объекту. Таким образом, вы можете легко проверить свои переменные:

var v = {}; //put everything here

var f = function(a, b){//do something
}; v.f = f; //make's easy to debug
var a = [1,2,3];
v.a = a;
var x = 'x';
v.x = x;  //so on...

console.log(v); //it's all there

Я сделал скрипку, реализуя (по существу) выше идеи, изложенные в Iman. Вот как это выглядит, когда вы наводите курсор мыши на второй ipsum вreturn ipsum*ipsum - ...

Переменные, которые находятся в области видимости, подсвечиваются там, где они объявлены (разными цветами для разных областей). loremС красной границы затененной переменной (не входят в комплект, но находиться в области видимости , если другой Lorem далее вниз по дереву бы там не будет.)

Я использую библиотеку esprima для синтаксического анализа JavaScript и estraverse, escodegen, escope (служебные библиотеки поверх esprima). «Тяжелая работа» выполняется всеми этими библиотеками (конечно, самой сложной является сама esprima).

Как это устроено

ast = esprima.parse(sourceString, {range: true, sourceType: 'script'});

создает абстрактное синтаксическое дерево. Затем,

analysis = escope.analyze(ast);

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

Таким образом, правильный ответ на самом деле не «нет», а «да, но». «Но» важно: вам нужно переписать важные части браузера Chrome (и его devtools) на JavaScript. JavaScript - это полный язык Тьюринга, поэтому, конечно, это возможно в принципе. Невозможно сделать все это без использования всего исходного кода (в виде строки), а затем выполнить очень сложные вещи с этим.

Если вы просто хотите проверить переменные вручную, чтобы помочь отладке, просто запустите отладчик:

debugger;

Прямо в консоль браузера.