scope
A scope is the area of a program’s source code where variables are defined.
A scope specifies how to find a variable, that is, determine what access the currently executing code has to the variable.
ECMAScript6 previously had only global and function scopes.
JavaScript uses lexical scoping, also known as static scoping.
Because of lexical scope, the scope of a function is determined at the time the function is defined.
The opposite of lexical scope is dynamic scope, where the scope of a function is determined at the time the function is called.
Let’s take a closer look at an example to see the difference:
var value = 1;
function foo() {
console.log(value);
}
function bar() {
var value = 2;
foo(a); }bar(a);Copy the codeIn static scoping, foo looks inside foo to see if there is a local variable value. If there is no local variable value, it looks for the code above it based on where it was written. In this case, it is global scoped, meaning value equals 1, so it prints 1
When dynamic scoping is used, function foo is executed, again looking for local value from within foo. If not, the value variable is looked up from within the scope of the calling function, that is, the bar function, so 2 is printed
Dynamic scope
You might be wondering what languages are dynamically scoped?
Bash is a dynamic scope. If you don’t believe me, save the following script as scope.bash, then go to the corresponding directory, run bash./scope.bash on the command line, and see what the printed value is
value=1
function foo () {
echo $value;
}
function bar () {
local value=2;
foo;
}
barCopy the codeThis file can also be found in demos/scope/.
Finally, let’s look at an example from the Definitive JavaScript Guide:
var scope = "global scope";
function checkscope() {var scope = "local scope";
function f() {return scope;
}
return f(a); }checkscope(a);Copy the codevar scope = "global scope";
function checkscope() {var scope = "local scope";
function f() {return scope;
}
return f;
}
checkscope() ();Copy the codeGuess what the result of each piece of code is?
I’m just going to tell you the result, and both pieces of code will print ‘Local scope’.
The answer, quoting authoritative guides, is:
JavaScript functions are executed using the scope chain, which is created when the function is defined. The nested function f() is defined in the scope chain, where the variable scope must be a local variable. This binding remains in effect when f() is executed, no matter where or when f() is executed.
But what I really want you to think about here is that two pieces of code execute the same, but what are the differences between them?
There are a lot of things involved in answering this question, and lexical scope is only a small part of it. Let’s look forward to the next article ———— JavaScript Deep Execution Context Stack.
More and more
More articles in the JavaScript In-depth series can be found at github.com/mqyqingfeng… To view