自执行方法 匿名方法 闭包等

int Quan=1000;//这个是全局变量

void main() {
  
 //拓展作业 定义一个匿名方法
  
  var Niming=(){
    print('我是一个匿名方法 就是()里不带参');
  };
  Niming();//输出 我是一个匿名方法 就是()里不带参  （也可带参）
  
  
  
  //自执行方法  《先一对括号 后而在第一个括号里 写方法》
  ((){
    print('我是一个自执行方法 我自己会动！');//我是一个自执行方法 我自己会动！
  })();
  
  
  //自执行方法带参操作
  
  ((data){
    print('自执行方法也可以带参数的 $data');//自执行方法也可以带参数的 data=这个是参数
  })('data=这个是参数');
  
  
  
  //递归 假设 需要求 1-100的累积和
  var zong=0;
  int leijia(int n){
     zong+=n;
    
     if(n==1){ //重在让递归停止 写好条件让其return
       return ;
     }
    leijia(n-1);//再次调用
  }
  
  leijia(100);
  print(zong);//输出5050
  
  
  
  /*
   闭包
   1、全局变量 写在main以外的变量 为全局变量 会常驻内存 还会导致影响全局的变量
   2、局部变量 写在main以内的变量，也是方法内的变量 不会常驻内存 会被回收机制销毁 也不会污染全局
   
   
   需求:
    假设想实现  能常驻内存 但是不会污染全局的变量  那就得用闭包  （Quan在第一行代码)
   */ 
  
  //全局变量  -  会存在被污染的情况
  fn(){
    Quan++;
    print(Quan);
  }
  fn();//调用一次 让全局变量 自增1   输出1001
  fn();//调用一次 让全局变量 自增1   输出1002
  fn();//调用一次 让全局变量 自增1   输出1003
  
  //如果其他地方调用的话 那就是1003了 按最后那个值为准
 
  int newnum=Quan;
  print(newnum);//这里就是1003了 会脏数据 会影响其他函数的调用
  
  
  //局部变量 - 则不存在这个问题
  judata(){
  var  a1=100;
    a1++;
    print(a1);
  }
  judata();//输出101
  judata();//输出101 始终输出101 因为局部变量不会受到影响
  
  
print('--------------分隔线-------------------');
  
  //开始闭包  实战写法  (方法里面嵌套方法 并且返回这个方法)
  bbao(){
    var b=123;
    return(){
      b++;
      print(b);
    };
  };

  var c=bbao();
  c();//输出124
  c();//输出125
  c();//输出126 实现了 常住内存  又不会污染全局
  
  
  /**
   适合需要调用累加的时候 每次都会累积操作 方法会记录前一次的值 不会影响全局 
   
   就好比 1+1等于2   a=2 时，再来操作这个a+1 那么就是 2+1等于3，下一次请求再来的时候 那就是 3+1 
   让变量常驻内存  不污染全局
   
         */ 
   
}

方法传参 默认传参 指定传参等

void main() {
  
  //如指定一个int类型的方法
  int GetNum(int n){
    return n;
  };
  //调用
  var n1=GetNum(666);//只能传入int类型 且如若不是 会报错 因为在传参哪儿已规定要int类型的
  print(n1);//输出6666
  
  
  
  //如指定一个String类型的方法
  String GetString(String  s){
    return s;
  };
  //调用
  var s1=GetString('我是字符串');
  print(s1);//输出我是字符串
  
 
  
  //设置可为空的参数方法  参数可传 可不传
  String test(String name,[int age]) {
    if(age ==null){
      return ("我叫 $name ---  但是我的年龄不告诉你");
    }
      return ("我叫 $name --- 我的年龄是 $age");
  }
  print(test('张三'));//输出我叫 张三 ---  但是我的年龄不告诉你
   print(test('张三',18));//我叫 张三 --- 我的年龄是 18
  
  
 
  
  //设置默认参数
  String DataInfo(String name,[int age=10]){
    return "$name --- $age";
  }
  print(DataInfo('小刘'));//小刘 --- 10
  print(DataInfo('小刘',20));//小刘 --- 20
  
  
 
  //设置指定参数
  String getData(String name,{int age,int younum,int mynum}){
    
        return "我的名字$name --- 我的age$age--- 我的younum$younum--- 我的mynum$mynum";
  }
  
  //形参  (指定的参数可以打乱顺序传参 只要格式没错就可以)
   print(getData('涓涓',age:20,younum:60));//我的名字涓涓 --- 我的age20--- 我的younum60--- 我的mynumnull
  
   print(getData('小刘爱涓涓',younum:20,age:60));//我的名字小刘爱涓涓 --- 我的age60--- 我的younum20--- 我的mynumnull
  
  
          
  print('----------------------我是分隔线----------------------');
  
//实现一个 把方法当做参数的方法

var fn=(){
print('我是一个匿名方法');
};

var fn2=(data){
   data();
  print('成功调用');
};
  
 
//调用fn2这个方法 把fn这个方法当做参数传入
fn2(fn);
}

箭头函数

//箭头函数的使用  可代替forEach和三元判断符等
  
  //假设让下面数组内的value打印出来 按forEach的话 那就是
  var list=['苹果','香蕉','西瓜'];
  list.forEach((value){
    print(value);
  });//会依次输出  苹果 香蕉  西瓜
  
 
  //让箭头来写的话 那就是
  list.forEach((value)=>print(value));//会依次输出  苹果 香蕉  西瓜
  
  //箭头函数 不用加封号 只能写一句话  也可写三元运算符  箭头函数三元运算符
  
  List data=[1,2,4,5,6,7,8];
  //把data数组中 大于等于4的值*2
  var a1=data.map((value){
    if(value>=4){
     return value*2;
    }
    return value;
  });
  print(a1);//(1, 2, 8, 10, 12, 14, 16)
  
  
  
  //箭头函数 实现把data数组中 大于等于4的值*2
  var jdata=data.map((value)=>value>=4?value*2:value);
  print(jdata); //输出(1, 2, 8, 10, 12, 14, 16)

拓展作业

void main() {
  
 //拓展作业 定义一个可以识别当前参数是否为偶数的方法  返回布尔值
  
  bool IsOushu(int n){
    if(n%2==0){
      return true; 
    }
      return false;
  }
  
//   print(IsOushu(2));//返回true
  
  //定义一个方法 可以打印 1 -n以内的所有偶数 ，嵌套方法处理(用上IsOushu)
  int intData(int n){
     
    for(int i=1;i<=n;i++){
      bool isOU=IsOushu(i);
      if(isOU==true){
        print(i);
      }
    }
  }
  
  intData(10);//输出  2  4  6 8 10