执行上下文栈
首先我们先了解一下什么是执行上下文栈(Execution context stack)。
上面这张图来自于mdn,分别展示了栈、堆和队列,其中栈就是我们所说的执行上下文栈;堆是用于存储对象这种复杂类型,我们复制对象的地址引用就是这个堆内存的地址;队列就是异步队列,用于event loop的执行。
JS代码在引擎中是以“一段一段”的方式来分析执行的,而并非一行一行来分析执行。而这“一段一段”的可执行代码无非为三种:Global code
、Function Code
、Eval code
。这些可执行代码在执行的时候又会创建一个一个的执行上下文(Execution context)。例如,当执行到一个函数的时候,JS引擎会做一些“准备工作”,而这个“准备工作”,我们称其为执行上下文
。
那么随着我们的执行上下文数量的增加,JS引擎又如何去管理这些执行上下文呢?这时便有了执行上下文栈。
这里我用一段贯穿全文的例子来讲解执行上下文栈的执行过程:
var scope = 'global scope';
function checkscope(s) {
var scope = 'local scope';
function f() {
return scope;
}
return f();
}
checkscope('scope');
当JS引擎去解析代码的时候,最先碰到的就是Global code
,所以一开始初始化的时候便会将全局上下文推入执行上下文栈,并且只有在整个应用程序执行完毕的时候,全局上下文才会推出执行上下文栈。
这里我们用ECS来模拟执行上下文栈,用globalContext来表示全局上下文:
ESC = [
globalContext, // 一开始只有全局上下文
]
然后当代码执行checkscope函数的时候,会创建checkscope函数的执行上下文,并将其压入执行上下文栈:
ESC = [
checkscopeContext, // checkscopeContext入栈
globalContext,
]
接着代码执行到return f()
的时候,f函数的执行上下文被创建:
ESC = [
fContext, // fContext入栈
checkscopeContext,
globalContext,
]
f函数执行完毕后,f函数的执行上下文出栈,随后checkscope函数执行完毕,checkscope函数的执行上下文出栈:
// fContext出栈
ESC = [
// fContext出栈
checkscopeContext,
globalContext,
]
// checkscopeContext出栈
ESC = [
// checkscopeContext出栈
globalContext,
]
变量对象
每一个执行上下文都有三个重要的属性:
- 变量对象
- 作用域链
- this
这一节我们先来说一下变量对象(Variable object,这里简称VO)。
变量对象是与执行上下文相关的数据作用域,存储了在上下文中定义的变量和函数声明。并且不同的执行上下文也有着不同的变量对象,这里分为全局上下文中的变量对象和函数执行上下文中的变量对象。
全局上下文中的变量对象
全局上下文中的变量对象其实就是全局对象。我们可以通过this来访问全局对象,并且在浏览器环境中,this === window
;在node环境中,this === global
。
函数上下文中的变量对象
在函数上下文中的变量对象,我们用活动对象来表示(activation object,这里简称AO),为什么称其为活动对象呢,因为只有到当进入一个执行上下文中,这个执行上下文的变量对象才会被激活,并且只有被激活的变量对象,其属性才能被访问。
在函数执行之前,会为当前函数创建执行上下文,并且在此时,会创建变量对象:
- 根据函数arguments属性初始化arguments对象;
- 根据函数声明生成对应的属性,其值为一个指向内存中函数的引用指针。如果函数名称已存在,则覆盖;
- 根据变量声明生成对应的属性,此时初始值为undefined。如果变量名已声明,则忽略该变量声明;
还是以刚才的代码为例:
var scope = 'global scope';
function checkscope(s) {
var scope = 'local scope';
function f() {
return scope;
}
return f();
}
checkscope('scope');
在执行checkscope函数之前,会为其创建执行上下文,并初始化变量对象,此时的变量对象为:
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: undefined, // 此时声明的变量为undefined
}
随着checkscope函数的执行,变量对象被激活,变相对象内的属性随着代码的执行而改变:
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: 'local scope', // 变量赋值
}
其实也可以用另一个概念“函数提升”和“变量提升”来解释:
function checkscope(s) {
function f() { // 函数提升
return scope;
}
var scope; // 变量声明提升
scope = 'local scope' // 变量对象的激活也相当于此时的变量赋值
return f();
}
作用域链
每一个执行上下文都有三个重要的属性:
- 变量对象
- 作用域链
- this
这一节我们说一下作用域链。
什么是作用域链
当查找变量的时候,会先从当前上下文的变量对象中查找,如果没有找到,就会从父级执行上下文的变量对象中查找,一直找到全局上下文的变量对象。这样由多个执行上下文的变量对象构成的链表就叫做作用域链。
下面还是用我们的例子来讲解作用域链:
var scope = 'global scope';
function checkscope(s) {
var scope = 'local scope';
function f() {
return scope;
}
return f();
}
checkscope('scope');
首先在checkscope函数声明的时候,内部会绑定一个[[scope]]
的内部属性:
checkscope.[[scope]] = [
globalContext.VO
];
接着在checkscope函数执行之前,创建执行上下文checkscopeContext,并推入执行上下文栈:
- 复制函数的
[[scope]]
属性初始化作用域链; - 创建变量对象;
- 将变量对象压入作用域链的最顶端;
// -> 初始化作用域链;
checkscopeContext = {
scope: checkscope.[[scope]],
}
// -> 创建变量对象
checkscopeContext = {
scope: checkscope.[[scope]],
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: undefined, // 此时声明的变量为undefined
},
}
// -> 将变量对象压入作用域链的最顶端
checkscopeContext = {
scope: [VO, checkscope.[[scope]]],
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: undefined, // 此时声明的变量为undefined
},
}
接着,随着函数的执行,修改变量对象:
checkscopeContext = {
scope: [VO, checkscope.[[scope]]],
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: 'local scope', // 变量赋值
}
}
与此同时遇到f函数声明,f函数绑定[[scope]]
属性:
checkscope.[[scope]] = [
checkscopeContext.VO, // f函数的作用域还包括checkscope的变量对象
globalContext.VO
];
之后f函数的步骤同checkscope函数。
再来一个经典的例子:
var data = [];
for (var i = 0; i < 6; i++) {
data[i] = function () {
console.log(i);
};
}
data[0]();
// ...
很简单,不管访问data几,最终console打印出来的都是6,因为在ES6之前,JS都没有块级作用域的概念,for循环内的代码都在全局作用域下。
在data函数执行之前,此时全局上下文的变量对象为:
globalContext.VO = {
data: [pointer to function ()],
i: 6, // 注意:此时的i值为6
}
每一个data匿名函数的执行上下文链大致都如下:
data[n]Context = {
scope: [VO, globalContext.VO],
VO: {
arguments: {
length: 0,
}
}
}
那么在函数执行的时候,会先去自己匿名函数的变量对象上找i的值,发现没有后会沿着作用域链查找,找到了全局执行上下文的变量对象,而此时全局执行上下文的变量对象中的i为6,所以每一次都打印的是6了。
词法作用域 & 动态作用域
JavaScript这门语言是基于词法作用域来创建作用域的,也就是说一个函数的作用域在函数声明的时候就已经确定了,而不是函数执行的时候。
改一下之前的例子:
var scope = 'global scope';
function f() {
console.log(scope)
}
function checkscope() {
var scope = 'local scope';
f();
}
checkscope();
因为JavaScript是基于词法作用域创建作用域的,所以打印的结果是global scope
而不是local scope
。我们结合上面的作用域链来分析一下:
首先遇到了f函数的声明,此时为其绑定[[scope]]
属性:
// 这里就是我们所说的“一个函数的作用域在函数声明的时候就已经确定了”
f.[[scope]] = [
globalContext.VO, // 此时的全局上下文的变量对象中保存着scope = 'global scope';
];
然后我们直接跳过checkscope的执行上下文的创建和执行的过程,直接来到f函数的执行上。此时在函数执行之前初始化f函数的执行上下文:
// 这里就是为什么会打印global scope
fContext = {
scope: [VO, globalContext.VO], // 复制f.[[scope]],f.[[scope]]只有全局执行上下文的变量对象
VO = {
arguments: {
length: 0,
},
},
}
然后到了f函数执行的过程,console.log(scope)
,会沿着f函数的作用域链查找scope变量,先是去自己执行上下文的变量对象中查找,没有找到,然后去global执行上下文的变量对象上查找,此时scope的值为global scope
。
this
在这里this绑定也可以分为全局执行上下文和函数执行上下文:
- 在全局执行上下文中,this的指向全局对象。(在浏览器中,this引用 Window 对象)。
- 在函数执行上下文中,this 的值取决于该函数是如何被调用的。如果它被一个引用对象调用,那么this会被设置成那个对象,否则this的值被设置为全局对象或者undefined(在严格模式下)
总结起来就是,谁调用了,this就指向谁。
执行上下文
这里,根据之前的例子来完整的走一遍执行上下文的流程:
var scope = 'global scope';
function checkscope(s) {
var scope = 'local scope';
function f() {
return scope;
}
return f();
}
checkscope('scope');
首先,执行全局代码,创建全局执行上下文,并且全局执行上下文进入执行上下文栈:
globalContext = {
scope: [globalContext.VO],
VO: global,
this: globalContext.VO
}
ESC = [
globalContext,
]
然后随着代码的执行,走到了checkscope函数声明的阶段,此时绑定[[scope]]
属性:
checkscope.[[scope]] = [
globalContext.VO,
]
在checkscope函数执行之前,创建checkscope函数的执行上下文,并且checkscope执行上下文入栈:
// 创建执行上下文
checkscopeContext = {
scope: [VO, globalContext.VO], // 复制[[scope]]属性,然后VO推入作用域链顶端
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: undefined,
},
this: globalContext.VO,
}
// 进入执行上下文栈
ESC = [
checkscopeContext,
globalContext,
]
checkscope函数执行,更新变量对象:
// 创建执行上下文
checkscopeContext = {
scope: [VO, globalContext.VO], // 复制[[scope]]属性,然后VO推入作用域链顶端
VO = {
arguments: {
0: 'scope',
length: 1,
},
s: 'scope', // 传入的参数
f: pointer to function f(),
scope: 'local scope', // 更新变量
},
this: globalContext.VO,
}
f函数声明,绑定[[scope]]
属性:
f.[[scope]] = [
checkscopeContext.VO,
globalContext.VO,
]
f函数执行,创建执行上下文,推入执行上下文栈:
// 创建执行上下文
fContext = {
scope: [VO, checkscopeContext.VO, globalContext.VO], // 复制[[scope]]属性,然后VO推入作用域链顶端
VO = {
arguments: {
length: 0,
},
},
this: globalContext.VO,
}
// 入栈
ESC = [
fContext,
checkscopeContext,
globalContext,
]
f函数执行完成,f函数执行上下文出栈,checkscope函数执行完成,checkscope函数出栈:
ESC = [
// fContext出栈
checkscopeContext,
globalContext,
]
ESC = [
// checkscopeContext出栈,
globalContext,
]
到此,一个整体的执行上下文的流程就分析完了。
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。