New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

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

Open
mqyqingfeng opened this Issue Apr 23, 2017 · 62 comments

Comments

Projects
None yet
@mqyqingfeng
Owner

mqyqingfeng commented Apr 23, 2017

作用域

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

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

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

This comment has been minimized.

JSupot commented May 11, 2017

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

@MissCuriosity

This comment has been minimized.

MissCuriosity commented May 27, 2017

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented May 27, 2017

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

@yangshun352607664

This comment has been minimized.

yangshun352607664 commented May 27, 2017

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

@wqxc

This comment has been minimized.

wqxc commented May 29, 2017

谢谢😜

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented May 29, 2017

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

@rccoder

This comment has been minimized.

rccoder commented Jun 1, 2017

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

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

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

This comment has been minimized.

Owner

mqyqingfeng commented Jun 1, 2017

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

@suoz

This comment has been minimized.

suoz commented Jun 8, 2017

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Jun 8, 2017

@suoz 你剧透了哈~ 😂

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Jun 15, 2017

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

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

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

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

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

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

链接地址: rccoder 博客链接

@double-chen

This comment has been minimized.

double-chen commented Jun 23, 2017

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Jun 23, 2017

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

@yh284914425

This comment has been minimized.

yh284914425 commented Aug 1, 2017

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

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Aug 3, 2017

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

@mengxin-FE

This comment has been minimized.

mengxin-FE commented Aug 14, 2017

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

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

@nicewahson

This comment has been minimized.

nicewahson commented Aug 14, 2017

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Aug 16, 2017

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

@nightn

This comment has been minimized.

nightn commented Mar 9, 2018

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

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

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

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

望博主解疑,非常感谢!!

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

@mengxin-FE

This comment has been minimized.

mengxin-FE commented Mar 9, 2018

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

@wenbingyan

This comment has been minimized.

wenbingyan commented Mar 16, 2018

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Mar 28, 2018

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

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

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

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

@mqyqingfeng

This comment has been minimized.

Owner

mqyqingfeng commented Mar 28, 2018

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

@DFLovingWM

This comment has been minimized.

DFLovingWM commented May 2, 2018

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

@liSong5713

This comment has been minimized.

liSong5713 commented May 10, 2018

`
var x = 21;

var talk = function () {

    console.log(x);

    var x = 20;

};

talk ();

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

@suminhohu

This comment has been minimized.

suminhohu commented May 15, 2018

@liSong5713

This comment has been minimized.

liSong5713 commented May 15, 2018

@jasonzhangdong

This comment has been minimized.

jasonzhangdong commented Jul 23, 2018

@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

This comment has been minimized.

lzuliuyun commented Aug 19, 2018

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

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

@xiaofan9

This comment has been minimized.

xiaofan9 commented Aug 19, 2018

@lzuliuyun 很好奇的是词法分析(词法作用域)这个阶段是发生在js编译阶段,还是执行阶段

@lzuliuyun

This comment has been minimized.

lzuliuyun commented Aug 19, 2018

@xiaofan9 词法分析是在编译阶段决定的,也就是说,在执行之前就已经确定了作用域的范围。你可以阅读下作者的“JavaScript深入之变量对象”:#5

@xie991283109

This comment has been minimized.

xie991283109 commented Aug 22, 2018

大佬,你后面举的javascript权威指南的两个例子,看着就是闭包呀,最终打出‘local scope‘从闭包也可以解释的通,能否把闭包和词法作用域打通说一下呢,感觉还是有点迷啊,谢谢

@yuu95

This comment has been minimized.

yuu95 commented Aug 22, 2018

@slogeor

This comment has been minimized.

slogeor commented Aug 27, 2018

@yuu95 看权威指南就行?

@jiayousuda

This comment has been minimized.

jiayousuda commented Sep 26, 2018

你好,,我想问下,,实际项目中一般尽量写成局部变量还是全局变量,,

@xiaofan9

This comment has been minimized.

xiaofan9 commented Sep 26, 2018

@jiayousuda 建议局部

@findpikachu

This comment has been minimized.

findpikachu commented Oct 15, 2018

你说错了,JavaScript即是词法作用域又是动态作用域,动态作用域指的是匿名函数的this和argument

@1011cat

This comment has been minimized.

1011cat commented Oct 28, 2018

你好,其实在最早之前学习js时就有这样的疑问,JavaScript里的作用域是对象吗?感觉不是,但是有这样一句话"JavaScript里万物皆对象".最近读<你不知道的JavaScript>其中有这样一句话"在 JavaScript 内部,作用 域确实和对象类似,可见的标识符都是它的属性。但是作用域“对象”无法通过 JavaScript 代码访问,它存在于 JavaScript 引擎内部。"所以更加迷惑了,请问,你是怎么理解的?谢谢!

@qiqingfu

This comment has been minimized.

qiqingfu commented Nov 9, 2018

@yh284914425

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

你这个例子全局看下来只有两个作用域。一个是全局作用域(Global), 一个是 o.b.fn引用的这个函数作用域。
变量对象(VO): 变量对象是与执行上下文相关的数据作用域。它是与上下文关联的特殊对象,用于存储被定义在上下文中的变量函数声明
而 Global的变量对象(VO)只有两个。
a: 10
b: object

在一个函数的上下文中有变量对象(VO)还有活动对象(AO)和[[Scope]]作用域链。

活动对象(AO):
在一个函数上下文中, 变量对象(VO)被表示为活动对象(activation object) AO, 活动对象(AO)相比变量对象(VO),还可以包含特殊对象arguments。

所以o.b.fn对应的函数中的活动对象是空的。因为既没有参数arguments,也没有变量声明,更没有函数声明。 那么在o.b.fn中打印 console.log(a)。这个函数自身没有,就会去它的父作用域(Global | 全局作用域)中查找。你再看一下它父作用域中的变量对象中只保存两个属性。a: 10 b:object。 所以打印10

个人见解,如有错误麻烦勘正。

@Nanchenk

This comment has been minimized.

Nanchenk commented Nov 19, 2018

JS也存在动态作用域吧,with,try/catch的catch子句好像就是动态的吧,包含eval的代码也不能由定义时确定。

@wd2010

This comment has been minimized.

wd2010 commented Nov 21, 2018

@Nanchenk 我也产生了同样的疑惑

var m=1
function foo(){
  console.log(m);//2
}
try{
  var m=2
  foo()
}catch(e){
  console.log(e)
}

在try/catch中若是静态编辑的话,那按理foo输出来的m应该是1,但这里是2 。

@mqyqingfeng 冴羽大大,麻烦指导下

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment