JavaScript深入之词法作用域和动态作用域

[mqyqingfeng]

作用域

作用域是指程序源代码中定义变量的区域。

作用域规定了如何查找变量，也就是确定当前执行代码对变量的访问权限。

JavaScript 采用词法作用域(lexical scoping)，也就是静态作用域。

静态作用域与动态作用域

因为 JavaScript 采用的是词法作用域，函数的作用域在函数定义的时候就决定了。

而与词法作用域相对的是动态作用域，函数的作用域是在函数调用的时候才决定的。

让我们认真看个例子就能明白之间的区别：

var value = 1;

function foo() {
    console.log(value);
}

function bar() {
    var value = 2;
    foo();
}

bar();

// 结果是 ???

假设JavaScript采用静态作用域，让我们分析下执行过程：

执行 foo 函数，先从 foo 函数内部查找是否有局部变量 value，如果没有，就根据书写的位置，查找上面一层的代码，也就是 value 等于 1，所以结果会打印 1。

假设JavaScript采用动态作用域，让我们分析下执行过程：

执行 foo 函数，依然是从 foo 函数内部查找是否有局部变量 value。如果没有，就从调用函数的作用域，也就是 bar 函数内部查找 value 变量，所以结果会打印 2。

前面我们已经说了，JavaScript采用的是静态作用域，所以这个例子的结果是 1。

动态作用域

也许你会好奇什么语言是动态作用域？

bash 就是动态作用域，不信的话，把下面的脚本存成例如 scope.bash，然后进入相应的目录，用命令行执行 bash ./scope.bash，看看打印的值是多少。

value=1
function foo () {
    echo $value;
}
function bar () {
    local value=2;
    foo;
}
bar

这个文件也可以在 Github 博客仓库中找到。

思考题

最后，让我们看一个《JavaScript权威指南》中的例子：

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

猜猜两段代码各自的执行结果是多少？

这里直接告诉大家结果，两段代码都会打印：local scope。

原因也很简单，因为JavaScript采用的是词法作用域，函数的作用域基于函数创建的位置。

而引用《JavaScript权威指南》的回答就是：

JavaScript 函数的执行用到了作用域链，这个作用域链是在函数定义的时候创建的。嵌套的函数 f() 定义在这个作用域链里，其中的变量 scope 一定是局部变量，不管何时何地执行函数 f()，这种绑定在执行 f() 时依然有效。

但是在这里真正想让大家思考的是：

虽然两段代码执行的结果一样，但是两段代码究竟有哪些不同呢？

如果要回答这个问题，就要牵涉到很多的内容，词法作用域只是其中的一小部分，让我们期待下一篇文章————《JavaScript深入之执行上下文栈》。

下一篇文章

JavaScript深入之执行上下文栈

深入系列

JavaScript深入系列目录地址：https://github.com/mqyqingfeng/Blog。

JavaScript深入系列预计写十五篇左右，旨在帮大家捋顺JavaScript底层知识，重点讲解如原型、作用域、执行上下文、变量对象、this、闭包、按值传递、call、apply、bind、new、继承等难点概念。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎star，对作者也是一种鼓励。

[JSupot]

之前一直不太理解什么是词法作用域，受教了

[MissCuriosity]

JS的上下文真的是个很神奇的东西，我看的是汤姆大叔的深入理解JS，这本书里面解释的也挺详细的，让我感觉看了之后稍微懂了，但是后面又会忘。 在看你文末两段代码的时候我其实觉得挺奇怪的，因为return f，我认为会返回function f() {};后面再看了一眼，原来checkscope()();也是无奈。

[mqyqingfeng]

@MissCuriosity 我也看过汤姆大叔的深入理解 JavaScript 系列，深受启发和影响。return f 确实会返回 function f(){}，只是因为 checkscope()()，返回的 f 函数又被执行了~

[yangshun352607664]

作者的案列太过简单，应该写那种嵌套比较深的的

[wqxc]

谢谢😜

