以下内容总结自《JS高级程序设计》第三版

---

什么是函数表达式？

函数表达式，是JS中定义函数的一种方式。
在JS中，共有两种方式定义函数：
1. 函数声明
2. 函数表达式
来看看区别吧：

// 1. 函数声明
function f(){
  // 函数体
}

// 2. 函数表达式
var f = function(){
  // 函数体
}

那除了写法不同之外，还有什么区别呢？
你可能会想到，函数声明的function写在了最开始，而函数表达式没有。没错，这是区别之一，一旦function用在了本行代码的最开始，就代表这是一个函数声明，函数声明还必须要有一个名字（标识符）跟在后面，否则会报错的；
另外函数声明有一个重要的特征就是函数声明提升，而函数表达式没有。
下面这段代码展示了这个区别

// 函数声明
sayHi()  // 不会报错。
function sayHi() {
  alert('Hello World!')
}

// 函数表达式
sayHi()  // 错误！函数还未定义！
var sayHi = function() {
  alert('Hello World!')
}

这便是函数声明提升。如果还有疑惑的话，那再看看下面的代码：

// 预编译前
sayHi()
function sayHi() {
  alert('Hello World')
}

// 预编译后
function sayHi() {
  alert('Hello World')
}
sayHi()

这便是JS引擎对函数声明做的处理，即函数声明提升。但是很不幸，本章的主角函数表达式，并没有这个待遇。

不过没关系，在其他方面，函数表达式还是非常有用的。

---

一、递归

先上一段代码

// 递归函数
function factorial (num) {    // 函数声明
  if (num < 1) {
    return 1
  } else {
    return num * factorial(num - 1)   // 函数表达式
  }
}

上面这段代码就是一个递归函数，它既有函数声明，也有函数表达式。这也是函数表达式的用处之一：当作函数返回值。

问题
上面的函数中虽然调用了自己当作返回值，但是一旦我们进行了下面的骚操作，就完蛋了。

var anotherFactorial = factorial
factorial = null
alert(anotherFactorial(4))  // 出错

这里的执行顺序是这样的：

 1 将 factorial()函数的引用给了anotherFactorial，
 2 然后factorial指向null，
 3 再执行anotherFactorial()，
 4 第一次进去的之后执行的挺好，最后到了返回值的时候，又遇到了factorial() 
 ？嗯？这玩意不是指向null了嘛，我还执行个毛线，直接扔个错误就完事了。

解决方法
使用 arguments.callee，这个东西指向的使正在执行的函数的指针，所以用它代替函数名就能解决了。
但是呢，在严格模式下，是不能通过脚本访问arguments.callee的，会报错。那怎么办？使用命名函数表达式的方法来操作

var factorial = (function f(num) {
  if (num < 1) {
    return 1
  } else {
    return num * f(num - 1)
  }
})

这里就是给函数加了个括号和函数名，然后赋值给一个变量即可，这个应该没什么难的。倒是 命名函数这个名词要解释一下：

  命名函数是有名字（标识符）的函数表达式

与之对应的有个叫做匿名函数的名词：

  匿名函数是没有名字（标识符）的函数表达式

如上，通俗易懂。其中，匿名函数我们用的更多些。

二、闭包

闭包算是JS中最重要的几个概念之一了。在初学闭包概念时，我看过的很多博客和书中，并没有能让我恍然大悟的，这个概念也是慢慢理解的。所以，我会尽可能的将我理解的闭包写出来让大家参考，如有错误，欢迎指正。
先来说说比较官方的概念

    闭包指有权访问另一个函数作用域中变量的函数。最常见的方式，是在一个函数内部创建另外一个函数。

再说说我的理解：

      我所见到的闭包，大都是嵌套函数的形式，就像上面所说，一个函数里面有一个函数，
      里面的函数有权访问外部函数的变量和方法，内部的函数就叫做闭包。
      ---闭包这个词比较抽象，个人感觉它更像在描述内部函数访问外部变量、方法的这种行为。这句话仅供参考：）

上代码：

function outSide(par) {
  var a = 1
  var b = function() {
    console.log('outFunc')
  }
  return function inSide() {
    console.log(a,par)
    b()
  }
}

outSide(123)()   // 1   123
                 // outFunc

可以看到，执行了内部的函数后将外部的函数的变量和方法都访问了一遍。
是不是感觉很自然。好，那现在我们就更加深入一些。
要整明白闭包，就要理解函数被调用时发生了什么，那说到函数调用，就得说说作用域链了。不懂什么是作用域链的同学可以先看看《JS高级程序设计》第四章。

   当函数被调用时，会创建一个执行环境及相应的作用域链，然后使用arguments和其他命名参数的值来初始化函数的
   活动对象。但在作用域链中，外部函数的活动对象始终处于第二位，再外层的函数的活动对象处于第三位，直到作用域
   链终点全局执行环境。

通俗的讲，可以形容成一把伞，伞柄一节节可伸缩，手里握着最内层的伞柄，往上一节节的对应一层又一层的外层函数，最终伞面就是全局作用域。当一个闭包结束使用时，就好比伞柄坏了扔掉，但是全局作用域伞面还在，如果产生了一个新的闭包，就安装一个新伞柄。

注意
闭包虽然有好处，但是耗内存。因为它带着一大串作用域链盘在内存里，所以谨慎使用闭包。

1 闭包和变量

