一、apply 和 call 方法

apply 和 call 都可以改變呼叫其的函式或方法中的 this 指向。

不同的是傳入引數時，apply 有兩個引數，第二個引數是陣列；call 從第二個引數開始是呼叫其的函式的所有引數。

使用方法：

1、apply的使用語法：

函式名.apply(物件，[引數1， 引數2，... ])；

方法名.apply(物件，[引數1， 引數2，... ])；

2、call的使用語法：

函式名.call(物件，引數1， 引數2，... )；

方法名.call(物件，引數1， 引數2，... )；

1、函式呼叫apply和call

function f1(x, y) {
  console.log(x+y +this); // 這裡面的this是window
  return x+y;
}

var r1 = f1.apply(null, [10,20]); // 列印30 window，傳入的是null，所以this指向還是window
console.log(r1); // 30
var r2 = f1.call(null, 10,20);// 列印30 window
console.log(r2); // 30
 

//函式改變 this 的指向
var obj = {};

var r1 = f1.apply(obj, [10,20]); // 列印30 window，傳入的是Obj，所以this指向是Obj
console.log(r1); // 30
var r2 = f1.call(obj, 10,20);// 列印30 Obj
console.log(r2); // 30

2、方法呼叫apply和call

// 方法改變 this 的指向
    function Person(age) {
        this.age = age;
    }
    Person.prototype.eat = function () {
        console.log(this.age); // this 指向例項物件
    };

    function Student(age) {
        this.age = age;
    }

    var per = new Person(18);
    var stu = new Student(20);

    per.eat.apply(stu); // 列印 20
    per.eat.call(stu); // 列印 20
 

由於 eat 方法已經指向了 Student 了，所以列印 20，而不是 18.

問題：我們知道函式也是物件，函式可以呼叫 apply 和 call 方法，但是這兩個方法並不在這個函式這個物件的例項函式中，那麼在哪裡呢？

解答：所有的函式都是 Function 的例項物件，而 apply 和 call 就在 Function 建構函式的原型物件中。

二、bind方法

bind 是複製的意思，也可以改變呼叫其的函式或方法的 this 指向，引數可以在複製的時候傳進去，也可以在複製之後呼叫的時候傳進去。

使用語法：

1、函式名.bind(物件, 引數1, 引數2, ...); // 返回值是複製的這個函式

2、方法名.bind(物件, 引數1, 引數2, ...); // 返回值是複製的這個方法

1、函式呼叫 bind

function f1(x, y) {
    console.log(x + y + this);
}
// 1.引數在複製的時候傳入
var ff = f1.bind(null,10,20); // 這只是複製的一份函式，不是呼叫，返回值才是
ff();

// 2.引數在呼叫的時候傳入
var ff = f1.bind(null); // 這只是複製的一份函式，不是呼叫，返回值才是
ff(10,20);

2、方法呼叫 bind

function Person(age) {
    this.age = age;
}

Person.prototype.eat = function () {
    console.log(this.age); // this 指向例項物件
};

function Student(age) {
    this.age = age;
}

var per = new Person(18);
var stu = new Student(20);

var ff = per.eat.bind(stu);
ff(); // 20

bind和call，apply的區別：[update:2018.07.26]

bind繫結this的指向之後，不會立即呼叫當前函式，而是將函式返回。
而call，apply繫結this指向後會立即呼叫。

如果我們在不知道什麼時候會呼叫函式的時候，需要改變this的指向，那麼只能使用bind。

比如：在定時器中，我們想改變this的指向，但是又不能立即執行，需要等待2秒，這個時候只能使用bind來繫結this。

setInterval(function(){
    // ...
}.bind(this), 2000);

三、閉包

1、閉包的概念

有一個函式 A 中有一個函式或者物件 B，那麼函式或者物件 B 可以訪問函式 A 中的資料，那麼函式 A 的作用域就形成了閉包。

2、閉包的模式

函式模式的閉包：函式中包含函式。

物件模式的閉包：函式中包含物件。

3、閉包的作用

快取資料，延長作用域鏈。

4、閉包的優缺點

也是快取的資料，導致在閉包的範圍內一直起作用。

5、閉包的應用

快取資料，函式中的資料，外面可以使用。

如果想要快取資料，就把這個資料放在外層的函式和裡層的函式之間。這樣不停的呼叫裡層函式，相當於外層函式裡的資料沒有得到及時釋放，就相當於快取了資料。

// 函式閉包
function A() {
    var num = 10;
    return function () {
        return num++;
    }
}

var func = A();
console.log(func());
console.log(func());
console.log(func());

// 物件閉包
function A() {
    var num = 10;
    return {
        age: num++
    };
}
var func = A();
console.log(func.age);

四、沙箱

沙箱：一小塊的真實環境，裡面發生的事情不會影響到外面。相同的操作，相同的資料都不會和外面發生衝突。

作用：避免命名衝突。

比如：自呼叫函式裡面就相當於一個沙箱環境。

(function (){
        
}());

五、區分偽陣列和真陣列

// 真陣列
    var arr = [10,20,30];
    // 偽陣列
    var obj = {
        0:10,
        1:20,
        2:30,
        length: 3
    };
    // 真陣列的訪問
    for(var i=0; i<arr.length; i++) {
        console.log("真陣列的訪問："+arr[i]);
    }
    // 偽陣列的訪問
    for(var j=0; j<obj.length; j++) { // 錯誤：物件中沒有length方法
        console.log("偽陣列的訪問："+obj[j]);
    }

方法一、使用 length 來區分

這樣看起來，真陣列和偽陣列就沒法區別了。

但是真陣列的長度 length 可以改變，偽陣列不可以，貌似可以區分了。

但是，你還記得有個 arguement 這個偽陣列（物件）的 length 是可以改變的，方法一區分失敗。

方法二、使用陣列的方法 forEach 來鑑別

因為每個陣列都是 Array 的例項物件，而 forEach 在 Array 的原型物件中，所以其他的偽陣列是不能使用的。方法二成功。