【Flutter】Dart篇之二

青旅半醒 2024-04-26 02:03 98阅读 0赞

> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[Flutter学习][Flutter]  
> ? 首发时间：2024年4月22日  
> ? 欢迎关注?点赞?收藏?留言?

#### 目录 ####

*  条件表达式
 *  循环语句
 *   *  for
     *  while 和 do ... while
     *  break 和 continue
 *  集合类型详解
 *   *  List
     *  Set
     *  Map
     *  集合类型常用的循环语句
 *  方法详解
 *   *  方法传参
     *  可选参数
     *  默认参数
     *  命名参数
     *  方法作为参数
     *  箭头函数
     *  函数的相互调用
     *  匿名方法
     *  自执行方法
     *  方法的递归
     *  闭包

## 条件表达式 ##

*  if else
 *  switch case

用法和其它语言一样

## 循环语句 ##

Dart 中的循环语句有：

*  for
 *  while
 *  do … while

### for ###

**for** 循环的基础用法我们都发，下面我们来讲一些比较特殊的：

void main() {
        
      //1、打印List
      List l1 = [
        {
        "title": "新闻111"},
        {
        "title": "新闻222"},
        {
        "title": "新闻333"}
      ];
    
      print(l1[1]);
    
      for (var i = 0; i < l1.length; i++) {
        
        print(l1[i]['title']);
      }
      print('-------------');
    
      //2、定义一个二维数组, 打印里面的内容
      List l2 = [
        {
        
          "cate": '国内',
          "news": [
            {
        "title": "国内新闻1"},
            {
        "title": "国内新闻2"},
            {
        "title": "国内新闻3"}
          ]
        },
        {
        
          "cate": '国际',
          "news": [
            {
        "title": "国际新闻1"},
            {
        "title": "国际新闻2"},
            {
        "title": "国际新闻3"}
          ]
        }
      ];
    
      for (var i = 0; i < l2.length; i++) {
        
        print(l2[i]["cate"]);
        for (var j = 0; j < l2[i]["news"].length; j++) {
        
          print(l2[i]["news"][j]["title"]);
        }
        print('-------------');
      }
    }

![在这里插入图片描述][0bf27677eb754807a35583d5ba90023a.png]

### while 和 do … while ###

*  语法格式:
    
        while(表达式/循环条件){
              			
        			
        }			
            		
        do{
              
        	语句/循环体			
        }while(表达式/循环条件);
 *  注意事项：
    
     *  最后的分号不要忘记
     *  循环条件中使用的变量需要经过初始化
     *  循环体中，应有结束循环的条件，否则会造成死循环

基础用法不讲，这里我们说一下 **while** 和 **do…while** 的区别

void main() {
        
      // while和do...while的区别, 第一次循环条件不成立的情况下, while 不会执行, do...while会执行一次
      int i = 10;
      while (i < 2) {
        
        print('while执行代码');
      }
    
      var j = 10;
      do {
        
        print('do...while执行代码');
      } while (j < 2);
    }

![在这里插入图片描述][a6beb142922547dabc89a046cb9373d1.png]

### break 和 continue ###

*  **break** 语句功能:
    
    1.  在 switch 语句中使流程跳出 switch 结构。
    2.  在循环语句中使流程跳出当前循环,遇到 break 循环终止，后面代码也不会执行
    3.  如果在循环中已经执行了 break 语句，就不会执行循环体中位于 break 后的语句
    4.  在多层循环中，一个 break 语句只能向外跳出一层
    5.  break 可以用在 switch case 中 也可以用在 for 循环和 while 循环中
 *  **continue** 语句的功能:
    
    1.  continue 只能在循环语句中使用，使本次循环结束，即跳过循环体重下面尚未执行的语句，接着进行下次的是否执行循环的判断
    2.  continue 可以用在 for 循环以及 while 循环中，但是不建议用在 while 循环中，不小心容易死循环

main() {
        
      //1、如果i等于4的话跳过
      for (var i = 1; i <= 6; i++) {
        
        if (i == 4) {
        
          print("i=4, 跳过当前循环体 然后循环继续执行");
          continue;
        }
        print(i);
      }
      print("------------");
    
      // 2、如果 i等于4的话跳出循环
      for (var i = 1; i <= 6; i++) {
        
        if (i == 4) {
        
          print("i=4, 跳出循环体, 即结束循环");
          break;
        }
        print(i);
      }
      print("------------");
    
      //3、break语句只能向外跳出一层
      for (var i = 0; i < 3; i++) {
        
        print('外层---$i');
        for (var j = 0; j < 3; j++) {
        
          if (j == 1) {
        
            break;
          }
          print('里层$j');
        }
      }
      print("------------");
    
      //4、while循环 break跳出循环
      var i = 1;
      while (i <= 10) {
        
        if (i == 4) {
        
          break;
        }
        print(i);
        i++;
      }
    }

