深入之执行上下文栈,执行上下文栈

JavaScript 长远之推行上下文栈

2017/05/13 · JavaScript
·
推行上下文

原稿出处: 冴羽   

已离开简书,原因参见
http://www.jianshu.com/p/0f12350a6b66。

先说说栈吧! 栈的推行各种是先进后出,后进先出!

原版的书文出处

JavaScript深切之实施上下文栈

依次执行?

假定要问到JavaScript代码执行各样的话,想必写过JavaScript的开发者都会有个直观的印象,这正是逐一执行,毕竟

var foo = function () { console.log(‘foo1’); } foo(); // foo1 var foo =
function () { console.log(‘foo2’); } foo(); // foo2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var foo = function () {
 
    console.log(‘foo1’);
 
}
 
foo();  // foo1
 
var foo = function () {
 
    console.log(‘foo2’);
 
}
 
foo(); // foo2

而是去看那段代码:

function foo() { console.log(‘foo1’); } foo(); // foo2 function foo() {
console.log(‘foo2’); } foo(); // foo2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function foo() {
 
    console.log(‘foo1’);
 
}
 
foo();  // foo2
 
function foo() {
 
    console.log(‘foo2’);
 
}
 
foo(); // foo2

打字与印刷的结果却是七个foo2。

刷过面试题的都了解那是因为JavaScript引擎并非一行一行地解析和进行顺序,而是一段一段地分析执行。当执行一段代码的时候,会开始展览贰个“准备工作”,比如第八个例证中的变量升高,和第2个例子中的函数提高。

只是本文真正想让大家想想的是:那几个”一段一段”中的“段”究竟是怎么划分的吧?

到底JavaScript引擎遭遇一段如何的代码时才会做’准备工作’呢?

虽人微权轻,但也要有投机的姿态。

施行上下文栈 履行全局代码和函数时,都会产生贰个环境,叫做执行上下文。一伊始打开页面包车型客车时候。全局环境(全局执行上下文)就会入栈。当执行到函数时,该函数也会时有产生一个实践环境,并入栈。(如若函数里带有另一个函数,同理)等该函数执行完了,就将该函数的履行环境弹出栈,再次回到全局上下文环境。

深入之执行上下文栈,执行上下文栈。可实施代码


那就要说到 JavaScript 的可实施代码(executable code)的档次有哪些了?

骨子里很简短,就三种,全局代码、函数代码、eval代码

举个例子,当执行到三个函数的时候,就会进展准备工作,那里的“准备工作”,让大家用个更标准一点的说法,就叫做”举办上下文(execution
context)
“。

可实施代码

那就要说到JavaScript的可实行代码(executable code)的档次有何了?

实则相当粗略,就两种,全局代码、函数代码、eval代码。

举个例证,当执行到七个函数的时候,就会开始展览准备干活,那里的’准备干活’,让我们用个更规范一点的传道,就叫做”执行上下文(execution
contexts)”。

小说能够在自笔者的 Github
https://github.com/mqyqingfeng/Blog
查看

图片 1

实践上下文栈

接下去难题来了,大家写的函数多了去了,怎么着管理创设的那么多执行上下文呢?

从而 JavaScript 引擎创立了进行上下文栈(Execution context
stack,ECS)
来保管实践上下文

为了模仿执行上下文栈的行为,让大家定义执行上下文栈是1个数组:

ECStack = [];

试想当 JavaScript
起先要表明施行代码的时候,起头遭遇的就是大局代码,所以早先化的时候首先就会向执行上下文栈压入3个大局执行上下文,大家用
globalContext 表示它,并且唯有当一切应用程序结束的时候,ECStack
才会被清空,所以 ECStack 最底部永远有个 globalContext

ECStack = [
    globalContext
];

今天 JavaScript 蒙受下边包车型客车那段代码了:

function fun3() {
    console.log('fun3')
}

function fun2() {
    fun3();
}

function fun1() {
    fun2();
}

fun1();

当执行3个函数的时候,就会创设3个推行上下文,并且压入执行上下文栈,当函数执行完结的时候,就会将函数的实施上下文从栈中弹出。知道了如此的做事原理,让我们来看看怎么着处理方面那段代码:

// 伪代码

// fun1()
ECStack.push(<fun1> functionContext);

// fun1中竟然调用了fun2,还要创建fun2的执行上下文
ECStack.push(<fun2> functionContext);

// 擦,fun2还调用了fun3!
ECStack.push(<fun3> functionContext);

// fun3执行完毕
ECStack.pop();

// fun2执行完毕
ECStack.pop();

// fun1执行完毕
ECStack.pop();

// javascript接着执行下面的代码,但是ECStack底层永远有个globalContext

实施上下文栈

接下去难点来了,我们写的函数多了去了,怎么着管理创造的那么多执行上下文呢?