[mqyqingfeng]

@yangshun352607664 哈哈，快来举一个例子~~~

[rccoder]

核心就是: 函数的作用域在函数定义的时候就决定了

真正理解这句话的时候闭包什么的也就理解了。

Like most modern programming languages, JavaScript uses lexical scoping. This means that functions are executed using the variable scope that was in effect when they were defined, not the variable scope that is in effect when they are invoked. In order to implement lexical scoping, the internal state of a JavaScript function object must in- clude not only the code of the function but also a reference to the current scope chain. (Before reading the rest of this section, you may want to review the material on variable scope and the scope chain in §3.10 and §3.10.3.) This combination of a function object and a scope (a set of variable bindings) in which the function’s variables are resolved is called a closure in the computer science literature. (This is an old term that refers to the fact that the function’s variables have bindings in the scope chain and that therefore the function is “closed over” its variables.)

Technically, all JavaScript functions are closures: they are objects, and they have a scope chain associated with them. Most functions are invoked using the same scope chain that was in effect when the function was defined, and it doesn’t really matter that there is a closure involved. Closures become interesting when they are invoked under a different scope chain than the one that was in effect when they were defined. This happens most commonly when a nested function object is returned from the function within which it was defined. There are a number of powerful programming techniques that involve this kind of nested function closures, and their use has become relatively common in JavaScript programming. Closures may seem confusing when you first en- counter them, but it is important that you understand them well enough to use them comfortably.

JavaScript, The Definite Guide

[mqyqingfeng]

@rccoder 感谢补充！非常赞同，词法作用域其实是非常重要的基础，所以才会作为第二篇去讲解。

[suoz]

在全局作用域中“定义”一个函数到时候，只会创建包含全局作用域的作用域链。 只有“执行”该函数的时候，才会复制创建时的作用域，并将当前函数的局部作用域放在作用域链的顶端。

[mqyqingfeng]

@suoz 你剧透了哈~ 😂

[mqyqingfeng]

@rccoder 我搬运了下你的博客中这段的翻译，希望不要介意~

翻译成中文的话也许是这样：

和大多数的现代化编程语言一样，JavaScript是采用词法作用域的，这就意味着函数的执行依赖于函数定义的时候所产生（而不是函数调用的时候产生的）的变量作用域。为了去实现这种词法作用域，JavaScript函数对象的内部状态不仅包含函数逻辑的代码，除此之外还包含当前作用域链的引用。函数对象可以通过这个作用域链相互关联起来，如此，函数体内部的变量都可以保存在函数的作用域内，这在计算机的文献中被称之为闭包。

从技术的角度去将，所有的JavaScript函数都是闭包：他们都是对象，他们都有一个关联到他们的作用域链。绝大多数函数在调用的时候使用的作用域链和他们在定义的时候的作用域链是相同的，但是这并不影响闭包。当调用函数的时候闭包所指向的作用域链和定义函数时的作用域链不是同一个作用域链的时候，闭包become interesting。这种interesting的事情往往发生在这样的情况下： 当一个函数嵌套了另外的一个函数，外部的函数将内部嵌套的这个函数作为对象返回。一大批强大的编程技术都利用了这类嵌套的函数闭包，当然，javascript也是这样。可能你第一次碰见闭包觉得比较难以理解，但是去明白闭包然后去非常自如的使用它是非常重要的。

通俗点说，在程序语言范畴内的闭包是指函数把其的变量作用域也包含在这个函数的作用域内，形成一个所谓的“闭包”，这样的话外部的函数就无法去访问内部变量。所以按照第二段所说的，严格意义上所有的函数都是闭包。

需要注意的是：我们常常所说的闭包指的是让外部函数访问到内部的变量，也就是说，按照一般的做法，是使内部函数返回一个函数，然后操作其中的变量。这样做的话一是可以读取函数内部的变量，二是可以让这些变量的值始终保存在内存中。

链接地址： rccoder 博客链接

[double-chen]