![在这里插入图片描述][26375e2468c34ce09c22f3d41c5fcfc9.png]

## 集合类型详解 ##

### List ###

List里面常用的属性和方法：

*  常用属性：
    
     *  length：长度
     *  reversed：将列表翻转
     *  isEmpty：判断列表是否为空
     *  isNotEmpty：判断列表是否不为空
 *  常用方法：
    
     *  add：增加元素
     *  addAll：拼接数组
     *  indexOf：根据传入的具体值查找其索引
     *  remove：根据传入的具体值删除元素
     *  removeAt：根据传入的索引值删除元素
     *  fillRange：修改元素的值
     *  insert(index,value)：指定位置插入元素
     *  insertAll(index,list)：指定位置插入List
     *  toList()：将其他类型转换成 List
     *  join()：将 List 转换成字符串
     *  split()：将字符串转化成 List

void main() {
        
      //List里面的属性
      List myList = ['香蕉', '苹果', '西瓜'];
      print(myList.length);
      print(myList.reversed); //对列表倒序排序
      print(myList.isEmpty);
      print(myList.isNotEmpty);
    
      var newMyList = myList.reversed.toList();
      print(newMyList);
      print("------------");
    
      //List里面的方法
      myList.add('桃子'); //增加数据  增加一个
      myList.addAll(['桃子', '葡萄']); //拼接数组
      print(myList);
      print(myList.indexOf('苹x果')); //indexOf查找数据, 查找不到返回-1, 查找到返回索引值
      print("------------");
    
      myList.remove('西瓜');
      myList.removeAt(0);
      print(myList);
      print("------------");
    
      //传入参数: 开始索引，结束索引（不包含），修改值
      myList.fillRange(1, 2, 'aaa'); //修改
      myList.fillRange(1, 3, 'aaa');
    
      myList.insert(1, 'aaa'); //插入  一个
      myList.insertAll(1, ['aaa', 'bbb']); //插入 多个
      print(myList);
      print("------------");
    
      var str = myList.join('-'); //list转换成字符串
      print(str);
    
      var str1 = '香蕉-苹果-西瓜';
      var list = str1.split('-');
      print(list);
      print(list is List);
    }

![在这里插入图片描述][f66d44501d2d4fae89246d9232c665f0.png]

### Set ###

*  **Set** 最主要的功能就是去除数组重复内容
 *  **Set** 是没有顺序且不能重复的集合，所以不能通过索引来获取值

void main() {
        
      var s = new Set();
      s.add('香蕉');
      s.add('苹果');
      s.add('苹果');
      print(s); //{香蕉, 苹果}
      print(s.toList());
      print("--------------");
    
      //如何将一个List去重
      List myList = ['香蕉', '苹果', '西瓜', '香蕉', '苹果', '香蕉', '苹果'];
      var s1 = new Set();
      s1.addAll(myList);
      print(s1);
      print(s1.toList());
    }

![在这里插入图片描述][122732fbded74f87a5be1fe9106725c4.png]

### Map ###

映射（**Map**）是无序的键值对：

*  常用属性：
    
     *  keys：获取所有的key值
     *  values：获取所有的value值
     *  isEmpty：判断是否为空
     *  isNotEmpty：判断是否不为空
 *  常用方法:
    
     *  remove(key)：删除指定key的数据
     *  addAll(\{…\})：合并映射，给映射内增加属性
     *  containsValue：查看映射内是否包含某个值，返回 true/false

void main() {
        
      //常用属性：
      Map person = {
        "name": "张三", "age": 20, "sex": "男"};
    
      print(person.keys.toList());
      print(person.values.toList());
      print(person.isEmpty);
      print(person.isNotEmpty);
      print("-------------");
    
      //常用方法：
      person.addAll({
        
        "work": ['敲代码', '送外卖'],
        "height": 160
      });
      print(person);
    
      person.remove("sex");
      print(person);
    
      print(person.containsValue('张三'));
    }

![在这里插入图片描述][48a1a22f084c4981b2c75072d2a564ac.png]

### 集合类型常用的循环语句 ###

*  forEach
 *  map
 *  where
 *  any
 *  every

