閉包是什麼

• 第一種說法：閉包建立一個詞法作用域，這個作用域內里的變量被援用以後能夠在這個詞法作用域表面被自在接見，是一個函數和聲明該函數的詞法環境的組合
• 第二種說法：閉包就是援用了自在變量的函數，這個自在變量與函數一同存在，縱然脫離了建立它的環境。所以常常看到的說閉包就是綁定了上下文環境的函數。
• 我更傾向於閉包是一個函數和聲明該函數的詞法環境的組合。

JS內里的閉包

先上一個閉包

function sayHello(name){
    let str = 'Hello,${name}';
    function say(){
        console.log(str);
    }
    return say;
}

let myHello = sayHello('abby');
myHello();

該例子的詮釋

上面的代碼，在sayHello函數內里定義的say函數和這個函數聲明的詞法環境就形成了一個閉包。say函數援用了sayHello函數內里定義的一個變量str，而且sayHello函數將say這個函數return了出去，如許，在sayHello函數的表面也能接見到它詞法作用域內里的變量str，末了就像say這個函數和str這個變量綁定了一樣

為何在外部還能接見到變量str呢？

• 在一些語言中，平常以為函數的局部變量只在函數的實行時期能夠接見
• 當上段代碼在實行到let myHello = sayHello('abby');這段代碼的時刻，按剖析銷毀掉sayHello這個函數的實行環境，然則在這裏卻沒有，由於，sayHello這個函數返回的是一個函數，這個函數內里的str援用了外部的變量str，假如銷毀了sayHello的實行環境就會找不到了，所以，sayHello的實行環境會一向在內存中，所以也就會有閉包會增添內存開支的說法

體味

• 在JavaScript語言中，只要函數內部的子函數才讀取內部變量，能夠把閉包簡樸明白成“定義在一個函數內部的函數”
• 閉包就是將函數內部和函數外部連接起來的一座橋樑

閉包的用途

1、讀取函數內部的變量

2、讓這些變量一向保持在內存中

function createIncrementor(start) {
    return function () {
        return start++;
    };
}
var inc = createIncrementor(5);
inc() // 5
inc() // 6
inc() // 7

start是函數createIncrementor的內部變量，經由過程閉包，start的狀況被保存了，每一次挪用都是在上一次挪用的基礎上舉行盤算，閉包inc使得函數createIncrementor的內部環境一向存在，由於inc一向存在內存中，而inc的存在依賴於createIncrementor，因而該函數不會在挪用完畢后，被渣滓接納機制接納

3、封裝對象的私有屬性和私有要領

function Person(name) {
    var _age;
    function setAge(n) {
        _age = n;
    }
    function getAge() {
        return _age;
    }
    return {
        name: name,
        getAge: getAge,
        setAge: setAge
    };
}

var p1 = Person("xiaoming");
p1.setAge(25);
pa.getAge(); //25

函數Person的內部變量_age，經由過程閉包getAge和setAge，變成了返回對象p1的私有變量，外層函數每次運轉，都邑發生一個新的閉包，而這個閉包又會保存外層函數的內部變量，內存也就斲喪較多

在舉幾個例子

1、罕見的閉包都是return出來一個函數，但並非申明，閉包肯定須要return一個函數，return一個函數也只是為了能在作用域局限以外接見一個變量

let say;
function sayHello(name){
    let str = 'Hello,${name}';
    say = function(){
        console.log(str);
    }
}

let myHello = sayHello('abby');
say();

2、同一個挪用函數天生同一個閉包環境，在內里聲明的一切函數同時具有這個環境內里的變量的援用

let get,up,down
function setUp(){
    let number = 20;
    get = function(){
        console.log(number);
    }
    up = function(){
        number += 3;
    }
    down = function(){
        number -= 2;
    }
}

setUp();
get();
up();
down();
get();

3、每一個挪用函數都邑建立差別的閉包環境，內里的變量互不影響

function newClosure(){
    let array = [1,2];
    return function(num){
        array.push(num);
        console.log('array:${array}');
    }
}

let myClosure = newClosure();
let yourClosure = newClosure();
myClosure(3);
yourClosure(4);
myClosure(5);

4、在輪迴內里建立閉包

function newClosure(){
    for(var i=0;i<5;i++){
        setTimeout(function(){
            console.log(i);
        });
    }
}

newClosure();//5個5

革新要領一：建立一個新的閉包對象，如許每一個閉包對象內里的變量就互不影響

function log(i){
    return function(){
        console.log(i);
    }
}

function newClosure(){
    for(var i=0;i<5;i++){
        setTimeout(log(i));
    }
}
newClosure();

每次log(i)都邑建立差別的閉包對象，一切的回調函數不會指向同一個環境

革新要領二：運用自實行函數，外部的匿名函數會馬上實行，而且把i作為它的參數，此時函數內變量e就具有了i的一個拷貝。當傳遞給setTimeout的匿名函數實行時，它就具有了對e的援用，而這個值是不會被輪迴轉變的

function newClosure(){
    for(var i=0;i<5;i++){
        (function(e){
            setTimeout(function(){
                console.log(e);
            });
        })(i)
    }
}

newClosure();