作用域和閉包在JavaScript里非常重要。但是在我最初學習JavaScript的時候，卻很難理解。這篇文章會用一些例子幫你理解它們。

我們先從作用域開始。

作用域

JavaScript的作用域限定了你可以訪問哪些變量。有兩種作用域：全局作用域，局部作用域。

全局作用域

在所有函數(shù)聲明或者大括號之外定義的變量，都在全局作用域里。

不過這個規(guī)則只在瀏覽器中運行的JavaScript里有效。如果你在Node.js里，那么全局作用域里的變量就不一樣了，不過這篇文章不討論Node.js。

`const globalVariable = 'some value'`

一旦你聲明了一個全局變量，那么你在任何地方都可以使用它，包括函數(shù)內(nèi)部。

const hello = 'Hello CSS-Tricks Reader!'

function sayHello () {
  console.log(hello)
}

console.log(hello) // 'Hello CSS-Tricks Reader!'
sayHello() // 'Hello CSS-Tricks Reader!'

盡管你可以在全局作用域定義變量，但我們并不推薦這樣做。因為可能會引起命名沖突，兩個或更多的變量使用相同的變量名。如果你在定義變量時使用了const或者let，那么在命名有沖突時，你就會收到錯誤提示。這是不可取的。

// Don't do this!
let thing = 'something'
let thing = 'something else' // Error, thing has already been declared

如果你定義變量時使用的是var，那第二次定義會覆蓋***次定義。這也會讓代碼更難調(diào)試，也是不可取的。

// Don't do this!
var thing = 'something'
var thing = 'something else' // perhaps somewhere totally different in your code
console.log(thing) // 'something else'

所以，你應(yīng)該盡量使用局部變量，而不是全局變量

局部作用域

在你代碼某一個具體范圍內(nèi)使用的變量都可以在局部作用域內(nèi)定義。這就是局部變量。

JavaScript里有兩種局部作用域：函數(shù)作用域和塊級作用域。

我們從函數(shù)作用域開始。

函數(shù)作用域

當你在函數(shù)里定義一個變量時，它在函數(shù)內(nèi)任何地方都可以使用。在函數(shù)之外，你就無法訪問它了。

比如下面這個例子，在sayHello函數(shù)內(nèi)的hello變量：

function sayHello () {
  const hello = 'Hello CSS-Tricks Reader!'
  console.log(hello)
}

sayHello() // 'Hello CSS-Tricks Reader!'
console.log(hello) // Error, hello is not defined

塊級作用域

你在使用大括號時，聲明了一個const或者let的變量時，你就只能在大括號內(nèi)部使用這一變量。

在下例中，hello只能在大括號內(nèi)使用。

{
  const hello = 'Hello CSS-Tricks Reader!'
  console.log(hello) // 'Hello CSS-Tricks Reader!'
}

console.log(hello) // Error, hello is not defined

塊級作用域是函數(shù)作用域的子集，因為函數(shù)是需要用大括號定義的，（除非你明確使用return語句和箭頭函數(shù)）。

函數(shù)提升和作用域

當使用function定義時，這個函數(shù)都會被提升到當前作用域的頂部。因此，下面的代碼是等效的：

// This is the same as the one below
sayHello()
function sayHello () {
  console.log('Hello CSS-Tricks Reader!')
}

// This is the same as the code above
function sayHello () {
  console.log('Hello CSS-Tricks Reader!')
}
sayHello()

使用函數(shù)表達式定義時，函數(shù)就不會被提升到變量作用域的頂部。

sayHello() // Error, sayHello is not defined
const sayHello = function () {
  console.log(aFunction)
}

因為這里有兩個變量，函數(shù)提升可能會導致混亂，因此就不會生效。所以一定要在使用函數(shù)之前定義函數(shù)。

函數(shù)不能訪問其他函數(shù)的作用域

在分別定義的不同的函數(shù)時，雖然可以在一個函數(shù)里調(diào)用一個函數(shù)，但一個函數(shù)依然不能訪問其他函數(shù)的作用域內(nèi)部。

下面這例，second就不能訪問firstFunctionVariable這一變量。

function first () {
  const firstFunctionVariable = `I'm part of first`
}

function second () {
  first()
  console.log(firstFunctionVariable) // Error, firstFunctionVariable is not defined
}

嵌套作用域

如果在函數(shù)內(nèi)部又定義了函數(shù)，那么內(nèi)層函數(shù)可以訪問外層函數(shù)的變量，但反過來則不行。這樣的效果就是詞法作用域。

外層函數(shù)并不能訪問內(nèi)部函數(shù)的變量。

function outerFunction () {
  const outer = `I'm the outer function!`

  function innerFunction() {
    const inner = `I'm the inner function!`
    console.log(outer) // I'm the outer function!
  }

  console.log(inner) // Error, inner is not defined
}

如果把作用域的機制可視化，你可以想象有一個雙向鏡（單面透視玻璃）。你能從里面看到外面，但是外面的人不能看到你。

函數(shù)作用域就像是雙向鏡一樣。你可以從里面向外看，但是外面看不到你。

嵌套的作用域也是相似的機制，只是相當于有更多的雙向鏡。

多層函數(shù)就意味著多個雙向鏡。

理解前面關(guān)于作用域的部分，你就能理解閉包是什么了。

閉包

你在一個函數(shù)內(nèi)新建另一個函數(shù)時，就相當于創(chuàng)建了一個閉包。內(nèi)層函數(shù)就是閉包。通常情況下，為了能夠使得外部函數(shù)的內(nèi)部變量可以訪問，一般都會返回這個閉包。

