Dart基础学习

Dart基础学习
概述
应用场景
版本
数据类型
变量
var
dynamic和Object
常量final和const
数值型
数值型num
字符串(String)
布尔型bool
列表List(数组)
Map
dynamic动态类型
运算符
算术运算符
关系运算符
逻辑运算符
赋值运算符
条件表达式
控制语句
if语句
for语句
while语句
break和continue
switch...case语句
函数/方法
main方法定义
方法定义Function
可选参数
默认参数
方法对象
匿名方法
闭包
面向对象编程
类与对象
计算属性
构造方法
命名构造方法
常量构造方法
工厂构造方法
初始化列表:
静态成员static
对象操作符
条件成员访问?.
类型转换as
是否指定类型is/is!
级联(链式)操作..
对象call方法
继承
继承中的构造方法
构造方法执行顺序
抽象类abstract
接口
Mixins
操作符覆写(重载运算符)
可覆写的操作符
枚举&类型
枚举
泛型<>
异步
Future
.then/.catchError
.whenComplete
.wait
Async/await
回调地狱(Callback Hell)
使用Future消除Callback Hell
使用async/await消除callback hell
Stream
Dart和Java及JavaScript对比
Dart vs Java
Dart vs JavaScript
TOC

Dart基础学习

参考:https://www.imooc.com/learn/1035

概述

  • Dart是Google发布的一门开源编程语言
  • Dart初期目标是成为下一代的web开发语言
  • Dart目前已可用于全平台开发
  • Dart是一门面向对象的编程语言

应用场景

  • Web开发
  • 跨平台移动应用开发( Fltter )
  • 脚本或服务端开发

版本

Dart1.x为稳定版本

Dart2.x目前为开发版本

案例:

hello_world.dart

  1. //Main程序入口
  2. void main(){
  3.   //控制台打印
  4.   print("Hello World!");
  5. }
  • main方法是固定写法,它是程序入口
  • print方法可以在控制台输出内容
  • 通过文件选择run ,可以运行文件中的main方法

数据类型

变量

  • 使用var声明变量,可赋予不同类型的值var a=12;
  • 未初始化时,默认值为null
  • 使用final声明一个只能赋值一次的变量 final c=30

var

类似于JavaScript中的var，它可以接收任何类型的变量，但最大的不同是Dart中var变量一旦赋值，类型便会确定，则不能再改变其类型

  1. var t;
  2. t = "hi world";
  3. // 下面代码在dart中会报错，因为变量t的类型已经确定为String，
  4. // 类型一旦确定后则不能再更改其类型。
  5. t = 1000;

dynamic和Object

  • Object 是Dart所有对象的根基类，也就是说所有类型都是Object的子类(包括Function和Null)，所以任何类型的数据都可以赋值给Object声明的对象.
  • dynamic与var一样都是关键词,声明的变量可以赋值任意对象。
  • dynamic与Object,声明的变量可以在后期改变赋值类型。
  • dynamic声明的对象编译器会提供所有可能的组合, 而Object声明的对象只能使用Object的属性与方法, 否则编译器会报错。
  1. dynamic t;
  2. Object x;
  3. t = "hi world";
  4. x = 'Hello Object';
  5. //下面代码没有问题
  6. t = 1000;
  7. x = 1000;
  1. dynamic a;
  2. Object b;
  3. main() {
  4.      a = "";
  5.      b = "";
  6.      printLengths();
  7.  }  
  9. printLengths() {
  10.      // no warning
  11.      print(a.length);
  12.      // warning:
  13.      // The getter 'length' is not defined for the class 'Object'
  14.      print(b.length);//只能使用Object类型默认的属性和方法,子类的不能使用了
  15. }
  16. //变量a不会报错, 变量b编译器会报错

常量final和const

  • 一个 final 变量只能被设置一次.
  • const 变量是一个编译时常量(编译的时候就初始化了--定义的时候就要初始化).
  • final变量在第一次使用时被初始化。
  • 被final或者const修饰的变量，变量类型可以省略
  1. //可以省略String这个类型声明
  2. final str = "hi world";
  3. //final String str = "hi world";
  4. const str1 = "hi world";//定义的时候就要初始化
  5. //const String str1 = "hi world";

数值型

  • 数值型-Number
  • 字符串-String
  • 布尔型-Boolean
  • 列表-List
  • 键值对-Map
  • Runes/Symbols(基本不用)

数值型num

类型:

  • 整形Int
  • 浮点型 double

数值型操作

  • 运算符:+、-、*、/、~/（取整）、%
  • 常用属性: isNaN（是否是非数字），isEven（是否是偶数），isOdd（是否是奇数）等
  • 常用方法:
    • abs(),取绝对值。
    • round(), 四舍五入。
    • floor()、向下取整。
    • ceil(),向上取整。
    • toInt()、
    • toDouble()
  1. void main(){
  2.   //num是数值类型，因此可以设置整数和浮点数。
  3.   num a = 10;
  4.   a = 12.5;
  5. //是整数，仅仅只能复制为整数，不能设置古典色。
  6.   int b = 20;
  7. //  b = 20.5;
  8. //浮点数不能设置整数。
  9.   double c = 10.5;
  10. //  c = 30;
  12.   print(b + c);//30.5
  13.   print(b - c);//9.5
  14.   print(b * c);//210.0
  15.   print(b / c);//1.9047619047619047
  16.   print(b ~/ c);//1
  17.   print(b % c);//9.5
  19.   print(0.0 / 0.0);//NaN 0.0/0.0非数字,其他都是数字
  21.   print(b.isEven);//true
  22.   print(b.isOdd);//false
  23.   int d = 11;
  24.   print(d.isEven);//false
  25.   print(d.isOdd);//true
  27.   int e = -100;
  28.   print(e.abs());//100
  30.   double f = 10.3;
  31.   print(f.round());//10
  32.   print(f.floor());//10
  33.   print(f.ceil());//11
  35.   print(f.toInt());//10,取整
  36.   print(d.toDouble());//11.0,向上取整,获取为小数
  38. }

字符串(String)

创建

  • 使用单引号,双引号创建字符串
  • 使用三个引号或双引号创建多行字符串
  • 使用r创建始raw字符串