由此js引擎创立了实践上下文栈(Execution context
stack,ECS)来治本推行上下文

为了模仿执行上下文栈的行事,让我们定义执行上下文栈是三个数组:

ECStack = [];

1
    ECStack = [];

试想当JavaScript开班要表明施行代码的时候,开端遇到的正是大局代码,所以开头化的时候首先就会向实施上下文栈压入贰个大局执行上下文,让大家用globalContext表示它,并且唯有当一切应用程序甘休的时候,ECStack才会被清空,所以ECStack最底部永远有个globalContext:

ECStack = [ globalContext ];

1
2
3
    ECStack = [
        globalContext
    ];

现行反革命JavaScript境遇上边包车型客车那段代码了:

function fun3() { console.log(‘fun3’) } function fun2() { fun3(); }
function fun1() { fun2(); } fun1();

1
2
3
4
5
6
7
8
9
10
11
12
13
function fun3() {
    console.log(‘fun3’)
}
 
function fun2() {
    fun3();
}
 
function fun1() {
    fun2();
}
 
fun1();

当碰到函数执行的时候,就会成立一个执行上下文,并且压入执行上下文栈,当函数执行实现的时候,就会将函数的推行上下文从栈中弹出。知道了如此的工作规律,让大家来看看哪些处理地点那段代码:

// 伪代码 // fun1() ECStack.push(fun1> functionContext); //
fun第11中学甚至调用了fun2,还要成立fun2的施行上下文 ECStack.push(fun2>
functionContext); // 擦,fun2还调用了fun3! ECStack.push(fun3>
functionContext); // fun3执行完结 ECStack.pop(); // fun2执行完成ECStack.pop(); // fun1执行达成 ECStack.pop(); //
javascript接着执行上边包车型客车代码,可是ECStack底层用于有个globalContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 伪代码
 
// fun1()
ECStack.push(fun1> functionContext);
 
// fun1中竟然调用了fun2,还要创建fun2的执行上下文
ECStack.push(fun2> functionContext);
 
// 擦,fun2还调用了fun3!
ECStack.push(fun3> functionContext);
 
// fun3执行完毕
ECStack.pop();
 
// fun2执行完毕
ECStack.pop();
 
// fun1执行完毕
ECStack.pop();
 
// javascript接着执行下面的代码,但是ECStack底层用于有个globalContext

图片借鉴自王福朋大神的博客>﹏<

解答思考题

好啊,到此甘休,大家早就明白了实施上下文栈怎样处理实施上下文的,所以让我们看看《JavaScript深刻之词法功效域和动态功效域》那篇小说最终的题材:

var scope = “global scope”; function checkscope(){ var scope = “local
scope”; function f(){ return scope; } return f(); } checkscope();

1
2
3
4
5
6
7
8
9
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f();
}
checkscope();

var scope = “global scope”; function checkscope(){ var scope = “local
scope”; function f(){ return scope; } return f; } checkscope()();

1
2
3
4
5
6
7
8
9
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
checkscope()();

两段代码执行的结果同样,不过两段代码毕竟有怎么着不相同吧?

答案便是执行上下文栈的变动差异。

让我们模拟第二段代码:

ECStack.push(checkscope> functionContext); ECStack.push(f>
functionContext); ECStack.pop(); ECStack.pop();

1
2
3
4
ECStack.push(checkscope> functionContext);
ECStack.push(f> functionContext);
ECStack.pop();
ECStack.pop();

让大家模拟第③段代码:

ECStack.push(checkscope> functionContext); ECStack.pop();
ECStack.push(f> functionContext); ECStack.pop();

1
2
3
4
ECStack.push(checkscope> functionContext);
ECStack.pop();
ECStack.push(f> functionContext);
ECStack.pop();

是还是不是多少分化吧?

自然,要是以为那样不难的作答执行上下文栈的变化,照旧显得不够详细,那就让大家去探索一下实施上下文到底包括了什么样内容,欢迎期待下一篇《JavaScript深远之变量对象》

举个例子

深切类别

JavaScript深刻体系推测写十五篇左右,目的在于帮大家捋顺JavaScript底层知识,重点教学如原型、效率域、执行上下文、变量对象、this、闭包、按值传递、call、apply、bind、new、继承等难处概念,与罗列它们的用法分裂,那么些连串更看得起通过写demo,捋进度、模拟达成,结合ES规范等办法来讲课。

怀有小说和demo都能够在github上找到。如若有错误可能不小心翼翼的地方,请务必给予指正,十一分感激。要是喜欢依然有所启发,欢迎star,对笔者也是一种鞭策。

本系列:

  1. JavaScirpt 深远之从原型到原型链
  2. JavaScript
    深切之词法作用域和动态功效域

    1 赞 1 收藏
    评论

图片 2

图片 3

当加载<script>中的代码时,全局执行环境入栈

相关文章