我有一点想不通，在读作者 执行上下文的文章，感觉执行上下文是在函数调用时准备的，作用域规定了如何查找变量。可是查找的变量是通过执行上下文中的变量对象和作用域链查找的，这是动态作用域的原理啊，为什么JS又是静态作用域了。

[mqyqingfeng]

@double-chen 动态作用域和静态作用域，决定的是作用域链的顺序

[yh284914425]

var a = 10;
var o = {
     a:11,
     b:{
         fn:function(){
              console.log(a);
         }
     }
}
o.b.fn();

函数包裹函数那种作用域理解了，这样的又有点懵了

[mqyqingfeng]

@yangshun352607664 结果是 10 ，因为变量 a 并不能读取到对象 o 的属性 a ，如果 console.log(o.a)，就会打印 11，函数 fn 的作用域链为 [AO, Global.VO]，而 Global.VO 中包括了变量 a 和变量 o。

[mengxin-FE]

var value = 1;
function bar(){
    var value =2;
    console.log(value)
}
bar() //2

为什么这回又返回2了呢？ 我还是没理解

[watsonnnnn]

如果是这样的，function out(function(){console.log(xxx)})这种形式，那括号里的函数作用域是怎么样的？

[mqyqingfeng]

@mengxin-FE 词法作用域决定了变量查找的顺序，这个顺序是从函数内部开始，然后到函数定义的外层，函数内部已经有值，所以就会打印 2

[mqyqingfeng]

@nicelj 你说的是

function out () {
    function inner() {
    }
}

这种形式吗？

如果是这种，可以接着往下看~

[watsonnnnn]

@mqyqingfeng 不是啊

function out( function (){console.log(xxx)} ){

}

是这样的，一个匿名函数直接当参数传进去

[mqyqingfeng]

@nicelj

function out( function (){console.log(1)} ){}

首先这种写法会导致语法错误，正常应该这样写：

var value = 1;
var f = function() { console.log(value) }
function out(f) {
        var value = 2;
        f();
}
out(f)

f 函数的作用域就是 [f.AO, global.VO]

[JarenZheng]

动态作用域 怎么演示。

[mqyqingfeng]

@JarenZheng 使用 bash

[mqyqingfeng]

@nicelj 跟上面的例子是一样的，都是 [f.AO, global.VO]

[mqyqingfeng]

@nicelj 关于作用域：

此外，作用域是动态的，这跟动态作用域不是一个概念哈~

[Yoomin233]

this应该就是典型的动态作用域吧.

[thisisandy]

f(); function f() { return scope; } var scope = "local scope"; 有个问题希望您能帮助我解答一下，这里f()返回了‘local scope’，但是按照作用域链那篇文章，在调用f时，这里的globalContext.VO中的scope应该是undefined的状态啊，怎么会返回‘local scope’呢？

[mqyqingfeng]

@thisisandy 这段代码返回的确实是 undefined，并不是 'local scope'，不知道你是怎么写的，不如试试不用 return, 改成 console.log

