🔥 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Flutter学习
🌠 首发时间：2024年4月22日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾

目录

条件表达式

  • 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('-------------');
  }
}

在这里插入图片描述

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);
}

在这里插入图片描述

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++;
  }
}

在这里插入图片描述

集合类型详解

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);
}

在这里插入图片描述

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());
}

在这里插入图片描述

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('张三'));
}

在这里插入图片描述

集合类型常用的循环语句

  • 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");
  });
}

在这里插入图片描述

方法详解

  • 内置方法/函数：print();

  • 自定义方法的基本格式：

    返回类型  方法名称（参数1，参数2,...）{
	方法体
	return 返回值;
}

方法传参

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

  print(printUserInfo('张三', 20)); //实参
}

在这里插入图片描述

可选参数

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

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

  print(printUserInfo('张三'));
  print(printUserInfo('张三', 21)); //实参
}

在这里插入图片描述

默认参数

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

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));
}

在这里插入图片描述

命名参数

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

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: '未知'));
}

在这里插入图片描述

方法作为参数

main() {
  //实现一个把方法当做参数的方法

  //方法1
  fn1() {
    print('我是fn1');
  }

  //方法2
  fn2(fn) {
    fn();
  }

  //调用fn2这个方法, 把fn1这个方法当做参数传入
  fn2(fn1);
}

在这里插入图片描述

箭头函数

void main() {
  /*需求：使用forEach打印下面List里面的数据*/
  List list = ['苹果', '香蕉', '西瓜'];

  //普通写法
  list.forEach((value) {
    print(value);
  });
  print("-------------");

  //箭头函数
  list.forEach((value) => print(value));
  print("-------------");

  // 注意和方法的区别: 箭头函数内只能写一条语句，并且语句后面没有分号(;)
  list.forEach((value) => {print(value)}); //可以加{}, 但没必要
}

在这里插入图片描述

函数的相互调用

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);
}

在这里插入图片描述

匿名方法

void main() {
  //匿名方法, 将里面的方法体赋值给printNum这个方法
  var printNum = () {
    print(123);
  };
  printNum();

  //可以有参数
  var printNum1 = (int n) {
    print(n + 2);
  };
  printNum1(12);
}

在这里插入图片描述

自执行方法

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

在这里插入图片描述

方法的递归

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

  fn(5);
  print(sum);
}

在这里插入图片描述

闭包

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

我们想实现的功能：

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

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

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

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

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

  var b = fn();
  b();
  b();
  b();
}

在这里插入图片描述

# flutter
Logo
开源鸿蒙跨平台开发者社区

开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。

更多推荐

cover

Flutter&OpenHarmony商城App消息通知组件开发

avatar 开源鸿蒙跨平台开发者社区
cover

Flutter 实现一个容器内部元素可平移、缩放和旋转等功能（十）

avatar 开源鸿蒙跨平台开发者社区
cover

Flutter&OpenHarmony状态管理方案详解

avatar 开源鸿蒙跨平台开发者社区