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

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

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

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

谢谢😜

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

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

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

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

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

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

@suoz 你剧透了哈~ 😂

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

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

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

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

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

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

链接地址： rccoder 博客链接

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

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

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

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

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

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

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

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

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

写得让人很容易理解

所以，作用域是在一个代码块编译时就确定了，而作用域链是在函数执行时才确定，这样理解对吗？

大佬，es6是如何对待{}的呢？{}生成一个新作用域么？为啥直接写{}的代码，里面的代码也会执行呢？是不是意味着{}是一个立即执行函数呢？

let a = 1;
{
  let a = 2;
  console.log(this);     //1
  console.log(a);
}
function foo(){
  console.log(this);     //2
}
console.log(this);       //3
console.log(a);

  var val = 10;
  foo();
  var val = 20;
  function foo() {
    console.log(val);  // 10
  }

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

大佬，按照词法作用域说法，应该打印的是20，实际打印的是10，这是为什么？

函数提升了，foo()执行之前还没被定义，函数声明和变量声明都会被提升，但是函数会先被提升，然后才是变量。
（可以参考《你不知道的JavaScript（上卷）第四章提升，4.3函数优先》，里面有很多例子讲的很清楚）

执行顺序是这样的：

//1:
var val = 10;
//2: 此时函数提升
function foo(){
  //此时val是全局作用域下的val引用，还没有被覆盖
  console.log(val);  // 10
}
//3:
foo();
//4:
var val = 20;

大佬，es6是如何对待{}的呢？{}生成一个新作用域么？为啥直接写{}的代码，里面的代码也会执行呢？是不是意味着{}是一个立即执行函数呢？

let a = 1;
{
  let a = 2;
  console.log(this);     //1
  console.log(a);
}
function foo(){
  console.log(this);     //2
}
console.log(this);       //3
console.log(a);

对于let来讲，它将创建的变量绑定到所在的任意作用域中，也就是说，let为其声明的变量隐式的绑定了所在的块作用域。这样会导致一个问题，就是在修改和移动的时候，如果不去关注块作用域中绑定的变量，会造成代码的混乱。

ES6中新增的{...}，用{...}去创建一个显式的块作用域可以解决上面讲的问题。而且let声明的变量只能在在这个块作用域里访问，有暂时性死区的特性（即：不会在块作用域中进行提升，声明前并不“存在”）。

是创建一个块作用域，和函数无关。

我是初学者对于一些概念不是太明白，谢谢这篇文章解答了我的解惑，期待您的更加优质的内容！

受益

你个傻冒，看了这个，连最基本的都不会了，肯定是2呀，value是局部变量，局部优先，其次全局，之所以你会困惑，因为作者的例子是执行函数，函数的作用域不一样，你个憨憨

补充： 函数的作用域基于函数创建的位置；函数内this指向基于函数运行的位置

蒙蔽了，老和 this 弄混。🙈

下面有一段JavaScript的代码：

let activeEffect

function whenDepsChanged(update) {
    const effect = ()=>{
        activeEffect = effect
        update()
    }
    effect()
}

请问，箭头函数中为什么能使用到effect？effect不是一个变量吗，等闭包定义后才赋值给这个effect变量啊。

function whenDepsChanged(update) {

    const effect2 = () => {console.log("effect2")}
    const effect = ()=>{
        activeEffect = effect2
        update()
    }
    effect()
}

如果换成上面这一种我理解，因为effect2先定义了，但是第一种那种写法如何理解呢。