f(); 
function f() { console.log(scope ; } 
var scope = "local scope";

[thisisandy]

@mqyqingfeng 唔，顺序错了 f(); var scope = "local scope"; function f() { return scope; } 应该是这样

[mqyqingfeng]

@thisisandy 这段代码确实是返回 "local scope"，因为是根据函数创建的位置，然后向外查找变量，自然是 'local scope'

---

说错了…… 应该是 undefined，因为有函数提升和变量提升，相当于

function f() {return scope};
var scope;
f();
scope = "local scope";

[ryouaki]

因为 JavaScript 采用的是词法作用域，[函数的作用域]在函数定义的时候就决定了。

而与词法作用域相对的是动态作用域，[函数的作用域]是在函数调用的时候才决定的。

后面应该是动态作用域吧？

[Tvinsh]

你不知道的js，对这个也有挺详细的介绍，博主写得很好，感谢🙏

[jimczj]

https://github.com/jimczj/blog/issues/21 这是最近总结的，可以看下呗

[hu-shuaishuai]

楼主你好。看了这篇文章，我对词法作用域的理解是函数时在创建的时候就已经把他的作用域给确定了，是这个意思吗？

[mqyqingfeng]

@xiaohu-xiaohu 是的，就是这个意思~

[Ghohankawk]

涨知识了，之前原来是一种，误会，对这个地方，明白了，函数场景的时候，已经确定了作用域，这句话，感谢，继续往下读

[FengYangLiu]

收益匪浅

[imaxing]

将复制的作用域放在顶部这一块不是很明白能否解惑?

[mqyqingfeng]

@imaxing 没有明白想问的问题哈……能再详细的描述一下吗？

[nightn]

《JavaScript权威指南》对作用域的描述是：

一个变量的作用域（scope）是程序源代码中定义这个变量的区域。

是不是可以认为变量对象就是 JavaScript 对作用域这个概念的实现。而且，作用域链其实就是变量对象链，这进一步证实了这种观点。

当我们说通过 catch 语句或者 with 语句来延长作用域链的时候，其实就是在作用域链的最前端添加一个新的变量对象，执行完代码块时再移除这个变量对象。我觉得用 catch 或 with 的时候应该只是暂时延长作用域链，并不会创建一个新的执行上下文。（因为按照博主所说，执行上下文总共只有 3 种：全局执行上下文、函数执行上下文、eval。那我很好奇 ES6 中的 let/const 的作用域是如何实现的，也像 with 一样吗）。

望博主解疑，非常感谢！！

PS：对了，博主你有建立什么交流群吗，我觉得你的文章非常有价值，大家在阅读的过程中也会思考很多问题，如果只是在 issue 下提问，博主也很难每个一一作答。建议博主创建一个交流群，这样大家可以在上面提问，知道的同学都可以回答。

[mengxin-FE]

即时通讯的效率其实不如邮件，题主也不不是为了回答你的问题而存在呀，他还有他自己的事情。

[wenbingyan]

关于作者最后的一个问题， return f(); 与return f()()的区别是前一个，return f()此时的作用域在函数作用域的顶端，而return f()()的作用域是在全局作用域的顶端，是这个意思吗？ @mqyqingfeng @suoz

[mqyqingfeng]

@nightn “变量对象就是 JavaScript 对作用域这个概念的实现”，可以这样认为呀~~ let 和 const 的作用域跟 var 类似呀，只是没有变量提升，又多了些“检查”而已。

我没有建立任何交流群哈，写得文章现在只在 Github、掘金、Segmentfault 上发，有问题大家可以在 Github 上留言。

之所以不建立交流群，确实如 @mengxin-FE 所说，真的很忙哈，并没有足够的精力来打理一个交流群，这段时间因为很多事情，所以大家的留言也回复的非常迟，我很抱歉，接下来的一段时间会好很多。

日常除了工作之外，还要研究新的课题，跟大家讨论一些问题，在加上生活上的各种琐事，以及不间断的懒散，能用来做其他事情的时间已经很少了，还请谅解哈~

[mqyqingfeng]

@wenbingyan 这个理解可能有些问题，建议接着看后面的文章~

[DFLovingWM]

原来词法作用域就等同于静态作用域！文章不错！

[liSong5713]

`
var x = 21;

var talk = function () {

    console.log(x);

    var x = 20;

};

talk ();

` 这个怎么用词法作用域解释下呢

[Sphinm]

首先 var 会变量提升的，函数 talk 执行，首先打印 x，在函数体先查找，由于变量提升，所以此时 x 是可以获取到的，只不过此时是 undefined，所以我们打印的 x 也就是 undefined 了。发自我的iPhone------------------ 原始邮件 ------------------发件人: Lees notifications@github.com发送时间: 2018年5月10日 15:13收件人: mqyqingfeng/Blog Blog@noreply.github.com抄送: Subscribed subscribed@noreply.github.com主题: 回复：[mqyqingfeng/Blog] JavaScript深入之词法作用域和动态作用域 (#3)` var x = 21; var talk = function () {

console.log(x);

var x = 20;

};

talk ();

` 这个怎么用词法作用域解释下呢

—You are receiving this because you are subscribed to this thread.Reply to this email directly, view it on GitHub, or mute the thread.

{"api_version":"1.0","publisher":{"api_key":"05dde50f1d1a384dd78767c55493e4bb","name":"GitHub"},"entity":{"external_key":"github/mqyqingfeng/Blog","title":"mqyqingfeng/Blog","subtitle":"GitHub repository","main_image_url":"https://cloud.githubusercontent.com/assets/143418/17495839/a5054eac-5d88-11e6-95fc-7290892c7bb5.png","avatar_image_url":"https://cloud.githubusercontent.com/assets/143418/15842166/7c72db34-2c0b-11e6-9aed-b52498112777.png","action":{"name":"Open in GitHub","url":"https://github.com/mqyqingfeng/Blog"}},"updates":{"snippets":[{"icon":"PERSON","message":"@liSong5713 in #3: \r\nvar x = 21;\r\n\r\n var talk = function () {\r\n\r\n console.log(x);\r\n\r\n var x = 20;\r\n\r\n };\r\n\r\n talk ();\r\n\r\n这个怎么用词法作用域解释下呢"}],"action":{"name":"View Issue","url":"https://github.com/mqyqingfeng/Blog/issues/3#issuecomment-387972638"}}} {"@type":"MessageCard","@context":"http://schema.org/extensions","hideOriginalBody":"false","originator":"37567f93-e2a7-4e2a-ad37-a9160fc62647","title":"Re: [mqyqingfeng/Blog] JavaScript深入之词法作用域和动态作用域 (#3)","sections":[{"text":"","activityTitle":"Lees","activityImage":"https://avatars3.githubusercontent.com/u/19524010?s=160\u0026v=4","activitySubtitle":"@liSong5713","facts":[]}],"potentialAction":[{"name":"Add a comment","@type":"ActionCard","inputs":[{"isMultiLine":true,"@type":"TextInput","id":"IssueComment","isRequired":false}],"actions":[{"name":"Comment","@type":"HttpPOST","target":"https://api.github.com","body":"{\"commandName\":\"IssueComment\",\"repositoryFullName\":\"mqyqingfeng/Blog\",\"issueId\":3,\"IssueComment\":\"{{IssueComment.value}}\"}"}]},{"name":"Close issue","@type":"HttpPOST","target":"https://api.github.com","body":"{\"commandName\":\"IssueClose\",\"repositoryFullName\":\"mqyqingfeng/Blog\",\"issueId\":3}"},{"targets":[{"os":"default","uri":"https://github.com/mqyqingfeng/Blog/issues/3#issuecomment-387972638"}],"@type":"OpenUri","name":"View on GitHub"},{"name":"Unsubscribe","@type":"HttpPOST","target":"https://api.github.com","body":"{\"commandName\":\"MuteNotification\",\"threadId\":219504985}"}],"themeColor":"26292E"}

[liSong5713]

理解了 谢谢

在 2018年5月15日，上午8:15，苏敏 notifications@github.com 写道：

首先 var 会变量提升的，函数 talk 执行，首先打印 x，在函数体先查找，由于变量提升，所以此时 x 是可以获取到的，只不过此时是 undefined，所以我们打印的 x 也就是 undefined 了。发自我的iPhone------------------ 原始邮件 ------------------发件人: Lees notifications@github.com发送时间: 2018年5月10日 15:13收件人: mqyqingfeng/Blog Blog@noreply.github.com抄送: Subscribed subscribed@noreply.github.com主题: 回复：[mqyqingfeng/Blog] JavaScript深入之词法作用域和动态作用域 (#3)` var x = 21; var talk = function () {

console.log(x);

var x = 20;

};

talk ();

` 这个怎么用词法作用域解释下呢

—You are receiving this because you are subscribed to this thread.Reply to this email directly, view it on GitHub, or mute the thread.

{"api_version":"1.0","publisher":{"api_key":"05dde50f1d1a384dd78767c55493e4bb","name":"GitHub"},"entity":{"external_key":"github/mqyqingfeng/Blog","title":"mqyqingfeng/Blog","subtitle":"GitHub repository","main_image_url":"https://cloud.githubusercontent.com/assets/143418/17495839/a5054eac-5d88-11e6-95fc-7290892c7bb5.png","avatar_image_url":"https://cloud.githubusercontent.com/assets/143418/15842166/7c72db34-2c0b-11e6-9aed-b52498112777.png","action":{"name":"Open in GitHub","url":"https://github.com/mqyqingfeng/Blog"}},"updates":{"snippets":[{"icon":"PERSON","message":"@liSong5713 in #3: \r\nvar x = 21;\r\n\r\n var talk = function () {\r\n\r\n console.log(x);\r\n\r\n var x = 20;\r\n\r\n };\r\n\r\n talk ();\r\n\r\n这个怎么用词法作用域解释下呢"}],"action":{"name":"View Issue","url":"https://github.com/mqyqingfeng/Blog/issues/3#issuecomment-387972638"}}} {"@type":"MessageCard","@context":"http://schema.org/extensions","hideOriginalBody":"false","originator":"37567f93-e2a7-4e2a-ad37-a9160fc62647","title":"Re: [mqyqingfeng/Blog] JavaScript深入之词法作用域和动态作用域 (#3)","sections":[{"text":"","activityTitle":"Lees","activityImage":"https://avatars3.githubusercontent.com/u/19524010?s=160\u0026v=4","activitySubtitle":"@liSong5713","facts":[]}],"potentialAction":[{"name":"Add a comment","@type":"ActionCard","inputs":[{"isMultiLine":true,"@type":"TextInput","id":"IssueComment","isRequired":false}],"actions":[{"name":"Comment","@type":"HttpPOST","target":"https://api.github.com","body":"{\"commandName\":\"IssueComment\",\"repositoryFullName\":\"mqyqingfeng/Blog\",\"issueId\":3,\"IssueComment\":\"{{IssueComment.value}}\"}"}]},{"name":"Close issue","@type":"HttpPOST","target":"https://api.github.com","body":"{\"commandName\":\"IssueClose\",\"repositoryFullName\":\"mqyqingfeng/Blog\",\"issueId\":3}"},{"targets":[{"os":"default","uri":"https://github.com/mqyqingfeng/Blog/issues/3#issuecomment-387972638"}],"@type":"OpenUri","name":"View on GitHub"},{"name":"Unsubscribe","@type":"HttpPOST","target":"https://api.github.com","body":"{\"commandName\":\"MuteNotification\",\"threadId\":219504985}"}],"themeColor":"26292E"} — You are receiving this because you commented. Reply to this email directly, view it on GitHub https://github.com/mqyqingfeng/Blog/issues/3#issuecomment-389002207, or mute the thread https://github.com/notifications/unsubscribe-auth/ASnpqsmvZt15oOjY89dAmbLHTqmzvEAdks5tyh4ogaJpZM4NFWFZ.

[jasonzhangdong]

@mqyqingfeng

// 题1 var a = 1; function f(b) { b = 2; } f(a); // a == 1 // 题2 var a = [1, 3]; function f(b) { b.push(2); } f(a) // a == [1,3,2] // 题3 var a = {k: 12}; function f(b) { a.c = 100; } f(a) // a == {k:12,c:100}

为什么会有这样的结果?????

[lzuliuyun]

@jasonzhangdong 问题关键在于基本类型和引用类型如何传参。

题1，a是基本类型，传参是直接复制a的值，因此a的值不变。 题2、题3，数组和对象是引用类型，传的是引用地址，可以理解为a，b操控的是同一块堆内存地址。