Ottenere tutte le variabili in ambito

C'è un modo per ottenere tutte le variabili che sono attualmente nell'ambito nell'ambito di JavaScript?

No. Le variabili "nell'ambito" sono determinate dalla "catena dell'ambito", che non è accessibile a livello di programmazione.

Per i dettagli (parecchio), controlla la specifica ECMAScript (JavaScript). Ecco un link alla pagina ufficiale in cui è possibile scaricare le specifiche canoniche (un PDF), ed eccone uno alla versione HTML ufficiale e collegabile.

Aggiornamento basato sul tuo commento a Camsoft

Le variabili nell'ambito della funzione dell'evento sono determinate da dove si definisce la funzione dell'evento, non da come la chiamano. Tuttavia , potresti trovare informazioni utili su ciò che è disponibile per la tua funzione tramite thise argomenti facendo qualcosa in linea con ciò che KennyTM ha indicato ( for (var propName in ____)) poiché ciò ti dirà cosa è disponibile su vari oggetti forniti ( thise argomenti; se sei non sei sicuro di quali argomenti ti danno, puoi scoprire tramite la argumentsvariabile che è implicitamente definita per ogni funzione).

Quindi oltre a qualunque cosa rientri nell'ambito in cui si definisce la propria funzione, è possibile scoprire cos'altro è disponibile in altri modi facendo:

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

(Puoi estenderlo per ottenere informazioni più utili.)

Invece, probabilmente userei un debugger come gli strumenti di sviluppo di Chrome (anche se normalmente non usi Chrome per lo sviluppo) o Firebug (anche se non usi normalmente Firefox per lo sviluppo) o Dragonfly su Opera o "Strumenti per sviluppatori F12" su Internet Explorer. E leggi tutti i file JavaScript che ti forniscono. E batterli sopra la testa per i documenti adeguati. :-)

Sebbene tutti rispondano " No " e so che "No" è la risposta giusta, ma se hai davvero bisogno di ottenere variabili locali di una funzione c'è un modo limitato.

Considera questa funzione:

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

Puoi convertire la tua funzione in una stringa:

var s = f + '';

Otterrai l'origine della funzione come stringa

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

Ora puoi usare un parser come esprima per analizzare il codice funzione e trovare dichiarazioni di variabili locali.

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

e trova oggetti con:

obj.type == "VariableDeclaration"

nel risultato (ho rimosso di console.log(x)seguito):

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

Ho provato questo in Chrome, Firefox e Node.

Ma il problema con questo metodo è che hai solo le variabili definite nella funzione stessa. Ad esempio per questo:

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

hai solo accesso a xe non a y . Tuttavia, è possibile utilizzare le catene del chiamante (argomenti.callee.caller.caller.caller) in un ciclo per trovare le variabili locali delle funzioni del chiamante. Se hai tutti i nomi delle variabili locali, quindi hai le variabili dell'ambito . Con i nomi delle variabili hai accesso ai valori con una semplice valutazione.

Sì e no. "No" in quasi ogni situazione. "Sì", ma solo in modo limitato, se si desidera verificare l'ambito globale. Prendi il seguente esempio:

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

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

Che produce, tra le 150+ cose , le seguenti:

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

Quindi è possibile elencare alcune variabili nell'ambito attuale, ma non è affidabile, conciso, efficiente o facilmente accessibile.

Una domanda migliore è: perché vuoi sapere quali variabili rientrano nell'ambito di applicazione?

In ECMAScript 6 è più o meno possibile racchiudendo il codice all'interno di withun'istruzione con un oggetto proxy. Nota che richiede una modalità non rigorosa ed è una cattiva pratica.

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

Il proxy afferma di possedere tutti gli identificatori a cui si fa riferimento all'interno with, quindi le assegnazioni di variabili vengono memorizzate nella destinazione. Per le ricerche, il proxy recupera il valore dalla destinazione proxy o dall'oggetto globale (non dall'ambito padre). lete le constvariabili non sono incluse.

Ispirato da questa risposta di Bergi .

Non puoi.

Le variabili, gli identificatori delle dichiarazioni di funzioni e gli argomenti per il codice di funzione, sono associati come proprietà dell'oggetto variabile , che non è accessibile.

Guarda anche:

• Scope Chain e risoluzione dell'identificatore

Il modo più semplice per accedere a Vars in un ambito particolare

1. Apri Strumenti per gli sviluppatori> Risorse (in Chrome)
2. Apri il file con una funzione che ha accesso a quell'ambito (punta cmd / ctrl + p per trovare il file)
3. Imposta il punto di interruzione all'interno di quella funzione ed esegui il tuo codice
4. Quando si ferma al punto di interruzione, è possibile accedere all'ambito var tramite la console (o la finestra var dell'ambito)

Nota: vuoi farlo contro js non minificati.

Il modo più semplice per mostrare tutti i Vars non privati

1. Open Console (in Chrome)
2. Digitare: this.window
3. Premi Invio

Ora vedrai un albero di oggetti che puoi espandere con tutti gli oggetti dichiarati.

Come tutti hanno notato: non puoi. Ma puoi creare un oggetto e assegnare ogni var che dichiari a quell'oggetto. In questo modo puoi facilmente controllare i tuoi var:

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

Ho fatto un violino implementando (essenzialmente) sopra le idee delineate da iman. Ecco come appare quando passi il mouse sul secondo ipsum inreturn ipsum*ipsum - ...

Le variabili che rientrano nell'ambito vengono evidenziate nel punto in cui sono dichiarate (con colori diversi per ambiti diversi). Il lorembordo rosso è una variabile ombreggiata (non in ambito, ma sii in ambito se l'altro lorem più in basso l'albero non ci sarebbe.)

Sto usando la libreria esprima per analizzare JavaScript, ed estraverse, escodegen, escope (librerie di utilità in cima a esprima.) Il "sollevamento pesante" è fatto da tutte quelle librerie (il più complesso è lo stesso esprima, ovviamente.)

Come funziona

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

rende l'albero di sintassi astratto. Poi,

analysis = escope.analyze(ast);

genera una struttura dati complessa che incapsula informazioni su tutti gli ambiti nel programma. Il resto sta raccogliendo le informazioni codificate in quell'oggetto di analisi (e l'albero di sintassi astratto stesso) e ricavandone uno schema di colorazione interattivo.

Quindi la risposta corretta non è in realtà "no", ma "sì, ma". Il "ma" è grande: in pratica devi riscrivere parti significative del browser Chrome (ed è devtools) in JavaScript. JavaScript è un linguaggio completo di Turing, quindi ovviamente è possibile, in linea di principio. Ciò che è impossibile è fare tutto senza usare l'intero codice sorgente (come una stringa) e quindi fare cose molto complesse con quello.

Se vuoi solo ispezionare manualmente le variabili per aiutare il debug, avvia il debugger:

debugger;

Direttamente nella console del browser.