function outerFunction () {
  const outer = `I see the outer variable!`

  function innerFunction() {
    console.log(outer)
  }

  return innerFunction
}

outerFunction()() // I see the outer variable!

因為內(nèi)部函數(shù)是返回值，因此你可以簡化函數(shù)聲明的部分：

function outerFunction () {
  const outer = `I see the outer variable!`

  return function innerFunction() {
    console.log(outer)
  }
}

outerFunction()() // I see the outer variable!

因為閉包可以訪問外層函數(shù)的變量，因此他們通常有兩種用途：

1. 減少副作用

2. 創(chuàng)建私有變量

使用閉包控制副作用

當你在函數(shù)返回值時執(zhí)行某些操作時，通常會發(fā)生一些副作用。副作用在很多情況下都會發(fā)生，比如Ajax調(diào)用，超時處理，或者哪怕是console.log的輸出語句：

function (x) {
  console.log('A console.log is a side effect!')
}

當你使用閉包來控制副作用時，你實際上是需要考慮哪些可能會混淆代碼工作流程的部分，比如Ajax或者超時。

要把事情說清楚，還是看例子比較方便：

比如說你要給為你朋友慶生，做一個蛋糕。做這個蛋糕可能花1秒鐘的時間，所以你寫了一個函數(shù)記錄在一秒鐘以后，記錄做完蛋糕這件事。

為了讓代碼簡短易讀，我使用了ES6的箭頭函數(shù)：

function makeCake() {
  setTimeout(_ => console.log(`Made a cake`, 1000)
  )
}

如你所見，做蛋糕帶來了一個副作用：一次延時。

更進一步，比如說你想讓你的朋友能選擇蛋糕的口味。那么你就給做蛋糕makeCake這個函數(shù)加了一個參數(shù)。

function makeCake(flavor) {
  setTimeout(_ => console.log(`Made a ${flavor} cake!`, 1000))
}

因此當你調(diào)用這個函數(shù)時，一秒后這個新口味的蛋糕就做好了。

makeCake('banana')
// Made a banana cake!

但這里的問題是，你并不想立刻知道蛋糕的味道。你只需要知道時間到了，蛋糕做好了就行。

要解決這個問題，你可以寫一個prepareCake的功能，保存蛋糕的口味。然后，在返回在內(nèi)部調(diào)用prepareCake的閉包makeCake。

從這里開始，你就可以在你需要的時調(diào)用，蛋糕也會在一秒后立刻做好。

function prepareCake (flavor) {
  return function () {
    setTimeout(_ => console.log(`Made a ${flavor} cake!`, 1000))
  }
}

const makeCakeLater = prepareCake('banana')

// And later in your code...
makeCakeLater()
// Made a banana cake!

這就是使用閉包減少副作用：你可以創(chuàng)建一個任你驅(qū)使的內(nèi)層閉包。

私有變量和閉包

前面已經(jīng)說過，函數(shù)內(nèi)的變量，在函數(shù)外部是不能訪問的既然不能訪問，那么它們就可以稱作私有變量。

然而，有時候你確實是需要訪問私有變量的。這時候就需要閉包的幫助了。

function secret (secretCode) {
  return {
    saySecretCode () {
      console.log(secretCode)
    }
  }
}

const theSecret = secret('CSS Tricks is amazing')
theSecret.saySecretCode()
// 'CSS Tricks is amazing'

這個例子里的saySecretCode函數(shù)，就在原函數(shù)外暴露了secretCode這一變量。因此，它也被成為特權(quán)函數(shù)。

使用DevTools調(diào)試

Chrome和Firefox的開發(fā)者工具都使我們能很方便的調(diào)試在當前作用域內(nèi)可以訪問的各種變量一般有兩種方法。

***種方法是在代碼里使用debugger關(guān)鍵詞。這能讓瀏覽器里運行的JavaScript的暫停，以便調(diào)試。

下面是prepareCake的例子：

function prepareCake (flavor) {
  // Adding debugger
  debugger
  return function () {
    setTimeout(_ => console.log(`Made a ${flavor} cake!`, 1000))
  }
}

const makeCakeLater = prepareCake('banana')

打開Chrome的開發(fā)者工具，定位到Source頁下（或者是Firefox的Debugger頁），你就能看到可以訪問的變量了。

使用debugger調(diào)試prepareCake的作用域。

你也可以把debugger關(guān)鍵詞放在閉包內(nèi)部。注意對比變量的作用域：

function prepareCake (flavor) {
  return function () {
    // Adding debugger
    debugger
    setTimeout(_ => console.log(`Made a ${flavor} cake!`, 1000))
  }
}

const makeCakeLater = prepareCake('banana')

調(diào)試閉包內(nèi)部作用域

第二種方式是直接在代碼相應(yīng)位置加斷點，點擊對應(yīng)的行數(shù)就可以了。

通過斷點調(diào)試作用域

總結(jié)一下

閉包和作用域并不是那么難懂。一旦你使用雙向鏡的思維去理解，它們就非常簡單了。

當你在函數(shù)里聲明一個變量時，你只能在函數(shù)內(nèi)訪問。這些變量的作用域就被限制在函數(shù)里了。

如果你在一個函數(shù)內(nèi)又定義了內(nèi)部函數(shù)，那么這個內(nèi)部函數(shù)就被稱作閉包。它仍可以訪問外部函數(shù)的作用域。

有問題就直接問吧。我盡量早點回復你們的問題。

如果你喜歡本文，也許你會喜歡我在博客和訂閱郵件里寫的其他前端開發(fā)相關(guān)的文章。我剛建立自己的新品牌，（而且是免費的哦?。┮粋€email的課程：JavaScript Roadmap。（希望你喜歡?。?/p>