闭包和this

### 1.闭包概念特点

```js

// 闭包:当一个a函数retrun返回另一个函数,那个这个函数a就是闭包函数

// 优点:1:防止变量污染

// -----> 闭包函数在执行时候,彼此独立互不干扰

//      2: 外部函数可以访问内部函数的变量(此处不正确,但是用于辅助理解)

// ------> 外部的变量只是引用了;闭包函数内部的retrun函数,在作用域链的角度上,没有违背,函数变量私有化的原则

// 缺点:容易内存泄漏

// ----> 正常情况函数执行结束变量释放,因为闭包函数中变量 未来可能会被其他程序引用,所以不会销毁.占据了内存

function foo() {

            var i = 0

            var b = 0//b 没有被销毁

            return function () {

                i = i + 1

                console.log(i);

            }

        }

    var a = foo()

    a()

    a()

    a()

    var b = foo()

    b()

    b()

    b()

```

### 2.闭包特点原理

```js

// 程序一

        function foo() {

            var i = 0;

            var b = 0; // b 没有销毁

            return function () {

                i = i + 1;

                console.log(i);

            }

        }

        // 1: 函数内部的变量没有被销毁,AO对象没有被销毁

        var a = foo();

        a()

        a()

        a()

        // 2: 外面的函数执行多次,彼此独立的.

        // 3: 执行多次形成多个独立的ao对象

        var b = foo();

        b();

        b();

        b();

 

        // i 变量没有销毁，因为未来程序中，随时可能需要i变量

        // -------------分界线---------------

        // 程序二

        // function foo1() {

        //     var i = 0;

        //      function bar() {

        //         i = i + 1;

        //         console.log(i);

        //     }

        //     bar()

        //     bar()

        //     bar()

        // }

        // foo1()

        // 程序一 与 程序二区别

        // 1：程序一中的内部函数，未来随时又可以被触发，所以一直存在

        // 2：程序二中内部函数，当外部函数执行结束，内部函数销毁。

       

        // 重点：

        // 1: 闭包相似程序的区分

        // 2: 一个变量在生么情况下会被销毁 , 未来不在需要的时候.

```

### 3.闭包语法

```js

function foo() {

      var i = 0

      i = i + 1

      bar() //bug：问题: 为什么没有return 可以调用bar函数:有了return  bar is not defined

      // return 可以将 bar 属性 从 fooContext 中删除 ???

      // 相当于只有匿名函数

      return function bar() {

        console.log("bar run");

      }

    }

    foo()

```

### 4.解决变量污染

```js

function foo() {

            var i = 0

            var b = 0//b 没有被销毁

            return function () {

                i = i + i

                console.log(i);

            }

        }

        var a = foo()

        a()

        a()

        a()

        var b = foo()

        b()

        b()

        b()

        //解决变量污染,就是让return 返回的函数在全局下实现 零引用

        a = null

        b = null

        // 也可以foo=null

        //让闭包函数成为一个立即执行函数

        (function(){

            return function(){

            }

        })()

        c()

        c()

        c()

        c=null

```