범위 내의 모든 변수 가져 오기

범위 내의 모든 변수 가져 오기

---

현재 자바 스크립트 범위에있는 모든 변수를 가져 오는 방법이 있습니까?

---

"범위 내"변수는 "스코프 체인"에 의해 결정되며 프로그래밍 방식으로는 액세스 할 수 없습니다.

자세한 내용은 (아주 많이) 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를 사용하지 않는 경우에도 ) 또는 Opera의 Dragonfly 와 같은 디버거를 사용합니다 또는 IE의 "F12 개발자 도구". 그들이 제공하는 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);
    };
}

y가 아닌 x에 액세스 할 수 있습니다 . 그러나 여전히 호출자 체인 (arguments.callee.caller.caller.caller)을 루프에서 사용하여 호출자 함수의 로컬 변수를 찾을 수 있습니다. 로컬 변수 이름이 모두 있으면 범위 변수가 있습니다. 변수 이름을 사용하면 간단한 평가를 통해 값에 액세스 할 수 있습니다.

---

Yes and no. "No" in almost every situation. "Yes," but only in a limited manner, if you want to check the global scope. Take the following example:

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

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

Which outputs, amongst 150+ other things, the following:

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

So it is possible to list some variables in the current scope, but it is not reliable, succinct, efficient, or easily accessible.

A better question is why do you want to know what variables are in scope?

---

In ECMAScript 6 it's more or less possible by wrapping the code inside a with statement with a proxy object. Note it requires non-strict mode and it's bad practice.

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

The proxy claims to own all identifiers referenced inside with, so variable assignments are stored in the target. For lookups, the proxy retrieves the value from the proxy target or the global object (not the parent scope). let and const variables are not included.

Inspired by this answer by Bergi.

---

You can't.

Variables, identifiers of function declarations and arguments for function code, are bound as properties of the Variable Object, which is not accesible.

See also:

• Scope Chain and Identifier Resolution

---

As everyone noticed: you can't. But you can create a obj and assign every var you declare to that obj. That way you can easily check out your 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

---

The Simplest Way to Get Access to Vars in a Particular Scope

1. Open Developer Tools > Resources (in Chrome)
2. Open file with a function that has access to that scope (tip cmd/ctrl+p to find file)
3. Set breakpoint inside that function and run your code
4. When it stops at your breakpoint, you can access the scope var through console (or scope var window)

Note: You want to do this against un-minified js.

The Simplest Way to Show All Non-Private Vars

1. Open Console (in Chrome)
2. Type: this.window
3. Hit Enter

Now you will see an object tree you can expand with all declared objects.

---

If you just want to inspect the variables manually to help debug, just fire up the debugger:

debugger;

Straight into the browser console.

---

1. get a list of each and every word ever having been written or typed in any way or fashion by any human since the beginning of time (definitely a finite list in the mathematical sense.)

2. put them all into one big array by typing them all again into your dev console (as strings, so you don't get error thrown here.)

3. create new array, and do a loop over your finite list, pushing into the new array if a try / catch (doing just that in the try) does not end in the catch, due to ReferenceError (using eval to "unstring", because you do want the error here, if not in scope).

4. I take that back. The list I was talking about in point 1 is not big enough. They could have created variables via window[randomlyGeneratedString] = something. Better loop over all strings which can be generated by any computer program halting in reasonable feasible time frame - say, the time since the invention of the computor.

---

OK, seriously, you could do it like that, using as the list in 1) what you get from running esprima.parse on your entire codebase and walking the tree for things called "Identifier" and storing their "name". But then you will miss variables being created as in window["file_" + i] = blah, see 4.

참고URL : https://stackoverflow.com/questions/2051678/getting-all-variables-in-scope