闭包
        闭包 -- 闭包函数 闭包变量
        1、（作用） 可以访问其他函数内部变量的 函数

        2、（表现方式）定义在函数内部的函数 -->闭包函数

        3、（写法）函数嵌套函数 。。里面的函数 ---闭包函数
        
    function a(){
        var x=1; 
        // x 闭包变量 -- 长期驻扎在内存中，不会销毁。可能导致内存泄漏
        // b 函数--闭包函数
        function b(){
            console.log("x",x);
        }
        b();

    }
  a()

  function a(){
        var x=1; 
        // x 闭包变量 -- 长期驻扎在内存中，不会销毁。可能导致内存泄漏
        // b 函数--闭包函数
        ;;(function (){
            console.log("x",x);

        })()
    }

  a()

    function a(){
        var x=1; 
        // x 闭包变量 -- 长期驻扎在内存中，不会销毁。可能导致内存泄漏
        // b 函数--闭包函数
        return  function (){
            console.log("x",x);

        }
    }
    @[TOC](这里写目录标题)

闭包应用
  a()()可以给计时器传参数
    for(var i=0;i<5;i++){

        // setTimeout(function(){
        //     console.log(i);
        // },1000*i)

        (function (i){
            // console.log(index)// 0 1 2 3 4
            setTimeout(function(){
                console.log(i)// 0 1 2 3 4
            },1000*i)
        })(i)
        // a(i);
    }
    */
    // console.log(i)

    function a(xxx){
        setTimeout(function(){
            console.log(xxx)
        },1000)
    }
    a("hhhhhhhhhhhh");
    a("哈哈哈哈哈哈哈");

所谓的函数闭包本质是函数的嵌套和高阶函数。我们来看看要实现函数闭包要满足什么条件（缺一不可）：
1)必须嵌套函数

2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量

3)外部函数必须返回内嵌函数——必须返回那个内部函数
闭包的作用：可以保持程序上一次运行后的状态然后继续执行。
我们来看一闭包函数的一个实例
def foo():
    num=1
    def add(n):
        nonlocal  num
        num += n
        return num
    return add
f=foo()
print(f(1))  #2
print(f(2))  #4

我们可以用函数闭包来实现一个函数的装饰器：
我们知道函数装饰器要满足如下条件：
1、不能改变原来函数的代码。

2、为函数添加新的功能。

3、不能改变函数的调用方式。
使用函数闭包完全可以做到这一点。
下面我们的为一个函数，增加统计时间的功能：
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import  time
def foo():
    time.sleep(3)
    print('aaa')
def decorate(fun):
    def bibao():
        start=time.time()
        fun()
        end=time.time()
        print('花费的时间是%d'%(end-start))
    return bibao
foo=decorate(foo)
foo()    
#aaa
花费的时间是3

5.函数及函数闭包 

5.1函数

--多返回值的函数
function foo(a,b,c)
    local sum=a+b;
    return sum,c
end
--平行赋值
r1,r2=foo(1,"123","helloworld!")
print(r1,r2)

运行结果： 


5.2函数闭包 

  Upvalue:一个函数所使用的定义在它的函数体之外的局部变量 

函数闭包：一个函数和它所有使用的upvalue构成函数的闭包

function countdowntimer(second)
    local ms=second*1000
--ms对于函数countDown()是一个upvalue,对于函数countdowntimer()只是一个局部变量
    local function countDown()
        ms=ms-1
        return ms
    end
--返回的是一个函数
    return countDown
end
--time1为函数
time1=countdowntimer(1)
for i=1,3 do
    print(time1())

end
print("#########")

time2=countdowntimer(1)
for i=1,3 do
    print(time2())
end

运行结果： 

JavaScript  函数闭包
什么是闭包
闭包就是能够读取其他函数内部变量的函数，

由于在 Javascript 语言中，只有函数内部的子函数才能读取局部变量，

因此可以把闭包简单理解成 “定义在一个函数内部的函数”。

所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
闭包的用途：

可以在函数外部读取函数内部成员
让函数内成员始终存活在内存中

function fn () {
  var count = 0
  return {
    getCount: function () {
      console.log(count)
    },
    setCount: function () {
      count++
    }
  }
}

var fns = fn()

fns.getCount() // => 0
fns.setCount()
fns.getCount() // => 1

作用域、作用域链、预解析

全局作用域
函数作用域
没有块级作用域

{
  var foo = 'bar'
}

console.log(foo)

if (true) {
  var a = 123
}
console.log(a)

作用域链示例代码：
var a = 10

function fn () {
  var b = 20

  function fn1 () {
    var c = 30
    console.log(a + b + c)
  }

  function fn2 () {
    var d = 40
    console.log(c + d)
  }

  fn1()
  fn2()
}


内层作用域可以访问外层作用域，反之不行

一些关于闭包的例子
示例1：
var arr = [10, 20, 30]
for(var i = 0; i < arr.length; i++) {
  arr[i] = function () {
    console.log(i)
  }
}

示例2：
console.log(111)

for(var i = 0; i < 3; i++) {
  setTimeout(function () {
    console.log(i)
  }, 0)
}
console.log(222)

闭包的思考题
思考题 1：
var name = "The Window";
var object = {
  name: "My Object",
  getNameFunc: function () {
    return function () {
      return this.name;
    };
  }
};

console.log(object.getNameFunc()())//结果：The Window

思考题 2：
var name = "The Window";　　
var object = {　　　　
  name: "My Object",
  getNameFunc: function () {
    var that = this;
    return function () {
      return that.name;
    };
  }
};
console.log(object.getNameFunc()()) //结果:My Object