void main() {
        
      //list
      List myList = ['香蕉', '苹果', '西瓜'];
    
      //遍历List
      for (var i = 0; i < myList.length; i++) {
        
        print(myList[i]);
      }
    
      for (var item in myList) {
        
        print(item);
      }
    
      //forEach: 遍历List
      myList.forEach((value) {
        
        print("$value");
      });
      print("----------------");
    
      //将List中的数据每个乘以2
      List myList1 = [1, 3, 4];
      var newList = myList1.map((value) {
        
        return value * 2;
      });
      print(newList.toList());
      print("----------------");
    
      //where: 通过条件筛选List中的元素
      List myList2 = [1, 3, 4, 5, 7, 8, 9];
      var newList2 = myList2.where((value) {
        
        return value > 5;
      });
      print(newList2.toList());
      print("----------------");
    
      //any: 判断List中是否有元素满足某个条件
      var f1 = myList2.any((value) {
        
        //只要集合里面有满足条件的就返回true
        return value > 5;
      });
      print(f1);
      print("----------------");
    
      //every: 判断List中每个元素是否满足某个条件
      var f2 = myList2.every((value) {
        
        //每一个都满足条件返回true  否则返回false
        return value > 5;
      });
      print(f2);
      print("----------------");
    
      // set
      var s = new Set();
      s.addAll([1, 222, 333]);
      s.forEach((value) => print(value));
      print("----------------");
    
      //map
      Map person = {
        "name": "张三", "age": 20};
      person.forEach((key, value) {
        
        print("$key---$value");
      });
    }

![在这里插入图片描述][469b9caf0dd647adb18eb267b70f168e.png]

## 方法详解 ##

*  内置方法/函数：`print();`
 *  自定义方法的基本格式：
    
        返回类型  方法名称（参数1，参数2,...）{
              
        	方法体
        	return 返回值;
        }

### 方法传参 ###

main() {
        
      //定义一个方法, 打印传入的用户信息
      String printUserInfo(String username, int age) {
        
        //行参
        return "姓名:$username---年龄:$age";
      }
    
      print(printUserInfo('张三', 20)); //实参
    }

![在这里插入图片描述][c75636e3a974478e86fec7f9210a0bdb.png]

### 可选参数 ###

包含在 `[]` 中的形参为可选参数，在调用方法时可以不传入

main() {
        
      //定义一个带可选参数的方法, 最新的dart定义可选参数需要指定类型默认值
      String printUserInfo(String username, [int age = 0]) {
        
        //行参
        if (age != 0) {
        
          return "姓名:$username---年龄:$age";
        }
        return "姓名:$username---年龄保密";
      }
    
      print(printUserInfo('张三'));
      print(printUserInfo('张三', 21)); //实参
    }

![在这里插入图片描述][20fe2eb7197a4963b1313c947f053258.png]

### 默认参数 ###

可选参数必须指定默认值，这个可选参数也是默认参数，如果在调用时没传入默认参数，就会为默认值

main() {
        
      //定义一个带默认参数的方法
      String printUserInfo(String username, [String sex = '男', int age = 0]) {
        
        //行参
        if (age != 0) {
        
          return "姓名:$username---性别:$sex--年龄:$age";
        }
        return "姓名:$username---性别:$sex--年龄保密";
      }
    
      print(printUserInfo('张三'));
      print(printUserInfo('小李', '女'));
      print(printUserInfo('小李', '女', 30));
    }

![在这里插入图片描述][d7a4e8ad17f84bd1824bd46734fbc81f.png]

### 命名参数 ###

包含在 `{}` 中的形参为命名参数，在调用时需要指定其名称

main() {
        
      //定义一个带命名参数的方法，最新的dart定义命名参数需要指定类型默认值
      String printUserInfo(String username, {
        int age = 0, String sex = '男'}) {
        
        //行参
        if (age != 0) {
        
          return "姓名:$username---性别:$sex--年龄:$age";
        }
        return "姓名:$username---性别:$sex--年龄保密";
      }
    
      print(printUserInfo('张三', age: 20, sex: '未知'));
    }

![在这里插入图片描述][0fdbe65071154b71b9f4d9c1d7824896.png]

### 方法作为参数 ###

main() {
        
      //实现一个把方法当做参数的方法
    
      //方法1
      fn1() {
        
        print('我是fn1');
      }
    
      //方法2
      fn2(fn) {
        
        fn();
      }
    
      //调用fn2这个方法, 把fn1这个方法当做参数传入
      fn2(fn1);
    }

![在这里插入图片描述][b729f3f16ba3450abc9516394f32c93b.png]

### 箭头函数 ###

void main() {
        
      /*需求：使用forEach打印下面List里面的数据*/
      List list = ['苹果', '香蕉', '西瓜'];
    
      //普通写法
      list.forEach((value) {
        
        print(value);
      });
      print("-------------");
    
      //箭头函数
      list.forEach((value) => print(value));
      print("-------------");
    
      // 注意和方法的区别: 箭头函数内只能写一条语句，并且语句后面没有分号(;)
      list.forEach((value) => {
        print(value)}); //可以加{}, 但没必要
    }

![在这里插入图片描述][fba811c2a1f140c79ba48118848d0442.png]

