When programming JavaScript, we can't avoid declaring functions and variables to successfully build our system, but how and where does the interpreter look for these functions and variables? What exactly happened when we reference these objects?
Original Published by Dmitry A. Soshnikov
Release time: 2009-06-27
Russian address: /ecmascript/ru-chapter-2-variable-object/
English translation: Dmitry A. Soshnikov
Release time: 2010-03-15
English address: /ecmascript/chapter-2-variable-object/
Some difficult sentences to translate refer to the Chinese translation of justinw
Most ECMAScript programmers should know that variables are closely related to the execution context:
var a = 10; // Variable in global context
(function () {
var b = 20; // Local variables in function context
})();
alert(a); // 10
alert(b); // Global variable "b" is not declared
Moreover, many programmers also know that the current ECMAScript specification states that independent scopes can only be created through the execution context of the "function" code type. That is to say, compared to C/C++, the for loop in ECMAScript cannot create a local context.
for (var k in {a: 1, b: 2}) {
alert(k);
}
alert(k); // Even though the loop has ended, the variable k is still in the current scope
Let's take a look at what details we found when declaring the data.
Data Statement
If the variable is related to the execution context, the variable itself should know where its data is stored and how to access it. This mechanism is called a variable object.
A variable object (abbreviated as VO) is a special object related to the execution context, which stores the following content declared in the context:
variable (var, variable declaration);
Function Declaration (FunctionDeclaration, abbreviated as FD);
The formal parameters of the function
For example, we can use a normal ECMAScript object to represent a variable object:
VO = {};
As we said, VO is the property of the execution context:
activeExecutionContext = {
VO: {
// Context data (var, FD, function arguments)
}
};
Only variable objects in the global context allow indirect access through the VO attribute name (because in the global context, the global object itself is a variable object, which will be introduced in detail later). In other contexts, VO objects cannot be accessed directly because it is only an implementation of the internal mechanism.
When we declare a variable or a function, there is no other difference than when we create a new VO property (i.e., there is a name and corresponding value).
For example:
var a = 10;
function test(x) {
var b = 20;
};
test(30);
The corresponding variable object is:
// Global context variable object
VO(globalContext) = {
a: 10,
test: <reference to function>
};
// Variable object in the context of the test function
VO(test functionContext) = {
x: 30,
b: 20
};
At the concrete implementation level (and in the specification) variable objects are just an abstract concept. (Essentially, in the specific execution context, the VO names are different and the initial structure is also different.
Variable objects in different execution contexts
Some operations (such as variable initialization) and behavior of variable objects are common for all types of execution contexts. From this perspective, it is easier to understand variable objects as basic things in abstraction. Also, additional content related to variable objects is defined in the function context.
Abstract variable object VO (general behavior of variable initialization process)
║
╠══> Global ContextVO
║ (VO === this === global)
║
╚══> Function ContextVO
(VO === AO, and <arguments> and <formal parameters> are added)
Let's take a look at it in detail:
Variable objects in global context
First, we need to give a clear definition of the global object:
Global object is an object that has been created before entering any execution context;
There is only one copy of this object, and its properties can be accessed anywhere in the program. The life cycle of the global object ends at the moment the program exits.
Copy the code
In the initial creation stage of the global object, Math, String, Date, parseInt are initialized as its own attributes, etc., and other additional objects can also be created as attributes (which can point to the global object itself). For example, in the DOM, the window property of the global object can refer to the global object itself (of course, not all specific implementations are like this):
global = {
Math: <...>,
String: <...>
...
...
window: global //Quot yourself
};
When accessing properties of global objects, the prefix is usually ignored, because global objects cannot be accessed directly by name. However, we can still access the global object through this in the global context, and we can also recursively refer to ourselves. For example, window in DOM. To sum up, the code can be abbreviated as:
String(10); // That is (10);
// with prefix
= 10; // === = 10 === = 10;
= 20; // = 20;
Therefore, back to the variable object in the global context—here, the variable object is the global object itself:
VO(globalContext) === global;
It is very necessary to understand the above conclusion. Based on this principle, the corresponding declared in the global context can we access it indirectly through the properties of the global object (for example, we do not know the variable name in advance).
var a = new String('test');
alert(a); // Direct access, find in VO(globalContext): "test"
alert(window['a']); // Indirectly accessed through global: global === VO(globalContext): "test"
alert(a === ); // true
var aKey = 'a';
alert(window[aKey]); // Indirectly accessed through dynamic attribute name: "test"
Variable objects in function context
In the function execution context, VO cannot be accessed directly, and the active object (activation object, abbreviated as AO) plays the role of VO.
VO(functionContext) === AO;
The active object is created at the moment when entering the function context and is initialized through the function's arguments property. The value of the arguments attribute is the Arguments object:
AO = {
arguments: <ArgO>
};
The Arguments object is an attribute of the active object, which includes the following properties:
callee — a reference to the current function
length — the number of parameters that are actually passed
properties-indexes (integral of string type) The value of the property is the parameter value of the function (arranged from left to right according to the parameter list). The number of internal elements of properties-indexes is equal to the value of properties-indexes and the actual passed in parameters is shared.
For example:
function foo(x, y, z) {
// The number of declared function parameters arguments (x, y, z)
alert(); // 3
// The number of parameters that are actually passed in (only x, y)
alert(); // 2
// The callee of the parameter is the function itself
alert( === foo); // true
// Parameter sharing
alert(x === arguments[0]); // true
alert(x); // 10
arguments[0] = 20;
alert(x); // 20
x = 30;
alert(arguments[0]); // 30
// However, the parameter z that is not passed in is not shared with the third index value of the parameter
z = 40;
alert(arguments[2]); // undefined
arguments[2] = 50;
alert(z); // 40
}
foo(10, 20);
The code for this example has a bug in the current version of Google Chrome browser - even if the parameter z is not passed, z and arguments[2] are still shared.
2 stages of processing context code
Now we finally reached the core point of this article. The code of the execution context is divided into two basic stages to handle:
Go to the execution context
Execute code
The modification changes of variable objects are closely related to these two stages.
Note: The processing of these 2 stages is general behavior and has nothing to do with the type of the context (that is, the performance is the same in the global context and function context).
Go to the execution context
When entering the execution context (before code execution), the following properties are already included in the VO (already mentioned earlier):
All formal parameters of a function (if we are in the function execution context)
— The attributes of a variable object composed of a name and corresponding value are created; if no corresponding parameters are passed, the attributes of a variable object composed of a name and undefined value will also be created.
All function declarations (FunctionDeclaration, FD)
—The attributes that consist of a variable object consisting of a name and the corresponding value (function-object) are created; if the variable object already has an attribute of the same name, this attribute is completely replaced.
All variable declarations (var, VariableDeclaration)
— The attributes that consist of a variable object consisting of a name and the corresponding value (undefined) are created; if the variable name is the same as the formal parameter or function that has been declared, the variable declaration will not interfere with the existing properties.
Let's look at an example:
function test(a, b) {
var c = 10;
function d() {}
var e = function _e() {};
(function x() {});
}
test(10); // call
When entering the test function context with parameter 10, AO is manifested as follows:
AO(test) = {
a: 10,
b: undefined,
c: undefined,
d: <reference to FunctionDeclaration "d">
e: undefined
};
Note that the function "x" is not included in AO. This is because "x" is a function expression (FunctionExpression, abbreviated as FE) rather than a function declaration, and the function expression does not affect VO. Anyway, the function "_e" is also a function expression, but as we will see below, since it is assigned to the variable "e", it can be accessed by the name "e". The difference between function declaration FunctionDeclaration and function expression FunctionExpression will be discussed in detail in Chapter 15 Functions. You can also refer to Chapter 2 of this series to reveal named function expressions.
After this, the second stage of processing the context code will enter the code - executing the code.
Code execution
During this cycle, AO/VO already has attributes (but not all attributes have values, and most attributes are still the system default initial value undefined).
As for the previous example, AO/VO is modified as follows during the code interpretation:
AO['c'] = 10;
AO['e'] = <reference to FunctionExpression "_e">;
Note again that because FunctionExpression "_e" is saved to the declared variable "e", it still exists in memory. FunctionExpression "x" does not exist in AO/VO, that is, if we want to try to call the "x" function, no matter whether before or after the function definition, an error "x is not defined". Unsaved function expressions can only be called in its own definition or recursion.
Another classic example:
alert(x); // function
var x = 10;
alert(x); // 10
x = 20;
function x() {};
alert(x); // 20
Why is the return value of the first alert "x" function, and it is also the "x" accessed before the "x" declaration? Why not 10 or 20? Because, according to the canonical function declaration is filled in when entering the context; the consent period is that there is a variable declaration "x" when entering the context. So as we said in the previous stage, the variable declaration is followed sequentially after the function declaration and formal parameter declaration, and in this context stage, the variable declaration will not interfere with the function declaration or formal parameter declaration that already exists in VO. Therefore, when entering the context, the structure of VO is as follows:
VO = {};
VO['x'] = <reference to FunctionDeclaration "x">
// Find var x = 10;
// If function "x" is not declared
// The value of "x" should be undefined
// However, the variable declaration in this case does not affect the value of the function with the same name
VO['x'] = <the value is not disturbed, still function>
Immediately afterwards, during the code execution stage, VO makes the following modifications:
VO['x'] = 10;
VO['x'] = 20;
We can see this effect in the second and third alerts.
In the following example we can see again that the variable is placed in VO during the context phase. (Because, although the else part of the code will never be executed, the variable "b" still exists in VO anyway.)
if (true) {
var a = 1;
} else {
var b = 2;
}
alert(a); // 1
alert(b); // undefined, not b is not declared, but the value of b is undefined
About variables
Generally, various articles and JavaScript-related books claim: "Whether you use the var keyword (in the global context) or not (in the world) you don't use the var keyword (in the world)" Remember, this is the wrong concept:
At any time, variables can only be declared by using the var keyword.
The assignment statement above:
a = 10;
This is simply creating a new property for the global object (but it is not a variable). "Not a variable" does not mean that it cannot be changed, but that it does not conform to the variable concept in the ECMAScript specification, so it is "not a variable" (the reason why it can become a property of a global object is entirely because VO(globalContext) === global, do you still remember this?).
Let's take a look at the specific differences through the following examples:
alert(a); // undefined
alert(b); // "b" has no declaration
b = 10;
var a = 20;
All roots are still VO and entering context and code execution phase:
Entering the context stage:
VO = {
a: undefined
};
We can see that because "b" is not a variable, there is no "b" at this stage at all, and "b" will only appear in the code execution stage (but in our example, there is an error before it reaches that).
Let's change the example code:
alert(a); // undefined, everyone knows this,
b = 10;
alert(b); // 10, code execution stage creation
var a = 20;
alert(a); // 20, code execution stage modification
There is another important knowledge point about variables. Compared with simple attributes, variables have an attribute: {DontDelete}. The meaning of this attribute is that variable attributes cannot be deleted directly using the delete operator.
a = 10;
alert(); // 10
alert(delete a); // true
alert(); // undefined
var b = 20;
alert(); // 20
alert(delete b); // false
alert(); // still 20
However, this rule does not cause distortion in a context, that is, the eval context, and the variable does not have the {DontDelete} feature.
eval('var a = 10;');
alert(); // 10
alert(delete a); // true
alert(); // undefined
When testing this instance using some debugging tools (such as Firebug) console, please note that Firebug also uses eval to execute your code in the console. Therefore, variable attributes also do not have the {DontDelete} attribute and can be deleted.
Special implementation: __parent__ attribute
As mentioned earlier, according to standard specifications, the active object cannot be directly accessed. However, some specific implementations do not fully comply with this regulation, such as SpiderMonkey and Rhino; in the implementation, the function has a special property __parent__, through which this property can be directly referenced to the active object or global variable object that the function has created.
For example (SpiderMonkey, Rhino):
var global = this;
var a = 10;
function foo() {}
alert(foo.__parent__); // global
var VO = foo.__parent__;
alert(); // 10
alert(VO === global); // true
In the example above, we can see that the function foo is created in the global context, so the property __parent__ points to the variable object of the global context, that is, the global object.
However, it is impossible to access the active object in the same way in SpiderMonkey: In different versions of SpiderMonkey, the __parent__ of the internal function sometimes points to null and sometimes to the global object.
In Rhino, it is perfectly OK to access the active object in the same way.
For example (Rhino):
var global = this;
var x = 10;
(function foo() {
var y = 20;
// Activity object in the context of "foo"
var AO = (function () {}).__parent__;
print(); // 20
// The __parent__ of the currently active object is an existing global object
// Special chains of variable objects are formed
// So we call scope chain
print(AO.__parent__ === global); // true
print(AO.__parent__.x); // 10
})();
Summarize
In this article, we have learned in-depth about objects related to the execution context. I hope this knowledge will help you and solve some problems or confusions you have ever encountered. According to the plan, in subsequent chapters, we will explore scope chains, identifier resolution, and closures.
If you have any questions, I'm glad to answer them in the comments below.
Other references
Original Published by Dmitry A. Soshnikov
Release time: 2009-06-27
Russian address: /ecmascript/ru-chapter-2-variable-object/
English translation: Dmitry A. Soshnikov
Release time: 2010-03-15
English address: /ecmascript/chapter-2-variable-object/
Some difficult sentences to translate refer to the Chinese translation of justinw
Most ECMAScript programmers should know that variables are closely related to the execution context:
Copy the codeThe code is as follows:
var a = 10; // Variable in global context
(function () {
var b = 20; // Local variables in function context
})();
alert(a); // 10
alert(b); // Global variable "b" is not declared
Moreover, many programmers also know that the current ECMAScript specification states that independent scopes can only be created through the execution context of the "function" code type. That is to say, compared to C/C++, the for loop in ECMAScript cannot create a local context.
Copy the codeThe code is as follows:
for (var k in {a: 1, b: 2}) {
alert(k);
}
alert(k); // Even though the loop has ended, the variable k is still in the current scope
Let's take a look at what details we found when declaring the data.
Data Statement
If the variable is related to the execution context, the variable itself should know where its data is stored and how to access it. This mechanism is called a variable object.
A variable object (abbreviated as VO) is a special object related to the execution context, which stores the following content declared in the context:
variable (var, variable declaration);
Function Declaration (FunctionDeclaration, abbreviated as FD);
The formal parameters of the function
For example, we can use a normal ECMAScript object to represent a variable object:
Copy the codeThe code is as follows:
VO = {};
As we said, VO is the property of the execution context:
activeExecutionContext = {
VO: {
// Context data (var, FD, function arguments)
}
};
Only variable objects in the global context allow indirect access through the VO attribute name (because in the global context, the global object itself is a variable object, which will be introduced in detail later). In other contexts, VO objects cannot be accessed directly because it is only an implementation of the internal mechanism.
When we declare a variable or a function, there is no other difference than when we create a new VO property (i.e., there is a name and corresponding value).
For example:
Copy the codeThe code is as follows:
var a = 10;
function test(x) {
var b = 20;
};
test(30);
The corresponding variable object is:
Copy the codeThe code is as follows:
// Global context variable object
VO(globalContext) = {
a: 10,
test: <reference to function>
};
// Variable object in the context of the test function
VO(test functionContext) = {
x: 30,
b: 20
};
At the concrete implementation level (and in the specification) variable objects are just an abstract concept. (Essentially, in the specific execution context, the VO names are different and the initial structure is also different.
Variable objects in different execution contexts
Some operations (such as variable initialization) and behavior of variable objects are common for all types of execution contexts. From this perspective, it is easier to understand variable objects as basic things in abstraction. Also, additional content related to variable objects is defined in the function context.
Copy the codeThe code is as follows:
Abstract variable object VO (general behavior of variable initialization process)
║
╠══> Global ContextVO
║ (VO === this === global)
║
╚══> Function ContextVO
(VO === AO, and <arguments> and <formal parameters> are added)
Let's take a look at it in detail:
Variable objects in global context
First, we need to give a clear definition of the global object:
Global object is an object that has been created before entering any execution context;
There is only one copy of this object, and its properties can be accessed anywhere in the program. The life cycle of the global object ends at the moment the program exits.
Copy the code
In the initial creation stage of the global object, Math, String, Date, parseInt are initialized as its own attributes, etc., and other additional objects can also be created as attributes (which can point to the global object itself). For example, in the DOM, the window property of the global object can refer to the global object itself (of course, not all specific implementations are like this):
Copy the codeThe code is as follows:
global = {
Math: <...>,
String: <...>
...
...
window: global //Quot yourself
};
When accessing properties of global objects, the prefix is usually ignored, because global objects cannot be accessed directly by name. However, we can still access the global object through this in the global context, and we can also recursively refer to ourselves. For example, window in DOM. To sum up, the code can be abbreviated as:
Copy the codeThe code is as follows:
String(10); // That is (10);
// with prefix
= 10; // === = 10 === = 10;
= 20; // = 20;
Therefore, back to the variable object in the global context—here, the variable object is the global object itself:
VO(globalContext) === global;
It is very necessary to understand the above conclusion. Based on this principle, the corresponding declared in the global context can we access it indirectly through the properties of the global object (for example, we do not know the variable name in advance).
Copy the codeThe code is as follows:
var a = new String('test');
alert(a); // Direct access, find in VO(globalContext): "test"
alert(window['a']); // Indirectly accessed through global: global === VO(globalContext): "test"
alert(a === ); // true
var aKey = 'a';
alert(window[aKey]); // Indirectly accessed through dynamic attribute name: "test"
Variable objects in function context
In the function execution context, VO cannot be accessed directly, and the active object (activation object, abbreviated as AO) plays the role of VO.
VO(functionContext) === AO;
The active object is created at the moment when entering the function context and is initialized through the function's arguments property. The value of the arguments attribute is the Arguments object:
Copy the codeThe code is as follows:
AO = {
arguments: <ArgO>
};
The Arguments object is an attribute of the active object, which includes the following properties:
callee — a reference to the current function
length — the number of parameters that are actually passed
properties-indexes (integral of string type) The value of the property is the parameter value of the function (arranged from left to right according to the parameter list). The number of internal elements of properties-indexes is equal to the value of properties-indexes and the actual passed in parameters is shared.
For example:
Copy the codeThe code is as follows:
function foo(x, y, z) {
// The number of declared function parameters arguments (x, y, z)
alert(); // 3
// The number of parameters that are actually passed in (only x, y)
alert(); // 2
// The callee of the parameter is the function itself
alert( === foo); // true
// Parameter sharing
alert(x === arguments[0]); // true
alert(x); // 10
arguments[0] = 20;
alert(x); // 20
x = 30;
alert(arguments[0]); // 30
// However, the parameter z that is not passed in is not shared with the third index value of the parameter
z = 40;
alert(arguments[2]); // undefined
arguments[2] = 50;
alert(z); // 40
}
foo(10, 20);
The code for this example has a bug in the current version of Google Chrome browser - even if the parameter z is not passed, z and arguments[2] are still shared.
2 stages of processing context code
Now we finally reached the core point of this article. The code of the execution context is divided into two basic stages to handle:
Go to the execution context
Execute code
The modification changes of variable objects are closely related to these two stages.
Note: The processing of these 2 stages is general behavior and has nothing to do with the type of the context (that is, the performance is the same in the global context and function context).
Go to the execution context
When entering the execution context (before code execution), the following properties are already included in the VO (already mentioned earlier):
All formal parameters of a function (if we are in the function execution context)
— The attributes of a variable object composed of a name and corresponding value are created; if no corresponding parameters are passed, the attributes of a variable object composed of a name and undefined value will also be created.
All function declarations (FunctionDeclaration, FD)
—The attributes that consist of a variable object consisting of a name and the corresponding value (function-object) are created; if the variable object already has an attribute of the same name, this attribute is completely replaced.
All variable declarations (var, VariableDeclaration)
— The attributes that consist of a variable object consisting of a name and the corresponding value (undefined) are created; if the variable name is the same as the formal parameter or function that has been declared, the variable declaration will not interfere with the existing properties.
Let's look at an example:
Copy the codeThe code is as follows:
function test(a, b) {
var c = 10;
function d() {}
var e = function _e() {};
(function x() {});
}
test(10); // call
When entering the test function context with parameter 10, AO is manifested as follows:
Copy the codeThe code is as follows:
AO(test) = {
a: 10,
b: undefined,
c: undefined,
d: <reference to FunctionDeclaration "d">
e: undefined
};
Note that the function "x" is not included in AO. This is because "x" is a function expression (FunctionExpression, abbreviated as FE) rather than a function declaration, and the function expression does not affect VO. Anyway, the function "_e" is also a function expression, but as we will see below, since it is assigned to the variable "e", it can be accessed by the name "e". The difference between function declaration FunctionDeclaration and function expression FunctionExpression will be discussed in detail in Chapter 15 Functions. You can also refer to Chapter 2 of this series to reveal named function expressions.
After this, the second stage of processing the context code will enter the code - executing the code.
Code execution
During this cycle, AO/VO already has attributes (but not all attributes have values, and most attributes are still the system default initial value undefined).
As for the previous example, AO/VO is modified as follows during the code interpretation:
Copy the codeThe code is as follows:
AO['c'] = 10;
AO['e'] = <reference to FunctionExpression "_e">;
Note again that because FunctionExpression "_e" is saved to the declared variable "e", it still exists in memory. FunctionExpression "x" does not exist in AO/VO, that is, if we want to try to call the "x" function, no matter whether before or after the function definition, an error "x is not defined". Unsaved function expressions can only be called in its own definition or recursion.
Another classic example:
Copy the codeThe code is as follows:
alert(x); // function
var x = 10;
alert(x); // 10
x = 20;
function x() {};
alert(x); // 20
Why is the return value of the first alert "x" function, and it is also the "x" accessed before the "x" declaration? Why not 10 or 20? Because, according to the canonical function declaration is filled in when entering the context; the consent period is that there is a variable declaration "x" when entering the context. So as we said in the previous stage, the variable declaration is followed sequentially after the function declaration and formal parameter declaration, and in this context stage, the variable declaration will not interfere with the function declaration or formal parameter declaration that already exists in VO. Therefore, when entering the context, the structure of VO is as follows:
Copy the codeThe code is as follows:
VO = {};
VO['x'] = <reference to FunctionDeclaration "x">
// Find var x = 10;
// If function "x" is not declared
// The value of "x" should be undefined
// However, the variable declaration in this case does not affect the value of the function with the same name
VO['x'] = <the value is not disturbed, still function>
Immediately afterwards, during the code execution stage, VO makes the following modifications:
Copy the codeThe code is as follows:
VO['x'] = 10;
VO['x'] = 20;
We can see this effect in the second and third alerts.
In the following example we can see again that the variable is placed in VO during the context phase. (Because, although the else part of the code will never be executed, the variable "b" still exists in VO anyway.)
Copy the codeThe code is as follows:
if (true) {
var a = 1;
} else {
var b = 2;
}
alert(a); // 1
alert(b); // undefined, not b is not declared, but the value of b is undefined
About variables
Generally, various articles and JavaScript-related books claim: "Whether you use the var keyword (in the global context) or not (in the world) you don't use the var keyword (in the world)" Remember, this is the wrong concept:
At any time, variables can only be declared by using the var keyword.
The assignment statement above:
a = 10;
This is simply creating a new property for the global object (but it is not a variable). "Not a variable" does not mean that it cannot be changed, but that it does not conform to the variable concept in the ECMAScript specification, so it is "not a variable" (the reason why it can become a property of a global object is entirely because VO(globalContext) === global, do you still remember this?).
Let's take a look at the specific differences through the following examples:
Copy the codeThe code is as follows:
alert(a); // undefined
alert(b); // "b" has no declaration
b = 10;
var a = 20;
All roots are still VO and entering context and code execution phase:
Entering the context stage:
Copy the codeThe code is as follows:
VO = {
a: undefined
};
We can see that because "b" is not a variable, there is no "b" at this stage at all, and "b" will only appear in the code execution stage (but in our example, there is an error before it reaches that).
Let's change the example code:
Copy the codeThe code is as follows:
alert(a); // undefined, everyone knows this,
b = 10;
alert(b); // 10, code execution stage creation
var a = 20;
alert(a); // 20, code execution stage modification
There is another important knowledge point about variables. Compared with simple attributes, variables have an attribute: {DontDelete}. The meaning of this attribute is that variable attributes cannot be deleted directly using the delete operator.
Copy the codeThe code is as follows:
a = 10;
alert(); // 10
alert(delete a); // true
alert(); // undefined
var b = 20;
alert(); // 20
alert(delete b); // false
alert(); // still 20
However, this rule does not cause distortion in a context, that is, the eval context, and the variable does not have the {DontDelete} feature.
Copy the codeThe code is as follows:
eval('var a = 10;');
alert(); // 10
alert(delete a); // true
alert(); // undefined
When testing this instance using some debugging tools (such as Firebug) console, please note that Firebug also uses eval to execute your code in the console. Therefore, variable attributes also do not have the {DontDelete} attribute and can be deleted.
Special implementation: __parent__ attribute
As mentioned earlier, according to standard specifications, the active object cannot be directly accessed. However, some specific implementations do not fully comply with this regulation, such as SpiderMonkey and Rhino; in the implementation, the function has a special property __parent__, through which this property can be directly referenced to the active object or global variable object that the function has created.
For example (SpiderMonkey, Rhino):
Copy the codeThe code is as follows:
var global = this;
var a = 10;
function foo() {}
alert(foo.__parent__); // global
var VO = foo.__parent__;
alert(); // 10
alert(VO === global); // true
In the example above, we can see that the function foo is created in the global context, so the property __parent__ points to the variable object of the global context, that is, the global object.
However, it is impossible to access the active object in the same way in SpiderMonkey: In different versions of SpiderMonkey, the __parent__ of the internal function sometimes points to null and sometimes to the global object.
In Rhino, it is perfectly OK to access the active object in the same way.
For example (Rhino):
Copy the codeThe code is as follows:
var global = this;
var x = 10;
(function foo() {
var y = 20;
// Activity object in the context of "foo"
var AO = (function () {}).__parent__;
print(); // 20
// The __parent__ of the currently active object is an existing global object
// Special chains of variable objects are formed
// So we call scope chain
print(AO.__parent__ === global); // true
print(AO.__parent__.x); // 10
})();
Summarize
In this article, we have learned in-depth about objects related to the execution context. I hope this knowledge will help you and solve some problems or confusions you have ever encountered. According to the plan, in subsequent chapters, we will explore scope chains, identifier resolution, and closures.
If you have any questions, I'm glad to answer them in the comments below.
Other references
- 10.1.3 – Variable Instantiation;
- 10.1.5 – Global Object;
- 10.1.6 – Activation Object;
- 10.1.8 – Arguments Object.