闭包：JavaScript，kotlin，Dart对比

很多语言都有闭包的特性，比如JavaScript,kotlin,Dart。虽然语言不同，但是原理特性都差不多，下面来做一下对比

1. JavaScript

   <script>
       /**
        * 子作用域可以访问父（甚至是祖先）作用域中的变量，而反过来不行
        * 闭包指子函数可以访问外部作用域变量的函数特性,即使在子函数作用域外也可以访问，在函数外部可以读取函数内部的局部变量
        * 如果子函数被使用时父级环境将被保留
        * 函数被执行后其环境变量将从内存中删除
        * 函数每次创建都会创建一个新作用域
        */
   
       function count() {
           let n = 1
           return function () {
               console.log(++n);
           }
       }
   
       let a = count()//子函数
       a()//子函数使用1  打印2
       a()//子函数使用2  打印3
       let m = count()
       m()//1
       m()//2
   
       class User {
           b = 1;
   
           show() {
               console.log(this.b++);
           }
       }
   
       let u = new User()//这个时候class其实也可以写成function 但是必须用new
       u.show()//1
       u.show()//2
       let s = new User()
       s.show()//1
   
   
       let arr = [];
       for (var i = 0; i < 10; i++) {
           arr.push(() => i)//没有闭包
       }
       console.log(arr[3]());//没有闭包，不管是执行第几个元素都会输出10
       let arr1 = []
       for (var i = 0; i < 10; i++) {
           (function (a) {//自行构建闭包
               arr1.push(() => a)
           })(i)//每次push都是在一个函数内执行，每次循环都会创建一个新的作用域
       }
       console.log(arr1[3]());//3
   
       function test(a, b) {
           if (a > b) {
               let t = 3
           } else {
               let t = 2//if和else中的变量互补干扰
           }
       }
   
       (function (a) {
           console.log(a);
       })("自执行函数")
   
   </script>
   

2. Kotlin

   fun main() {
       { x:String ->
           println(x)
       }("自执行闭包")
       val a = count()
       a()//2
       a()//3
       val u = User()
       u.show()//2
       u.show()//3
   
       val arr = mutableListOf<() -> Int>()
       for (i in 0..10) {
           arr.add(i,fun ():Int{return i})
       }
       println(arr[4]())//4
   
   
   }
   
   fun count(): () -> Unit {
       var a = 1
       return fun() {
           println(++a)
       }
   }
   
   class User{
       var a = 1
       val show = fun (){ println(++a)}
   }
   

3. Dart

   void main() {
     (x) {
       print(x);
     }("自执行闭包");
   
     var count = () {
       var a = 1;
       return () {
         print(++a);
       };
     };
   
     var a = count();
     a();//2
     a();//3
       
     var p = Person();
     p.increNum();//1
     p.increNum();//2
   }
   class Person{
     var a = 1;
     void increNum(){
       print('${a++}');
   
     }
   }
   
   
   

   一言以蔽之，闭包就是在函数作用域之外，依然能访问函数作用域内的变量(在Dart中叫状态的函数)