操作:

  • 运算符:+、*、==、[]
  • 插值表达式: $(lexpression} (字符串中表达式)
  • 常用属性: length, isEmpty, isNotEmpty
  • 常用方法:
    • contains()
    • subString()
    • startsWith(),
    • endsWith()
    • indexOf(),
    • lastIndexOf()
    • toLowerCase(),
    • toUpperCase()
      trim(),
    • trimLeft(),
    • trimRight()
      split(),
    • replacexXX()
  1. void main(){
  2.   String str1 = 'Hello';//""
  3.   //```设置多行
  4.   String str2 = '''Hello
  5.                   Dart''';//"""
  6.   print(str2);
  7.   //Hello
  8.   //                  Dart
  10.   String stra = 'Hello 
 Dart';//单引号
会换行
  11.   print(stra);
  12.   //Hello
  13.   // Dart
  14.   String str3 = r'Hello 
 Dart';//r开头,
等会是字符创
  15.   print(str3);
  16.   //Hello 
 Dart
  19.   String str4 = "This is my favorite language";
  20.   print(str4 + "New");//This is my favorite languageNew
  21.   print(str4 * 2);//复制2遍  This is my favorite languageThis is my favorite language
  22.   print(str3 == str4);//false
  23.   print(str4[1]);//h
  25.   int a = 1;
  26.   int b = 2;
  27.   print("a + b = ${a + b}");//a + b = 3
  28.   print("a = $a");//只有一个字符,可以省略{} a = 1
  30.   print(str4.length);//28
  31.   print(str4.isEmpty);//false
  33.   print(str4.contains("This"));//true
  34.   print(str4.substring(0,3));//Thi
  35.   print(str4.startsWith("a"));//false
  36.   print(str4.endsWith("ge"));//true
  38.   var list = str4.split(" ");//[This, is, my, favorite, language]
  39.   print(list);
  41.   print(str4.replaceAll("This", "That"));//That is my favorite language
  42. }

布尔型bool

布尔值只有true和false

  1.   bool isTrue = true;
  2.   bool isFalse = false;
  4.   print("Hello".isEmpty);//false

列表List(数组)

创建

  • 创建List :var list = [1, 2, 3];
  • 创建不可变的List : var list = const [1, 2, 3];
  • 构造创建: var list = new List();也可以定义固定类型的var list = new List<String>();

常用操作:

  • [],length
  • indexOf(),lastIndexOf()
  • add(),insert()
  • sort()排序,sublist()
  • remove(),clear()
  • shuffle()打乱,asMap()转map,forEach()
  • 倒序
  • 修改值fillRange(s,e,value)
  • join("字符串"),以字符串分割,转为字符串
  • split("字符串")
  1. void main(){
  2.   var list1 = [1,2,3,"Dart",true];//[1, 2, 3, Dart, true]
  3.   print(list1);
  4.   print(list1[2]);//3
  5.   list1[1] = "Hello";//[1, Hello, 3, Dart, true]
  6.   print(list1);
  8.   var list2 = const [1,2,3];
  9. //  list2[0] = 5;
  11.   var list3 = new List();
  13.   var list = ["hello","dart"];
  14.   print(list.length);//2
  15.   list.add("New");//[hello, dart, New]
  16.   print(list);
  18.   list.insert(1, "Java");//[hello, Java, dart, New]
  19.   print(list);
  21.   list.remove("Java");//[hello, dart, New]
  22.   print(list);
  24. //  list.clear();  //[]
  25. //  print(list);
  27.   print(list.indexOf("dart1"));//-1
  28.   list.sort();
  29.   print(list);//[New, dart, hello],按照字母牌,大写字母比小写字母小
  31.   print(list.sublist(1));//[dart, hello]
  33.   list.forEach(print);
  34.   //New
  35.   //dart
  36.   //hello
  37.   list=list.reversed.toList();//只调用reversed方法会是(1,2,3),不是list
  38.     list.fillRange(1,3,"aa");
  39.     //将list的下表为[1,3)的值都改为"aa"
  40. }

Map

