函数表达式

有两种方式：1、函数声明2、函数表达式
函数声明会提升，函数表达式不会。
函数声明，在执行函数之前会先读取函数声明。

sayhi()//‘hi’
function sayhi(){
 console.log('hi');
}
//不会出错

函数表达式

sayhi()//‘hi’
var  sayhi=function(){
 console.log('hi');
}
//会出错

函数表达式和函数声明中没有函数名的函数，都是匿名函数

//不要这样做！,有的浏览器用第一个声明，有的用第二个
if(condition){
   function sayHi(){
    alert("Hi!");
  }
} else {
  function sayHi(){
  alert("Yo!");
  }
}
//可以这样做
var sayHi;
 if(condition){
  sayHi = function(){
   alert("Hi!");
  };
} else {
  sayHi = function(){
  alert("Yo!");
 };
}

闭包

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

• 闭包可以让外侧函数的局部变量驻留内存，实现局部变量的累加,过度使用闭包导致性能下降,内存泄漏

function a(){
   var age=1;
    return function(){
         age++;
        return age;
    }  
}
var x=a();
console.log(x())//2
console.log(x())//3

但是此处要注意，先把·x=a()`，a（）返回该闭包中的匿名函数，然后调用x（），调用的是a函数返回同一个匿名函数。若连续多次打印a()(),则变量age不会累加，因为每次执行a()(),都重新返回了函数。

function a(){
   var age=1;
    return function(){
         age++;
        return age;
    }  
}
// var x=a();
console.log(a()())//2
console.log(a()())//2
console.log(a()())//2

• 由于作用域链的机制导致一个问题，循环里的匿名函数取得的任何变量都是最后一个值。闭包所保存的是整个变量对象，而不是某个特殊的变量。

function box() {
    var arr = [];
    for (var i = 0; i < 5; i++) {
        arr[i] = function() {
            return i;
        };
    }
    return arr;
}
var b = box(); //得到函数数组
alert(b.length); //得到函数集合长度
for (var i = 0; i < b.length; i++) {
    console.log(b[i]()); //输出每个函数的值，都是最后一个值55555
}

因为b中存的是匿名函数对象，当bi执行匿名函数时，box（）中的for循环早已执行完毕，i早已变成5.
解决方法1：让匿名函数自我执行

function box() {
    var arr = [];
    for (var i = 0; i < 5; i++) {
        arr[i] = (function(i) {
            return i;
        })(i);
    }
    return arr;
}
var b = box(); //得到函数数组
alert(b.length); //得到函数集合长度
for (var i = 0; i < b.length; i++) {
    console.log(b[i]); //输出0,12,3,4
}

解决方法2：匿名函数下在创建一个匿名函数，外侧匿名函数自执行

function box() {
    var arr = [];
    for (var i = 0; i < 5; i++) {
        arr[i] = (function(num) {
            return function() {
                return num;//具体数字
            };
        })(i)
    }
    return arr;
}
var b = box(); //得到函数数组
alert(b.length); //得到函数集合长度
for (var i = 0; i < b.length; i++) {
    console.log(b[i]()); //输出 01234
}

解决方法3:使用ES6中的let

function box() {
    var arr = [];
    for (let i = 0; i < 5; i++) {
        arr[i] = function(){
            return i
        }
    }
    return arr;
}
var b = box(); //得到函数数组
console.log(b.length); //得到函数集合长度
for (var i = 0; i < b.length; i++) {
    console.log(b[i]()); //输出 01234
}

this对象

this对象是在运行时基于函数的执行环境绑定的，如果this在全局范围就是window，如果在对象内部就指向这个对象。而闭包却在运行时指向window，因为闭包并不属于这个对象的属性或方法。

var user='window';
var obj={
    user:'obj',
    getUserName:function(){
        return function(){
            return this.user;
        }
    }
}
console.log(obj.getUserName()());//window

解决1：强制指向特定对象

console.log(obj.getUserName().call(obj));//obj
console.log(obj.getUserName().apply(obj));//obj
var x=obj.getUserName().bind(obj)
console.log(x())//obj

解决2：复制this，得到上一个作用域的this对象

var user='window';
var obj={
    user:'obj',
    getUserName:function(){
        var that=this;
        return function(){
            return that.user;
        }
    }
}
console.log(obj.getUserName()());//obj

匿名函数仿块级作用域

for循环中的var i在外部也能访问

function box(count) {
for (var i=0; i<count; i++) {}
var i; //就算重新声明，也不会覆盖前面的值,除非重新初始化
alert(i);
}
box(2);//2

解决1：
//模仿块级作用域(私有作用域)
(function () {
//这里是块级作用域
})();

//使用块级作用域(私有作用域)改写
function box(count) {
(function () {
for (var i = 0; i<count; i++) {}
})();
alert(i); //报错，无法访问

}
box(2);

解决2：ES6中使用let

function box(count) {
for (let i=0; i<count; i++) {}
alert(i); //i报错

}
box(2);

参考资料：JavaScript高级程序设计（第3版）