Dart中的异步支持

文章参考：《Flutter实战》

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

   同JavaScript中的async和await的用法和功能一样。

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

//先分别定义各个异步任务
Future<String> login(String userName, String pwd){
    ...
    //用户登录
};
Future<String> getUserInfo(String id){
    ...
    //获取用户信息 
};
Future saveUserInfo(String userInfo){
    ...
    // 保存用户信息 
};

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

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

上面这种多层嵌套容易出错，并且不容易维护，这个问题被形象的称为回调地狱（Callback Hell）。

Angular使用TypeScript语法，同样使用Promise解决回调地狱。
ECMAScript7中引入的async/await。

在Dart中，Future相当于Promise。
使用Future消除回调地狱的方法，就是在then中返回另外一个Future。

login("alice","******").then((id){
      return getUserInfo(id);
}).then((userInfo){
    return saveUserInfo(userInfo);
}).then((e){
   //执行接下来的操作 
}).catchError((e){
  //错误处理  
  print(e);
});

使用async/await消除callback hell

通过Future回调中再返回Future的方式虽然能避免层层嵌套，但是还是有一层回调.
使用async/await消除这种嵌套：
async 位于函数名称后面，函数体前，await用在函数体内，其他方法调用前。

task() async {
   try{
    String id = await login("alice","******");
    String userInfo = await getUserInfo(id);
    await saveUserInfo(userInfo);
    //执行接下来的操作   
   } catch(e){
    //错误处理   
    print(e);   
   }  
}

可以看到，我们通过async/await将一个异步流用同步的代码表示出来了。

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

2. 返回future或者stream
   Angular中有些异步函数返回promise，这个概念与future很相似。
   表示一个异步操作的最终完成（或失败）及其结果值的表示。一个future只对应一个返回结果，要么成功，要么失败。成功了执行成功的方法，失败了则捕捉异常或者停止之后的操作。
   Future 的所有API的返回值仍然是一个Future对象，所以可以很方便的进行链式调用。
3. Future.then
   Future的所有API仍旧返回一个Future。
   可以通过匿名参数来获得上个Future的返回结果，并进行链式处理。

import 'dart:async';

main() {
  doSomeLongtimeWork();
}

Future doSomeLongtimeWork() =>
    Future.delayed(new Duration(seconds: 2), () {
      return "hi world!";
    }).then((returndata) {
      print(returndata);
      return "end this";
    }).then((data){
      print(data);
    });

处理异常的方式：

1. 在then结束后添加catchError( (e){} )。

Future doSomeLongtimeWork() => Future.delayed(new Duration(seconds: 2), () {
      return "hi world!";
    }).then((data) {
      print(data);
      return "end this";
    }).then((data) {
      print(data);
    }).catchError((e) {
      //执行失败会走到这里
      print(e);
    });

2. 在then里面响应 onError：(e){}

Future doSomeLongtimeWork() => Future.delayed(new Duration(seconds: 2), () {
      return "hi world!";
    }).then((data) {
      print(data);
      return "end this";
    }).then((data) {
      print(data);
    }, onError: (e) {
      //执行失败到这里
      print(e);
    });

4. Future.whenComplete
   当整个Future执行完之后，无论成功或者失败 都要进行的方法，放到whenComplete里面。
5. Future.wait
   Future.wait([])接受一个Future数组参数。含义为当数组中的所有的Future都处理完成后，再对每个Future的结果进行处理。
   其结果同样返回一个Future数组。可以通过数组下标访问。

Future.wait([
  // 2秒后返回结果  
  Future.delayed(new Duration(seconds: 2), () {
    return "hello";
  }),
  // 4秒后返回结果  
  Future.delayed(new Duration(seconds: 4), () {
    return " world";
  })
]).then((results){
  print(results[0]+results[1]);
}).catchError((e){
  print(e);
});

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

Stream.fromFutures([
    // 1秒后返回结果
    Future.delayed(new Duration(seconds: 1), () {
      return "hello 1";
    }),
    // 抛出一个异常
    Future.delayed(new Duration(seconds: 2), () {
      throw AssertionError("Error");
    }),
    // 3秒后返回结果
    Future.delayed(new Duration(seconds: 3), () {
      return "hello 3";
    })
  ]).listen((data) {
    print(data);
  }, onError: (e) {
    print(e.message);
  }, onDone: () {
    print("all done!");
  });