Dart中的函数-----下

箭头函数

• 需求：使用forEach打印下面List里面的数据

    List list=['苹果','香蕉','西瓜'];

第一种方式
    list.forEach((value){
      print(value);
    });

第二种方式---箭头函数：
实现方式1：
    list.forEach((value)=>print(value));

实现方式2：
    list.forEach((value)=>{
      print(value)
    });

打印结果：
苹果
香蕉
西瓜

• 需求：修改下面List里面的数据，让数组中大于2的值乘以2

    List list=[4,1,2,3,4];

第一种方式：
    var newList=list.map((value){
        if(value>2){
          return value*2;
        }
        return value;
    });
    print(newList.toList());

第二种方式---箭头函数：
   var newList=list.map((value)=>value > 2 ? value * 2 : value);
   print(newList.toList());

打印结果：
[8, 1, 2, 6, 8]

函数的相互调用

• 需求：
  1、定义一个方法isEvenNumber来判断一个数是否是偶数
  2、定义一个方法打印1-n以内的所有偶数

1、定义一个方法isEvenNumber来判断一个数是否是偶数 

第一种方式：
    bool isEvenNumber(int n){
      if(n%2==0){
        return true;
      }
      return false;
    }
第二种方式：
bool isEvenNumber(int n) =>n%2 == 0 ? true : false;


    printNum(int n){
        for(var i=1;i<=n;i++){
            if(isEvenNumber(i)){
              print(i);
            }
        }
    } 
printNum(10);  

打印结果：2 4 6 8 10

匿名方法

无参
  var printNum = (){
    print(123);
  };
  printNum();     //123


有参
  var printNum = (int n){
    print(n+2);
  };
  printNum(12);   //14

自执行方法

一运行就执行，不需要手动调用。

    ((int n){
      print(n);    //12
      print('我是自执行方法');   //我是自执行方法
    })(12);

方法的递归

 var sum=1;         
  fn(n){
    sum*=n;
    if(n==1){
      return ;
    }         
    fn(n-1);    
  }
  fn(5);      
  print(sum);

闭包

1、全局变量特点: 全局变量常驻内存、全局变量污染全局
2、局部变量的特点： 不常驻内存会被垃圾机制回收、不会污染全局

想实现的功能：
1.常驻内存
2.不污染全局
因此产生了闭包,闭包可以解决这个问题.....

闭包: 函数嵌套函数, 内部函数会调用外部函数的变量或参数, 变量或参数不会被系统回收(不会释放内存)。

闭包的写法： 函数嵌套函数，并return 里面的函数，这样就形成了闭包。

  fn(){
    var a=123;  /*不会污染全局   常驻内存*/
    return(){           
      a++;          
      print(a);
    };        
   }     
   var b=fn();  
    b(); //124
    b(); //125
    b(); //126