### 函数的相互调用 ###

void main() {
        
      /*
      需求：    1、定义一个方法isEvenNumber来判断一个数是否是偶数  
              2、定义一个方法打印1-n以内的所有偶数
      */
      // 1、定义一个方法isEvenNumber来判断一个数是否是偶数
      bool isEvenNumber(int n) {
        
        if (n % 2 == 0) {
        
          return true;
        }
        return false;
      }
    
      //  2、定义一个方法打印1-n以内的所有偶数
      printNum(int n) {
        
        for (var i = 1; i <= n; i++) {
        
          if (isEvenNumber(i)) {
        
            print(i);
          }
        }
      }
    
      printNum(10);
    }

![在这里插入图片描述][428a82581f91457098ddba4161f1d9f8.png]

### 匿名方法 ###

void main() {
        
      //匿名方法, 将里面的方法体赋值给printNum这个方法
      var printNum = () {
        
        print(123);
      };
      printNum();
    
      //可以有参数
      var printNum1 = (int n) {
        
        print(n + 2);
      };
      printNum1(12);
    }

![在这里插入图片描述][cf1ec3b4631e484cb419035c2d7010ec.png]

### 自执行方法 ###

void main() {
        
      //自执行方法, 不用调用自己会执行的方法
      //两个括号, 前面的括号可以定义形参, 后面的括号传参
      ((int n) {
        
        print(n);
        print('我是自执行方法');
      })(12);
    }

![在这里插入图片描述][988e7a81810b4a249e9a00a67970c528.png]

### 方法的递归 ###

void main() {
        
      //方法的递归, 求n的阶乘
      var sum = 1;
      fn(int n) {
        
        sum *= n;
        if (n == 1) {
        
          return;
        }
        fn(n - 1);
      }
    
      fn(5);
      print(sum);
    }

![在这里插入图片描述][8b0964b423f84ef6ae04a6ad51216942.png]

### 闭包 ###

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

我们想实现的功能：

1.  常驻内存
2.  不污染全局

产生了闭包，闭包可以解决这个问题…

闭包：函数嵌套函数, 内部函数会调用外部函数的变量或参数，变量或参数不会被系统回收（不会释放内存）

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

void main() {
        
      //闭包
      fn() {
        
        var a = 123; /*不会污染全局 , 常驻内存*/
        //返回一个方法
        return () {
        
          a++;
          print(a);
        };
      }
    
      var b = fn();
      b();
      b();
      b();
    }

![在这里插入图片描述][7e16c74dfe4e4b72a436aac848407060.png]

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Flutter]: https://blog.csdn.net/weixin_62511863/category_12649403.html?spm=1001.2014.3001.5482
[0bf27677eb754807a35583d5ba90023a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/29e56dd696b343529e7eeada9e290cb1.png
[a6beb142922547dabc89a046cb9373d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/83ebc133abe4493c9310a788b46a47bb.png
[26375e2468c34ce09c22f3d41c5fcfc9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d3beac4916794936b5830cd5285080f9.png
[f66d44501d2d4fae89246d9232c665f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e26f2f2eaa204e10b54e69a564fabe15.png
[122732fbded74f87a5be1fe9106725c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1d10b37a5f7a4769acc7d674358c599e.png
[48a1a22f084c4981b2c75072d2a564ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/093b0ef46a184d9da048bf3785506af3.png
[469b9caf0dd647adb18eb267b70f168e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/516b78ff2e1e4208b98c739c2a30b9bc.png
[c75636e3a974478e86fec7f9210a0bdb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/79ba1683620249358d494eb951f546b4.png
[20fe2eb7197a4963b1313c947f053258.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3972a3a8dd6049a6958c025eb5283883.png
[d7a4e8ad17f84bd1824bd46734fbc81f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/239d22ce69434860b918e5a820cf5248.png
[0fdbe65071154b71b9f4d9c1d7824896.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2b841830febc42a29945221da1e41914.png
[b729f3f16ba3450abc9516394f32c93b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/bef2c1a303b345b78fa6df9a70582315.png
[fba811c2a1f140c79ba48118848d0442.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0ea366bb2796495db51ac16d48aaebf4.png
[428a82581f91457098ddba4161f1d9f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/43535aeab236467fabbd6ff59f4025eb.png
[cf1ec3b4631e484cb419035c2d7010ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c5b017b4f8b74f1985b8f8da770ac91a.png
[988e7a81810b4a249e9a00a67970c528.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1ce5b8a908f64a9d8524e0ae9373f35c.png
[8b0964b423f84ef6ae04a6ad51216942.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5f553229f938439c8f89160ea148c849.png
[7e16c74dfe4e4b72a436aac848407060.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7e91a084124848d6bd354211d1df8c51.png