ejemplos - javascript html

Obtener todas las variables en el alcance

Question

¿Hay alguna manera de obtener todas las variables que están actualmente en el alcance en javascript?

Answer 1

La forma más simple de obtener acceso a Vars en un ámbito particular

1. Abra Herramientas de desarrollo> Recursos (en Chrome)
2. Abrir archivo con una función que tiene acceso a ese alcance (tip cmd / ctrl + p para encontrar el archivo)
3. Establezca un punto de interrupción dentro de esa función y ejecute su código
4. Cuando se detiene en su punto de interrupción, puede acceder al alcance var a través de la consola (o ventana de alcance var)

Nota: Desea hacer esto contra js no minimizado.

La forma más simple de mostrar todos los Vars no privados

1. Abrir consola (en Chrome)
2. Tipo: this.window
3. Presione enter

Ahora verá un árbol de objetos que puede expandir con todos los objetos declarados.

Answer 2

1. Obtenga una lista de todas y cada una de las palabras escritas o tipadas de cualquier forma o estilo por cualquier ser humano desde el comienzo de los tiempos (definitivamente una lista finita en el sentido matemático).

2. ponlos a todos en una gran matriz escribiéndolos todos nuevamente en tu consola de desarrollo (como cadenas, para que no se genere error aquí).

3. crear una nueva matriz, y hacer un ciclo sobre su lista finita, presionando en la nueva matriz si una try / catch (haciendo justamente eso en la prueba) no termina en la captura, debido a ReferenceError (usando eval para "unstring", porque usted quiere el error aquí, si no en el alcance).

4. Tomare eso de vuelta. La lista de la que hablaba en el punto 1 no es lo suficientemente grande. Podrían haber creado variables a través de la ventana [randomlyGeneratedString] = something. Mejor recorrido por todas las cadenas que puede generar cualquier programa de computadora que se detenga en un marco de tiempo razonable, por ejemplo, el tiempo transcurrido desde la invención del computor.

OK, en serio, puedes hacerlo así, usando como lista en 1) lo que obtienes al ejecutar esprima.parse en toda tu base de código y recorrer el árbol en busca de elementos llamados "Identificador" y almacenar su "nombre". Pero luego perderá las variables que se crean como en la ventana ["file_" + i] = blah, vea 4.

Answer 3

Aunque todos responden " No " y sé que "No" es la respuesta correcta, pero si realmente necesita obtener variables locales de una función, existe una forma restringida.

Considera esta función:

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

Puede convertir su función en una cadena:

var s = f + '''';

Obtendrás la fuente de la función como una cadena

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

Ahora puede usar un analizador sintáctico como esprima para analizar el código de función y encontrar declaraciones de variables locales.

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

y encuentra objetos con:

obj.type == "VariableDeclaration"

en el resultado (he eliminado console.log(x) continuación):

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

He probado esto en Chrome, Firefox y Node.

Pero el problema con este método es que solo tiene las variables definidas en la función en sí. Por ejemplo para este:

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

solo tienes acceso a la x y no a la y . Pero aún puede usar cadenas de llamadas (arguments.callee.caller.caller.caller) en un bucle para encontrar las variables locales de las funciones de la persona que llama. Si tiene todos los nombres de variables locales, tiene variables de ámbito . Con los nombres de variables tiene acceso a valores con una evaluación simple.

Answer 4

Como todos notaron: no puedes. Pero puedes crear un obj y asignar cada var que declares a ese obj. De esta forma, puedes ver fácilmente tus vars:

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

Answer 5

En ECMAScript 6 es más o menos posible envolviendo el código dentro de una instrucción with con un objeto proxy. Tenga en cuenta que requiere un modo no estricto y es una mala práctica.

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

El proxy afirma que posee todos los identificadores a los que se hace referencia dentro, por lo que las asignaciones variables se almacenan en el destino. Para las búsquedas, el proxy recupera el valor del destino del proxy o el objeto global (no el ámbito principal). let variables let y const no están incluidas.

Inspirado por esta respuesta de Bergi .

Answer 6

No puedes.

Las variables, identificadores de declaraciones de función y argumentos para el código de función están vinculados como propiedades del Objeto Variable , que no es accesible.

Ver también:

• Cadena de alcance y resolución de identificador

Answer 7

No. Las variables "en el alcance" están determinadas por la "cadena de alcance", que no es accesible mediante programación.

Para detalles (bastantes), consulte la especificación ECMAScript (JavaScript). Aquí hay un enlace a la página oficial donde puede descargar la especificación canónica (un PDF), y aquí hay una para la versión oficial y enlazable de HTML.

Actualización basada en tu comentario a Camsoft

Las variables en el alcance de su función de evento están determinadas por donde usted define su función de evento, no cómo lo llaman. Pero , puede encontrar información útil sobre lo que está disponible para su función a través de this y argumentos al hacer algo similar a lo que señaló KennyTM ( for (var propName in ____) ) ya que eso le dirá qué hay disponible en varios objetos proporcionados a usted ( this y argumentos, si no está seguro de qué argumentos le dan, puede averiguar a través de la variable de arguments implícitamente definida para cada función).

Por lo tanto, además de lo que esté dentro del alcance debido a dónde define su función, puede averiguar qué más está disponible por otros medios al hacer:

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

(Puede ampliar eso para obtener más información útil).

En lugar de eso, sin embargo, probablemente usaría un depurador como las herramientas de desarrollo de Chrome (incluso si normalmente no usas Chrome para el desarrollo) o Firebug (incluso si normalmente no usas Firefox para el desarrollo), o Dragonfly on Opera o "F12 Developer Tools" en IE. Y lea los archivos de JavaScript que le proporcionen. Y golpéalos en la cabeza para obtener los documentos adecuados. :-)

Answer 8

Si solo desea inspeccionar las variables manualmente para ayudar a depurar, simplemente inicie el depurador:

debugger;

Directamente en la consola del navegador.

Answer 9

Si y no. "No" en casi todas las situaciones. "Sí", pero solo de manera limitada, si desea verificar el alcance global. Toma el siguiente ejemplo:

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

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

Que produce, entre más de 150 cosas más , lo siguiente:

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

Por lo tanto, es posible enumerar algunas variables en el alcance actual, pero no es confiable, sucinto, eficiente o de fácil acceso.

Una mejor pregunta es por qué quieres saber qué variables están dentro del alcance?