这里需要注意的点是：闭包只能取得外部函数中任何变量的最新值。
原因：闭包保存的是外部函数这个完整的对象，而不是其中的变量。
例：

function out () {
  var result = []

  for (var i = 0; i < 10; i++) {
    result[i] = function () {
      return i
    }
  }
  return result
}

执行完 i == 10 ，result中任何一个元素都保存着同一个 i 变量的引用，所以值都是相同的，而不是对应的索引值。
如果我们想当场获取i的值，可以使用下面的方法

function out () {
  var result = []

  for (var i = 0; i < 10; i++) {
    result[i] = function (num) {
      return function(){
        return num
      }
    }(i)
  }
  return result
}

这里又多了一个闭包，而原来的闭包成了一个立即执行函数，作用是立刻获取当前 i 值，它内层的闭包则是返回这个传进来的 i 值，这样就能使每个元素的值对应其索引了。

2 关于this对象

在普通函数中，this指向调用它时的对象；
在ES6的箭头函数中，this指向定义它时的对象。

这里只说关于普通函数的this。
还是举个例子

var name = 'the Window'

var object = {
  name: 'the object',
  getNameFunc: function(){ // 这个函数的this是object
    return function(){     // 这个函数的this是window
      return this.name
    }
  }
}

alert(object.getNameFunc()())   // 'the Window'(非严格模式下)

外层函数是字面量对象中的方法，所以this指向object；但内层函数只是一个普通函数，它在被调用时不会获取到外层函数的this。
当然，我觉得下面这种理解方式更容易些

object.getNameFunc()() ====> function(){ return this.name }()

object.getNameFunc()可以等效成后面的写法，而后面的函数this指向肯定是window。
那怎么才能获取到object当作this呢？
简单，如下

var object = {
  name: 'the object',
  getNameFunc: function(){ // 这个函数的this是object
    var that = this
    return function(){     // 这个函数的this是window
      return that.name
    }
  }
}

将外部函数的this保存下来给内部函数就行了。这样的情况在开发中也很常见。

3 块级作用域

在很久以前（ES6之前），js还没有块级作用域的概念，所以，使用了一些手段来达到块级作用域的目的。
首先来说块级作用域的好处，为什么要用它？

   块级作用域内可以产生私有变量，外界访问不到，一旦执行完，就直接销毁，大大减少内存开销；说的就是你，闭包！

那怎么用呢？
使用立即执行函数

(function(){
  // 这里是块级作用域
})()

// 注意不要写成这样，这样写function在最开始，成了函数声明，会报错
function(){
  // 。。。
}()

同样的，闭包也可以放在块级作用域内使用，以减少内存开销。
题外话
在《你不知道的js上卷》中有提到
其实try-catch代码块中的catch，它后面的｛｝中就是一个块级作用域，感兴趣的同学可以去了解一下。

三 私有变量

私有变量是指只有函数内部能访问，外部无法访问到的变量。
下面的例子我觉得挺好的，来看看

function MyObject () {
  // 私有变量
  var privateVariable = 10
  // 私有方法
  function privateFunction () {
    return false
  }

  // 特权方法
  this.publicMethod = function () {
    privateVariable++
    return privateFunction()
  }
}

嗯，看完代码应该都懂了，下面来说点特别的。

1 静态私有变量

多了两个字： 静态，那区别是什么？
先上代码：

(function() {
  // 私有变量
  var privateVariable = 10
  // 私有方法
  function privateFunction () {
    return false
  }
  MyObject = function(){}
  // 特权方法
  MyObject.prototype.publicMethod = function () {
    privateVariable++
    return privateFunction()
  }
})()

诶？立即执行函数？全局变量MyObject？原型方法？
看着没太大区别，但是好像鸟枪换炮。
先是将整体改造成了立即执行函数，又用了一个不带声明关键字的变量MyObject（即全局变量，严格模式下会报错！），最后给MyObject整了个原型方法来访问私有变量和方法。
不用问，私有变量和方法成了全部实例共享，这就是静态这两个字的含义。

2 模块模式

模块模式是为了单例创建私有变量和方法的。
单例又是什么？是指只有一个实例的对象。
按照惯例，JS是按照字面量的方式来创建单例对象的。
先来看看单例

var singleton = {
  name: 'value',
  method: function () {
    // 。。。
  }
}

在来看看模块模式做了什么

var singleton = function(){
  // 私有变量和方法
  var privateVarible = 10
  function privateFunction(){
    return false
  }
  // 公有属性和方法
  return {
    publicProperty: true,
    publicMethod:function(){
      privateVarible ++
      return privateFunction()
    }
  }
}

模块模式添加了私有变量和方法，并通过return的字面量对象访问私有变量和方法。和单例模式相比，增加了私有的部分。

应用：
在需要对单例进行某些初始化，同时又需要维护其私有变量时是很有用的。

3 增强的模块模式

听名字就知道比模块模式要强了。那来看来看有多强

var singleton = function () {
  // 私有属性，方法
  var privateVarible = 10

  function privateFunction () {
    return false
  }

  // 创建对象
  var object = new CustomType() //  这里的CustomType是可以客制化的（你想放啥放啥）

  // 添加公共属性和方法
  object.publicProperty = true 

  object.publicMethod = function () {
    privateVarible++
    return privateFunction()
  }

  // 返回对象
  return object
}

增强的地方：把字面量对象改成构造函数，又在实例上添加了属性和方法。

应用场景：
单例必须是某个类型的实例，同时还要添加某些属性和方法。