创建

  • var language = {first': 'Dart' 'second': Java' };
  • 创建不可变Map:var language = const { 'first': 'Dart','second":'Java'};
  • 构造创建:var language = new Map();
  2. void main(){
  3.   //创建法1
  4.   var map1 = {"first":"Dart",1:true,true:"2"};
  5.   print(map1);//{first: Dart, 1: true, true: 2}
  7.   print(map1["first"]);//Dart
  8.   print(map1[true]);//2
  9.   map1[1] = false;
  10.   print(map1);//{first: Dart, 1: false, true: 2}
  12.   var map2 = const {1:"Dart",2:"Java"};
  13. //  map2[1] = "Python";//不能改变值
  15.   var map3 = new Map();
  17.   var map = {"first":"Dart","second":"Java","third":"Python"};
  18.   print(map.length);//3
  19. //  map.isEmpty;
  21.   print(map.keys);//(first, second, third)(是list)
  22.   print(map.values);//(Dart, Java, Python)
  24.   print(map.containsKey("first"));//true
  25.   print(map.containsValue("C"));//false
  27.   map.remove("third");
  28.   print(map);//{first: Dart, second: Java}
  30.   map.forEach(f);//forEach遍历每一个字段,f调用f方法,传入key,value;
  31.   //key=first,value=Dart
  32.   //key=second,value=Java
  34.   var list = ["1","2","3"];
  35.   print(list.asMap());//{0: 1, 1: 2, 2: 3}   //转map是  下标:value
  36. }
  38. void f(key,value){
  39.   print("key=$key,value=$value");//${} 简写
  40. }

dynamic动态类型

使用var定义一个字段,字段类型可以随便变换,其实,var定义的就是一个dynamic类型

  1. void main(){
  2.   var a;
  3.   a = 10;
  4.   a = "Dart";
  6.   dynamic b = 20;//定义,动态类型
  7.   b = "JavaScript";
  9.   var list = new List<dynamic>();
  10.   list.add(1);
  11.   list.add("hello");
  12.   list.add(true);
  13.   print(list);
  14. }

运算符

算术运算符

  • 加减乘除,取整取余:+,-,*, /,~/,%
  • 递增递减:++var, var++,--var, var--
  1. void main(){
  2.   int a = 10;
  3.   int b = 2;
  5.   print(a + b);//12
  6.   print(a - b);//8
  7.   print(a * b);//20
  8.   print(a / b);//5.0
  9.   print(a ~/ b);//5
  10.   print(a % b);//0
  12.   print(a++);//10
  13.   print(++a);//12
  15.   print(a--);//12
  16.   print(--a);//10
  17. }

关系运算符

  • 运算符:==,!=, >, <,>=,<=
  • 判断内容是否相同使用==

    判断对象不适合

  1. void main(){
  2.   int a = 5;
  3.   int b = 3;
  5.   print(a == b);//false
  6.   print(a !=b );//true
  7.   print(a > b);//true
  8.   print(a < b);//false
  9.   print(a >= b);//true
  10.   print(a <= b);//false
  12.   String strA = "123";
  13.   String strB = "123";
  14.   print(strA == strB);//true
  15.   strB = "123 ";
  16.   print(strA == strB);//false
  17. }

逻辑运算符

  • 运算符:!取反,&&且,||或
  1. void main(){
  2.   bool isTrue = true;
  3.   print(!isTrue);//false
  5.   bool isFalse = false;
  6.   print(isTrue && isFalse);//false
  7.   print(isTrue || isFalse);//true
  9.   String str = "";
  10.   print(str.isEmpty);//true   isEmpty空字符串
  11.   str=null;
  12.   print(str.isEmpty);//会异常,null不能判断
  13. }

赋值运算符

  • 基础运算符: =, ??=左侧有值不变,左侧没值,赋值
  • 复合运算符:+=,-=,*=,/=,%=, ~/=
  1. void main(){
  2.   int a = 10;
  3.   int b = 5;
  5.   b ??= 10;//b有值,不设置,没有值,设置为右侧的值
  6.   print(b);//5
  8.   a += 2;
  9.   print(a);//12
  11.   a -= b;
  12.   print(a);//7
  14.   a *= b;
  15.   print(a);//35
  16. //  a /= b;(/需要double)
  17.   a ~/= b;
  18.   print(a);//7
  19.   a %= b;
  20.   print(a);//2
  21. }

条件表达式

  • 三目运算符: condition ? expr1 : expr2
  • ??运算符: expr1 ?? expr2 第一个表达式值不为空,使用第一个,为空使用第二个
  1.   int gender = 1;
  2.   String str = gender == 0 ? "Male=$gender" :"Female=$gender";
  3.   print(str);//Female=1
  5.   String a = "Dart";
  6.   String b = "Java";
  7.   String c = a ?? b;
  8.   print(c);//Dart

控制语句

if语句

  1. void main(){
  2.   int score = 100;
  4.   if(score >= 90){
  5.     if(score == 100){
  6.       print("完美");
  7.     }else {
  8.       print("优秀");
  9.     }
  10.   }else if(score > 60){
  11.     print("良好");
  12.   }else if(score == 60){
  13.     print("及格");
  14.   }else {
  15.     print("不及格");
  16.   }
  17.   //完美
  18. }

for语句

  • for
  • for..in
  1. void main(){
  2.   var list = [1,2,3,4,5];
  4.   for(var index = 0;index < list.length;index++){
  5.     print(list[index]);
  6.   }
  8.   print("---------");
  9.   for(var item in list){
  10.     print(item);
  11.   }
  13. }
  14. 1
  15. 2
  16. 3
  17. 4
  18. 5
  19. ---------
  20. 1
  21. 2
  22. 3
  23. 4
  24. 5

while语句

  • while
  • do...while
  1.   int count = 0;
  3.   while(count < 3){
  4.     print(count++);
  5.   }
  7.   print("---$count----");
  9.   do{
  10.     print(count--);
  11.   }while(count > 0 && count < 3);
  12. 0
  13. 1
  14. 2
  15. ---3----
  16. 3
  17. 2
  18. 1

break和continue

  • 终止循环:break
  • 跳出当前循环:continue
  1.   var list = [1,2,3];
  2.   for(var item in list){
  3.     if(item == 2) {
  4. //      break;
  5.       continue;
  6.     }
  7.     print(item);  //1 3 输出
  8.   }
  10.   print("-----");
  11.   var list2 = [4,5,6];
  12.   for(var item1 in list){
  13.     if(item1 == 2){
  14.       break;
  15.     }
  17.     for(var item2 in list2){
  18.       if(item2 == 5){//第二个到5,跳出
  19.         break;
  20.       }
  21.       print(item2);
  22.     }
  23.   }
  24. 1
  25. 3
  26. -----
  27. 4

switch...case语句

  • 比较类型: num , String,编译期常量,对象,枚举
  • 非空case必须有一个break
  • default处理默认情况
  • continue跳转标签
  1. void main(){
  2.   String language = "Java";
  4.   switch(language){
  5.     case "Dart":
  6.       print("Dart is my favorite");
  7.       break;
  8.     case "Java":
  9.       print("Java is my favorite");
  10.       break;
  11.     case "Python":
  12.       print("Python is my favorite");
  13.       break;
  14.     default:
  15.       print("None");
  16.   }
  17.   //Java is my favorite
  18.   switch(language){
  19.     Test:
  20.     case "Dart":
  21.       print("Dart is my favorite");
  22.       break;
  23.     case "Java":
  24.       print("Java is my favorite");
  25.       continue Test;
  26. //      break;
  27.     case "Python":
  28.       print("Python is my favorite");
  29.       break;
  30.     default:
  31.       print("None");
  32.   }
  33.   //Java is my favorite   第一步从switch跳转到java的case输出,然后跳转到Test,输出dart的内容,break
  34.   //Dart is my favorite
  35. }

函数/方法

Dart是一种真正的面向对象的语言，所以即使是函数也是对象，并且有一个类型Function。这意味着函数可以赋值给变量或作为参数传递给其他函数，这是函数式编程的典型特征。

main方法定义

  • main方法可以设置参数
  1. void main(){}
  2. void main(...){}

案例

  1. void main(){print(123);}
  2. void main(List args){print(args);}

运行main方法

  • 使用工具直接右键运行
  • 命令行运行
  1. 进入dart文件目录
  2. dart 文件 参数
  3. 例如 上面第二个main:   dart test2.dart 1 2 3   //1 2 3会作为list的3个字段传入
  4. 输出为 [1, 2, 3]

方法定义Function

  1. 返回类型方法名(参数1,参数2.,.){
  2. 方法体..
  3. return返回值
  4. }
  • 方法也是对象,并且有具体类型Function
  • 返回值类型、参数类型都可省略
    • 返回值类型没有定义,默认当做dynamic类型
    1. typedef bool CALLBACK();//校验类型
    3. //不指定返回类型，此时默认为dynamic，不是bool
    4. isNoble(int atomicNumber) {
    5.   return _nobleGases[atomicNumber] != null;
    6. }
    8. void test(CALLBACK cb){
    9.    print(cb());
    10. }
    11. //报错，isNoble不是bool类型,是dynamic
    12. test(isNoble);
  • 箭头语法:=> expr是{ return expr;}缩写。只适用于一个表达式
  • 方法都有返回值。如果没有指定,默认return null
  1. void main(List args){
  2.   print(args);
  4.   print(getPerson("张三", 18));
  5.   //getPerson:name=张三,age=18
  6.   print(getPerson2("张三", 18));
  7.   //getPerson2:name=张三,age=18
  8.   print(printPerson("李四", 20));
  9.   //name=李四,age=20
  10.   //null
  11. }
  13. int gender = 1;
  15. String getPerson(String name,int age){
  16.   return gender == 1 ? "getPerson:name=$name,age=$age":"Test";
  17. }
  18. //返回类型可以省略,参数类型可以省略
  19. //只有一句return,可以使用=>表达式
  20. getPerson2(name,age) => gender == 1 ? "getPerson2:name=$name,age=$age":"Test";
  21. printPerson(name,age){
  22.   //没有设置返回值,默认返回了null
  23.   print("name=$name,age=$age");
  24. }
  • 对于只包含一个表达式的函数，可以使用简写语法
  1. bool isNoble(int atomicNumber) {
  2.   return _nobleGases[atomicNumber] != null;
  3. }
  4. -----------
  5. bool isNoble (int atomicNumber)=> _nobleGases [ atomicNumber ] ！= null ;
  • 函数作为变量
  1. var say = (str){
  2.   print(str);
  3. };
  4. say("hi world");
  • 函数作为参数传递
  1. void execute(var callback) {
  2.     callback();
  3. }
  4. execute(() => print("xxx"))

可选参数

  • 可选命名参数: ( param1,param2,...}:需要设置key
  • 可选位置参数: [ paraml,param2....]:包装一组函数参数，用[]标记为可选的位置参数，并放在参数列表的最后面：

注意，不能同时使用可选的位置参数和可选的命名参数

  1. void main(){
  2.   //没有传的值是null
  3.   printPerson("李四");//name=李四,age=null,gender=null
  4.   //可选参数传入的时候需要标明key
  5.   printPerson("李四",age: 20);//name=李四,age=20,gender=null
  6.   printPerson("李四",age: 20,gender: "Male");//name=李四,age=20,gender=Male
  7.   printPerson("李四",gender: "Male");//name=李四,age=null,gender=Male
  9.   //没有传的值是null
  10.   printPerson2("张三");//name=张三,age=null,gender=null
  11.   //传入参数需要顺序传入,不能乱序
  12.   printPerson2("张三",18);//name=张三,age=18,gender=null
  13.   printPerson2("张三",18,"Female");//name=张三,age=18,gender=Female
  14. }
  15. //{}中是可选参数
  16. printPerson(String name,{int age,String gender}){
  17.   print("name=$name,age=$age,gender=$gender");
  18. }
  19. //[]中是可选参数
  20. printPerson2(String name,[int age,String gender]){
  21.   print("name=$name,age=$age,gender=$gender");
  22. }

默认参数

  • 使用=在可选参数指定默认值
  • 默认值只能是编译时常量
  1. void main(){
  2.   printPerson("李四");//name=李四,age=30,gender=Female
  3.   printPerson("李四",age: 20);//name=李四,age=20,gender=Female
  4.   printPerson("李四",age: null);//name=李四,age=null,gender=Female
  5.   printPerson("李四",gender: "Male");//name=李四,age=30,gender=Male
  6. }
  7. //设置默认值
  8. printPerson(String name,{int age = 30,String gender = "Female"}){
  9.   print("name=$name,age=$age,gender=$gender");
  10. }

方法对象

  • 方法可作为对象赋值给其它变量
  • 方法可作为参数传递给其它方法
  1. void main(){
  2.   //定义方法变量
  3.   Function func = printHello;
  4.   //运行方法
  5.   func();//Hello
  7.   var list = [1,2,3,4];
  8.   list.forEach(print);
  9.   //1
  10.   //2
  11.   //3
  12.   //4
  14.   var list2 = ["h","e","l","l","o"];
  15.   //listTimes方法传入两个字段
  16.   print(listTimes(list2, times));
  17.   //[hhh, eee, lll, lll, ooo]
  18.   print(listTimes2(list2, times));
  19.   //[hhhhhhhhh, eeeeeeeee, lllllllll, lllllllll, ooooooooo]
  21. }
  23. void printHello(){
  24.   print("Hello");
  25. }
  26. //方法定义的参数可以随便定义,第二个参数只是字段的定义,不代表是下方的times方法,设置为f都行
  27. List listTimes(List list ,String times(str)){
  28.   for(var index = 0;index < list.length;index++){
  29.     list[index] = times(list[index]);
  30.   }
  32.   return list;
  33. }
  34. List listTimes2(List list ,String f(str)){
  35.   for(var index = 0;index < list.length;index++){
  36.     list[index] = f(list[index]);
  37.   }
  39.   return list;
  40. }
  43. String times(str){
  44.   //字符串的话,会复制三遍
  45.   return str*3;
  46. }

匿名方法

  1. (参数1,参数2. ..){
  2. 方法体….
  3. return返回值
  4. }
  • 可赋值给变量,通过变量进行调用
  • 可在其它方法中直接调用或传递给其它方法
  1. void main(){
  2.   //匿名方法在方法内定义
  3.   //定义并调用
  4.   var func = (str){
  5.     print("Hello---$str");
  6.   };
  7.   func(30);//Hello---30
  9.   //定义,并直接调用()--不建议
  10. //  ((){
  11. //    print("Test");
  12. //  })();
  13.   var list2 = ["h","e","l","l","o"];
  15.   var result = listTimes(list2, (str){ return str * 3;});
  16.   print(result);//[hhh, eee, lll, lll, ooo]
  18.   print(listTimes2(list2));//[hhhhhhhhh, eeeeeeeee, lllllllll, lllllllll, ooooooooo]
  20. }
  22. List listTimes(List list ,String times(str)){
  23.   for(var index = 0;index < list.length;index++){
  24.     list[index] = times(list[index]);
  25.   }
  26.   return list;
  27. }
  29. List listTimes2(List list ){
  30.   var func = (str){ return str * 3;};
  31.   for(var index = 0;index < list.length;index++){
  32.     list[index] = func(list[index]);
  33.   }
  34.   return list;
  35. }

闭包

  • 闭包是一个方法(对象)
  • 闭包定义在其它方法内部
  • 闭包能够访问外部方法内的局部变量,并持有其状态

1、全局变量特点: 全局变量常驻内存、全局变量污染全局

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

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

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

  1. void main(){
  2.   //相当于初始化了一个对象
  3.   var func = a();
  4.   //调用方法调用的是里面的return部分
  5.   func();//0
  6.   func();//1
  7.   func();//2
  8.   func();//3
  9.   //重新初始化一个方法/对象,新的对象与上一个数据不会共通
  10.   var func2 = a();
  11.   func2();//0
  13. }
  14. //定义方法
  15. a(){
  16.   int count = 0;
  18. //  printCount(){
  19. //    print(count++);
  20. //  }
  21.   return (){
  22.     print(count++);
  23.   };
  24. }

面向对象编程

类与对象

  • 使用关键字class声明一个类
  • 使用关键字new创建一个对象, new可省略
  • 所有对象都继承于Object类

属性与方法

  • 属性默认会生成getter和setter方法
  • 使用final声明的属性只有getter方法
  • 属性和方法通过.访问
  • 方法不能被重载(同一个名字的只能有一个)

类及成员可见性

  • Dart中的可见性以library(库)为单位
  • 默认情况下,每一个Dart文件就是一个库
  • 使用_表示库的私有性(只能在本文件中使用)
  • 使用import导入库
  1. class Person {
  2.   String name;
  3.   int age;
  4.   final String address = "";
  6.   void work(){
  7.     print("Name is $name,Age is $age,He is working...");
  8.   }
  9. }
  1. import 'person.dart';//不在同一个文件中,需要引入
  2. void main() {
  3.     var person = new Person();
  4.     person.name = "Tom";
  5.     person.age = 20;
  7.     print(person.name);//Tom
  8.     print(person.address);//
  9.     person.work();//Name is Tom,Age is 20,He is working...
  10. }

计算属性

属性默认会生成getter和setter方法,这里自定义get/set方法

  • 顾名思义,计算属性的值是通过计算而来,本身不存储值
  • 计算属性赋值,其实是通过计算转换到其它实例变量
  1. get/set 字段 =>定义
  2. set(参数){}
  1. void main() {
  2.   var rect = new Rectangle();
  3.   rect.height = 20;
  4.   rect.width = 10;
  6.   print(rect.area);//200
  7.   print(rect.aa);//60
  8.   rect.area = 200;
  9.   print(rect.width);//10.0
  10.   rect.aa = 40;
  11.   print(rect.width);//20.0
  12.   print(rect.height);//20.0
  13. }
  15. class Rectangle {
  16.   num width, height;
  17.   //计算属性 area
  18.   // get xx
  19.   num get area => width * height;
  20.   set area(value) {
  21.     width = value / 20;
  22.   }
  24.   num get aa => aaval();
  25.   set aa(value) {
  26.     width = value / 2;
  27.     height = value / 2;
  28.   }
  29.   num aaval() {
  30.     return (width + height) * 2;
  31.   }
  32. }

构造方法

  • 如果没有自定义构造方法,则会有个默认构造方法名(){}
  • 如果存在自定义构造方法,则默认构造方法无效(不能重载,所以同名方法只有一个)
  • 构造方法不能重载
  1. class Person{
  2.   String name;
  3.   int age;
  5.   final String gender;
  6. //  final字段没有set方法,构造方法不能使用普通方法,只能this.
  7. //  Person(String name,int age, this.gender){
  8. //    this.name=name;
  9. //    this.age=age;
  10. //
  11. //  }
  12.   Person(this.name,this.age,this.gender);
  13. }

命名构造方法

  • 使用命名构造方法,可以实现多个构造方法
  • 使用类名.方法的形式实现

命名构造方法必须设置上final字段的值

  1. void main() {
  2.     new Person.withName("John","12").work();
  3.     new Person.withAge(20,"35").work();
  4. }
  6. class Person{
  7.   String name;
  8.   int age;
  10.   final String gender;
  11.   Person.withName(String name, this.gender){
  12.     this.name = name;
  13.   }
  15.   Person.withAge(this.age, this.gender);
  17.   void work(){
  18.     print("Work...");
  19.   }
  20. }
  21. //Work...
  22. //Work...

常量构造方法

  • 如果类是不可变状态,可以把对象定义为编译时常量
  • 使用const声明构造方法,并且所有变量都为final
  • 使用const声明对象,可以省略
  1. void main() {
  2.   //常量对应的构造方法也是常量,定义的const可以省略
  3. //  const person = Person("Tom", 20, "Male");
  4.   const person = const Person("Tom", 20, "Male");
  5.   person.work();
  6. }
  8. class Person {
  9.   //所有字段必须是final
  10.   final String name;
  11.   final int age;
  13.   final String gender;
  15.   //构造必须是常量
  16.   const Person(this.name, this.age, this.gender);
  18.   void work() {
  19.     print("Work...");
  20.   }
  21. }

工厂构造方法

  • 工厂构造方法类似于设计模式中的工厂模式
  • 在构造方法前添加关键字factory实现一个工厂构造方法
  • 在工厂构造方法中可返回对象(之前的构造方法没有返回值,都是void的)
  1. class Logger {
  2.   final String name;
  3.   //new 省略了,里面的值是final的
  4.   static final Map<String, Logger> _cache = <String, Logger>{};
  6.   //工厂构造方法,可以设置返回值
  7.   factory Logger(String name) {
  8.     if (_cache.containsKey(name)) {
  9.       return _cache[name];
  10.     } else {
  11.       final logger = Logger._internal(name);
  12.       _cache[name] = logger;
  13.       return logger;
  14.     }
  15.   }
  16.   //私有的命名构造方法
  17.   Logger._internal(this.name);
  19.   void log(String msg) {
  20.     print(msg);
  21.   }
  22. }

初始化列表:

final的赋值需要在构造方法之前执行,或者使用语法糖

  • 初始化列表会在构造方法体执行之前执行
  • 使用逗号分隔初始化表达式
  • 初始化列表常用于设置final变量的值
  1. void main() {
  2.   new Person.withMap({"name": "aaa", "age": 12, "gender": "123"}).work();
  3.   //aaa null
  4.   //newName  null  123
  5.   //1.参数构造方法调用的时候,先给name和gender赋值
  6.   //2.运行构造方法的时候,先输出了 name 和age
  7.   //3.name赋值
  8.   //4.调用work方法
  9. }
  11. class Person {
  12.   String name;
  13.   int age;
  14.   final String gender;
  16.   Person(this.name, this.age, this.gender);
  18.   //final可以直接在参数后面 :之后初始化
  19.   //构造方法之后使用 :可以给字段初始化,在构造方法运行之前
  20.   Person.withMap(Map map) : name = map["name"], gender = map["gender"] {
  21.     print("$name $age");
  22.     name = "newName";
  23.   }
  25.   void work() {
  26.     print("$name  $age  $gender");
  27.   }
  28. }

静态成员static

  • 使用static关键字来实现类级别的变量和函数
  • 静态成员不能访问非静态成员,非静态成员可以访问静态成员
  • 类中的常量需要使用static const声明
  1. void main() {
  2.   var page = new Page();
  3.   page.scrollUp();
  4.   Page.scrollDown();
  5. }
  7. class Page {
  8.   //静态常量
  9.   static const int maxPage = 10;
  10.   //静态变量
  11.   static int currentPage = 1;
  12.   //静态方法
  13.   //下滑
  14.   static void scrollDown() {
  15.     currentPage = 1;
  16.     print("ScrollDown...$currentPage");
  17.   }
  18.   //普通方法
  19.   //上滑
  20.   void scrollUp() {
  21.     currentPage++;
  22.     print("scrollUp...$currentPage");
  23.   }
  24. }

对象操作符

  • 条件成员访问(左侧为空就不执行了): ?.
  • 类型转换: as
  • 是否指定类型: is, is!
  • 级联(链式)操作:..
  1. class Person{
  2.   String name;
  3.   int age;
  5.   void work(){
  6.     print("Work...$name,$age");
  7.   }
  8. }

条件成员访问?.

  1.   Person person1;
  2. //  person1.work();//person1没有实例化,会异常
  3.   person1?.work();//person1没有实例化,不会继续执行
  4.   person1?.name="123";//person1没有实例化,不会继续执行
  5.   person1?.work();//person1没有实例化,不会继续执行
  6.   person1=new Person();
  7.   person1?.work();//Work...null,null

类型转换as

  1.   var person2;
  2.   person2="";
  3.   person2=new Person();
  4.   person2.name="12";
  5.   person2.work();//Work...12,null 调用work()没有代码提示,但是运行不会异常
  6.   (person2 as Person).work();//Work...12,null 类型转换,有代码提示
  7. //若是没有 person2=new Person(); 在调用方法的时候会异常

是否指定类型is/is!

  1.   var person2;
  2.   person2="";
  3.   if(person2 is Person){
  4.   person2.work();
  5.   }else{
  6.     print(person2 is! Person);//true
  7.   }

级联(链式)操作..

  1.   var person=new Person();
  2.   //级联操作,链式操作
  3.   person..name="Tom"..age=12..work()
  4.     ..age=20..work();
  5. 或者 new Person()..name="Tom"..age=12..work()..age=20..work()
  6. Work...Tom,12
  7. Work...Tom,20

对象call方法

  • 如果类实现了call()方法,则该类的对象可以作为方法使用
  1. void main() {
  2.     var person = new Person();
  3.     print(person("Test",30));
  4. }
  5. class Person{
  6.   String name;
  7.   int age;
  8.   String call(String name,int age){
  9.     return "Name is $name,Age is $age";
  10.   }
  11. }

继承

  • 使用关键字extends继承一个类
  • 子类会继承父类可见的属性和方法,不会继承构造方法
  • 子类能够复写父类的方法、getter和setter
  • 单继承,多态性

父类

  1. class Person {
  2.   String name;
  3.   int age;
  4.   String _birthday;
  6.   bool get isAdult => age > 18;
  8.   void run(){
  9.     print("Person run...");
  10.   }
  12.   @override
  13.   String toString() {
  14.     return "Name is $name,Age is $age";
  15.   }
  16. }

测试

  1. void main() {
  2.   var student = new Student();
  3.   student.study();//Student study...
  4.   student.name = "Tom";
  5.   student.age = 16;
  6.   print(student.isAdult);//true
  7.   //_birthday是父类隐藏的,不能调用
  8.   student.run();//Student run...
  10.   Person person = new Student();
  11.   person.name = "Tom";
  12.   person.age = 18;
  14.   if(person is Student){
  15.     person.study();//Student study...  (实例化的是Student)
  16.   }
  18.   print(person);//Name is Tom,Age is 18
  19. }
  21. class Student extends Person{//继承
  23.   void study(){
  24.     print("Student study...");
  25.   }
  26.   //重写方法
  27.   @override
  28.   bool get isAdult => age > 15;
  30.   @override
  31.   void run() {
  32.     print("Student run...");
  33.   }
  35. }

直接print对象的时候,对象实现了toString的话,调用toString方法,没有实现,输出默认的方法Instance of '类型'

print(对象)--toString()

print(对象(字段))--call(..字段)

继承中的构造方法

  • 子类的构造方法默认会调用父类的无名无参构造方法
  • 如果父类没有无名无参构造方法,则需要显示调用父类构造方法
  • 在构造方法参数后使用:显示调用父类构造方法

若父类的构造方法是无名无参的,会直接调用这个构造

  1. Person(){print(123);}
  2. ----------
  3. new Student();

若父类的构造是有参的,需专门调用(在初始化列表中)

  1.   Person(this.name);
  2.   Person.withName(this.name);
  3. ------
  4. //需要专门调用构造方法
  5. class Student extends Person{
  6.   int age;
  7.   final String gender;
  8.   Student(String name,String g) : gender = g, super.withName(name);
  9.     //父类的构造方法是必须调用的,上面的哪个都行
  10. }

构造方法执行顺序

  • 父类的构造方法在子类构造方法体开始执行的位置调用
  • 如果有初始化列表,初始化列表会在父类构造方法之前执行

子类初始化列表>父类初始化列表>父类构造方法>子类构造方法

  1. void main() {
  2.   var student = new Student("Tom","Male");
  3.   print(student.name);
  4. }
  6. class Person{
  7.   String name;
  8.   Person(this.name);
  9.   Person.withName(this.name);
  10. }
  11. class Student extends Person{
  12.   int age;
  13.   final String gender;
  14.   Student(String name,String g) : gender = g, super.withName(name);//父类构造在子类的最后一个初始化列表中
  15. }

抽象类abstract

  • 抽象类使用abstract表示,不能直接被实例化
  • 抽象方法不用abstract修饰,无实现
  • 抽象类可以没有抽象方法
  • 有抽象方法的类一定得声明为抽象类
  1. void main() {
  2. //  var person = new Person();//抽象类不能实例化,会异常
  3.   var person = new Student();
  4.   person.run();
  5. }
  6. abstract class Person{
  7.   void run();//抽象方法不用abstract修饰,无实现
  8. }
  9. class Student extends Person{ //实现抽象类
  10.   @override
  11.   void run() {
  12.     print("run...");
  13.   }
  14. }
  15. //run...

接口

  • 类和接口是统一的,类就是接口
  • 每个类都隐式的定义了一个包含所有实例成员的接口

使用继承 :复用已有类的实现,使用继承(extends)

使用接口:使用已有类的外在行为,使用接口(implements)(一般最好使用抽象类)

普通类作为接口

  1. void main() {
  2.   var student = new Student();
  3.   student.run();
  4. }
  6. class Person{
  7.   String name;
  9.   int get age => 18;
  11.   void run(){
  12.     print("Person run...");
  13.   }
  14. }
  16. class Student implements Person{
  17. //  实现接口的时候,接口层的所有内容都是接口,在实现的时候都要实现一遍
  19.   @override
  20.   String name;
  22.   @override
  23.   int get age => 1;
  24.   @override
  25.   void run() {
  26.     print("Student run...");
  27.   }
  29. }

抽象类作为接口(一样)

  1. abstract class Person{
  2.   String name;
  3.   int get age => 18;
  4.   void run(){
  5.     print("Person run...");
  6.   }
  7. }
  9. class Student implements Person{
  10.   @override
  11.   String name;
  12.   @override
  13.   int get age => throw UnimplementedError();
  14.   @override
  15.   void run() {
  16.   }
  17. //  实现接口的时候,接口层的所有内容都是接口,在实现的时候都要实现一遍
  18. }

Mixins

  • Mixins类似于多继承,是在多类继承中重用一个类代码的方式
  • 作为Mixin的类不能有显示声明构造方法(父类只能使用默认构造)
  • 作为Mixin的类只能继承自Object(父类不能定义上级父类)
  • 使用关键字with连接一个或多个mixin
  • 格式 :class A with b,c,...{}
  • 同名方法,使用最后的一个

若要继承

  • class A extend a with b,c,...{}
  • class A =a with b,c,...{}

A,a可以自定义构造

bc不可以自定义构造,不能定义继承;

  1. void main() {
  2.   var d = new D();
  3.   d.a();
  4. }
  6. class A {
  7.   void a() {
  8.     print("A.a()...");
  9.   }
  10. }
  12. class B {
  13.   void a() {
  14.     print("B.a()...");
  15.   }
  17.   void b() {
  18.     print("B.b()...");
  19.   }
  20. }
  22. class C {
  23.   void a() {
  24.     print("C.a()...");
  25.   }
  27.   void b() {
  28.     print("C.b()...");
  29.   }
  31.   void c() {
  32.     print("C.c()...");
  33.   }
  34. }
  36. //D同时继承 ABC
  37. class D extends A with C, B {}

测试

  1. abstract class Engine{
  2.   void work();
  3. }
  5. class OilEngine implements Engine{//实现接口,不是继承,可以作为Mixin的类
  6.   @override
  7.   void work() {
  8.     print("Work with oil...");
  9.   }
  11. }
  13. class ElectricEngine implements Engine{
  15.   @override
  16.   void work() {
  17.     print("Work with Electric...");
  18.   }
  20. }
  22. class Tyre{
  23.   String name;
  24.   void run(){}
  25. }
  27. //class Car extends Tyre with ElectricEngine{};
  28. //没有其他操作的话--简写
  29. class Car = Tyre with ElectricEngine;
  31. class Bus = Tyre with OilEngine;

操作符覆写(重载运算符)

  • 覆写操作符需要在类中定义
  • 如果覆写==，还需要覆写对象的hashCode getter方法
  • operator
  1. 返回类型 operator 操作符(参数1,参数2, ...) {
  2.     实现体...
  3.     return 返回值
  4. }

可覆写的操作符

< * ` ` []
> / ^ []=
<= ~/ & ~
>= * << ==
- % >> 
  1. void main() {
  3.   var person1 = new Person(20);
  4.   var person2 = new Person(20);
  6.   print(person1 > person2);
  8.   person1.age;
  9.   print(person1['age']);//20
  11.   print(person1 == person2);//false
  12. }
  14. class Person{
  15.   int age;
  17.   Person(this.age);
  18.   //重定义  > 操作符,返回 bool格式
  19.   bool operator >(Person person){
  20.     return this.age > person.age;
  21.   }
  23.   int operator [](String str){
  24.     if("age" == str){//查的是age,返回age的值,否则返回0
  25.       return age;
  26.     }
  28.     return 0;
  29.   }
  31.   //==的还要复写 hashCode的getter方法
  32.   @override
  33.   bool operator ==(Object other) =>
  34.       identical(this, other) ||
  35.           other is Person &&
  36.               runtimeType == other.runtimeType &&
  37.               age == other.age;
  39.   @override
  40.   int get hashCode => age.hashCode;
  42. }

枚举&类型

枚举

  • 枚举是一种有穷序列集的数据类型
  • 使用关键字enum定义一个枚举
  • 常用于代替常量,控制语句等

特性:

  • index从0开始,依次累加
  1. void main() {
  2.   var currentSeason  = Season.winter;
  4.   print(currentSeason.index);//3
  6.   switch(currentSeason){
  7.     case Season.spring:
  8.       print("1-3月");
  9.       break;
  10.     case Season.summer:
  11.       print("4-6月");
  12.       break;
  13.     case Season.autumn:
  14.       print("7-9月");
  15.       break;
  16.     case Season.winter:
  17.       print("10-12月");//10-12月
  18.       break;
  19.   }
  20. }
  22. enum Season{
  23.   spring,
  24.   summer,
  25.   autumn,
  26.   winter
  27. }

泛型<>

  • Dart中类型是可选的,可使用泛型限定类型

使用:

  • 类的泛型
  • 方法的泛型
  1. void main() {
  2.   //限制类型
  3.   var list = new List<int>();
  4.   list.add(1);
  6.   var util = new Util<int>();
  7.   util.put(1);//只能传入数字
  8.   var util2 = new Util();
  9.   util2.put(1);//1
  10.   util2.put("aaa");//aaa
  12.   var utils = new Utils();
  13.   utils.put<int>(1);//1
  14.   utils.put("aaa");//aaa
  15. }
  17. //类级别
  18. class Util<T> {
  19.   void put(T element) {
  20.     print(element);
  21.   }
  22. }
  24. class Utils {
  25.   //方法级别
  26.   void put<T>(T element) {
  27.     print(element);
  28.   }
  29. }

异步

Dart类库有非常多的返回Future或者Stream对象的函数。 这些函数被称为异步函数：它们只会在设置好一些耗时操作之后返回，比如像 IO操作。而不是等到这个操作完成。

Future

Future与JavaScript中的Promise非常相似，表示一个异步操作的最终完成（或失败）及其结果值的表示。简单来说，它就是用于处理异步操作的，异步处理成功了就执行成功的操作，异步处理失败了就捕获错误或者停止后续操作。一个Future只会对应一个结果，要么成功，要么失败。

由于本身功能较多，这里我们只介绍其常用的API及特性。还有，请记住，Future 的所有API的返回值仍然是一个Future对象，所以可以很方便的进行链式调用。

.then/.catchError

  1. Future.delayed(new Duration(seconds: 2),(){
  2.    //return "hi world!";
  3.    throw AssertionError("Error"); 
  4. }).then((data){
  5.    //执行成功会走到这里 
  6.    print("success");
  7. }).catchError((e){
  8.    //执行失败会走到这里 
  9.    print(e);
  10. });
  11. ///////或者使用then的可选参数处理异常
  12. Future.delayed(new Duration(seconds: 2), () {
  13.     //return "hi world!";
  14.     throw AssertionError("Error");
  15. }).then((data) {
  16.     print("success");
  17. }, onError: (e) {
  18.     print(e);
  19. });

.whenComplete

有些时候，我们会遇到无论异步任务执行成功或失败都需要做一些事的场景，比如在网络请求前弹出加载对话框，在请求结束后关闭对话框。这种场景，有两种方法，第一种是分别在then或catch中关闭一下对话框，第二种就是使用Future的whenComplete回调，我们将上面示例改一下：

  1. Future.delayed(new Duration(seconds: 2),(){
  2.    //return "hi world!";
  3.    throw AssertionError("Error");
  4. }).then((data){
  5.    //执行成功会走到这里
  6.    print(data);
  7. }).catchError((e){
  8.    //执行失败会走到这里  
  9.    print(e);
  10. }).whenComplete((){
  11.    //无论成功或失败都会走到这里
  12. });

.wait

有些时候，我们需要等待多个异步任务都执行结束后才进行一些操作，比如我们有一个界面，需要先分别从两个网络接口获取数据，获取成功后，我们需要将两个接口数据进行特定的处理后再显示到UI界面上，应该怎么做？答案是Future.wait，它接受一个Future数组参数，只有数组中所有Future都执行成功后，才会触发then的成功回调，只要有一个Future执行失败，就会触发错误回调。下面，我们通过模拟Future.delayed 来模拟两个数据获取的异步任务，等两个异步任务都执行成功时，将两个异步任务的结果拼接打印出来，代码如下：

  1. Future.wait([
  2.   // 2秒后返回结果 
  3.   Future.delayed(new Duration(seconds: 2), () {
  4.     return "hello";
  5.   }),
  6.   // 4秒后返回结果 
  7.   Future.delayed(new Duration(seconds: 4), () {
  8.     return " world";
  9.   })
  10. ]).then((results){
  11.   print(results[0]+results[1]);
  12. }).catchError((e){
  13.   print(e);
  14. });

Async/await

Dart中的async/await 和JavaScript中的async/await功能和用法是一模一样的，如果你已经了解JavaScript中的async/await的用法，可以直接跳过本节。

  • async用来表示函数是异步的，定义的函数会返回一个Future对象，可以使用then方法添加回调函数。
  • await 后面是一个Future，表示等待该异步任务完成，异步完成后才会往下走；await必须出现在 async函数内部。

回调地狱(Callback Hell)

如果代码中有大量异步逻辑，并且出现大量异步任务依赖其它异步任务的结果时，必然会出现Future.then回调中套回调情况。举个例子，比如现在有个需求场景是用户先登录，登录成功后会获得用户ID，然后通过用户ID，再去请求用户个人信息，获取到用户个人信息后，为了使用方便，我们需要将其缓存在本地文件系统，代码如下：

  1. //先分别定义各个异步任务
  2. Future<String> login(String userName, String pwd){
  3.     ...
  4.     //用户登录
  5. };
  6. Future<String> getUserInfo(String id){
  7.     ...
  8.     //获取用户信息
  9. };
  10. Future saveUserInfo(String userInfo){
  11.     ...
  12.     // 保存用户信息
  13. };

接下来，执行整个任务流：

  1. login("alice","******").then((id){
  2.  //登录成功后通过，id获取用户信息   
  3. getUserInfo(id).then((userInfo){
  4.     //获取用户信息后保存
  5.     saveUserInfo(userInfo).then((){
  6.        //保存用户信息，接下来执行其它操作
  7.         ...
  8.     });
  9.   });
  10. })

可以感受一下，如果业务逻辑中有大量异步依赖的情况，将会出现上面这种在回调里面套回调的情况，过多的嵌套会导致的代码可读性下降以及出错率提高，并且非常难维护，这个问题被形象的称为回调地狱（Callback Hell）。回调地狱问题在之前JavaScript中非常突出，也是JavaScript被吐槽最多的点，但随着ECMAScript6和ECMAScript7标准发布后，这个问题得到了非常好的解决，而解决回调地狱的两大神器正是ECMAScript6引入了Promise，以及ECMAScript7中引入的async/await。 而在Dart中几乎是完全平移了JavaScript中的这两者：Future相当于Promise，而async/await连名字都没改。接下来我们看看通过Future和async/await如何消除上面示例中的嵌套问题。

使用Future消除Callback Hell
  1. login("alice","******").then((id){
  2.       return getUserInfo(id);
  3. }).then((userInfo){
  4.     return saveUserInfo(userInfo);
  5. }).then((e){
  6.    //执行接下来的操作
  7. }).catchError((e){
  8.   //错误处理 
  9.   print(e);
  10. });

正如上文所述， Future 的所有API的返回值仍然是一个Future对象，所以可以很方便的进行链式调用” ，如果在then中返回的是一个Future的话，该future会执行，执行结束后会触发后面的then回调，这样依次向下，就避免了层层嵌套。

使用async/await消除callback hell

通过Future回调中再返回Future的方式虽然能避免层层嵌套，但是还是有一层回调，有没有一种方式能够让我们可以像写同步代码那样来执行异步任务而不使用回调的方式？答案是肯定的，这就要使用async/await了，下面我们先直接看代码，然后再解释，代码如下：

  1. task() async {
  2.    try{
  3.     String id = await login("alice","******");
  4.     String userInfo = await getUserInfo(id);
  5.     await saveUserInfo(userInfo);
  6.     //执行接下来的操作  
  7.    } catch(e){
  8.     //错误处理  
  9.     print(e);  
  10.    } 
  11. }

其实，无论是在JavaScript还是Dart中，async/await都只是一个语法糖，编译器或解释器最终都会将其转化为一个Promise（Future）的调用链。

Stream

Stream 也是用于接收异步事件数据，和Future 不同的是，它可以接收多个异步操作的结果（成功或失败）。 也就是说，在执行异步任务时，可以通过多次触发成功或失败事件来传递结果数据或错误异常。 Stream 常用于会多次读取数据的异步任务场景，如网络内容下载、文件读写等。举个例子：

  1. Stream.fromFutures([
  2.   // 1秒后返回结果
  3.   Future.delayed(new Duration(seconds: 1), () {
  4.     return "hello 1";
  5.   }),
  6.   // 抛出一个异常
  7.   Future.delayed(new Duration(seconds: 2),(){
  8.     throw AssertionError("Error");
  9.   }),
  10.   // 3秒后返回结果
  11.   Future.delayed(new Duration(seconds: 3), () {
  12.     return "hello 3";
  13.   })
  14. ]).listen((data){
  15.    print(data);
  16. }, onError: (e){
  17.    print(e.message);
  18. },onDone: (){
  20. });

上面的代码依次会输出：

  1. I/flutter (17666): hello 1
  2. I/flutter (17666): Error
  3. I/flutter (17666): hello 3

Dart和Java及JavaScript对比

Dart vs Java

客观的来讲，Dart在语法层面确实比Java更有表现力；在VM层面，Dart VM在内存回收和吞吐量都进行了反复的优化，但具体的性能对比，笔者没有找到相关测试数据，但在笔者看来，只要Dart语言能流行，VM的性能就不用担心，毕竟Google在Go（没用VM但有GC）、JavaScript（v8）、Dalvik（Android上的Java VM）上已经有了很多技术积淀。值得注意的是Dart在Flutter中已经可以将GC做到10ms以内，所以Dart和Java相比，决胜因素并不会是在性能方面。而在语法层面，Dart要比Java更有表现力，最重要的是Dart对函数式编程支持要远强于Java(目前只停留在Lambda表达式)，而Dart目前真正的不足是生态，但笔者相信，随着Flutter的逐渐火热，会回过头来反推Dart生态加速发展，对于Dart来说，现在需要的是时间。

Dart vs JavaScript

JavaScript的弱类型一直被抓短，所以TypeScript、CoffeeScript甚至是Facebook的flow（虽然并不能算JavaScript的一个超集，但也通过标注和打包工具提供了静态类型检查）才有市场。就笔者使用过的脚本语言中（笔者曾使用过Python、PHP），JavaScript无疑是动态化支持最好的脚本语言，比如在JavaScript中，可以给任何对象在任何时候动态扩展属性，对于精通JavaScript的高手来说，这无疑是一把利剑。但是，任何事物都有两面性，JavaScript的强大的动态化特性也是把双刃剑，你可经常听到另一个声音，认为JavaScript的这种动态性糟糕透了，太过灵活反而导致代码很难预期，无法限制不被期望的修改。毕竟有些人总是对自己或别人写的代码不放心，他们希望能够让代码变得可控，并期望有一套静态类型检查系统来帮助自己减少错误。正因如此，在Flutter中，Dart几乎放弃了脚本语言动态化的特性，如不支持反射、也不支持动态创建函数等。并且Dart在2.0强制开启了类型检查（Strong Mode），原先的检查模式（checked mode）和可选类型（optional type）将淡出，所以在类型安全这个层面来说，Dart和TypeScript、CoffeeScript是差不多的，所以单从这一点来看，Dart并不具备什么明显优势，但综合起来看，Dart既能进行服务端脚本、APP开发、web开发，这就有优势了！

综上所述，笔者还是很看好Dart语言的将来，之所以表这个态，是因为在新技术发展初期，很多人可能还有所摇摆，有所犹豫，所以有必要给大家打一剂强心针，当然，这是一个见仁见智的问题，大家可以各抒己见。





【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ziyue7575/p/8e22a5de670cecc985847fc1cd2de5c7.html