flutter前言-dart语言（二）

通过dart语言(一)的学习，相信大家已经可以很熟练的写出完整的应用程序了，但是想要写出更优秀、更完美的dart语言框架，还需要更深入的理解dart语言的一些特点。
接下来，我将带领大家一起更深入的学习dart语言。

目录

image.png

泛型

使用<...> 的方式来定义泛型。

为什么使用泛型？

1. 虽然Dart 语言中类型是可选的，但是明确的指明使用的是泛型，会让代码更好理解。

 var names = new List<String>();
 names.addAll(['xiaojian', 'lili', 'jim']);

2. 使用泛型让代码更简洁

 abstract class IntCache {
   int getByKey(String key);
   setByKey(String key, int value);
 }
 abstract class StringCache {
   String getByKey(String key);
   setByKey(String key, String value);
 }
上面两个类可以优化为：
 abstract class Cache<T> {
   T getByKey(String key);
   setByKey(String key, T value);
 }

集合类型

泛型用于List 、Set、 Map 类型参数化

var names = <String>['Seth', 'Kathy', 'Lars'];
var pages = <String, String>{
  'index.html': 'Homepage',
  'robots.txt': 'Hints for web robots',
  'humans.txt': 'We are people, not machines'
};

构造函数中参数化类型
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
var nameSet = new Set<String>.from(names);
var views = new Map<int, View>();

泛型集合及它们所包含的类型
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List<String>); // true

库和可见性

使用import 和 library 指令可以方便的创建一个模块或分享代码。一个Dart 库不仅能够提供相应的API，还可以包含一些以_开头的私有变量仅在库内部可见。
每一个Dart 应用都是一个库，即使它没有使用library指令。库可以方便是使用各种类型的包。

使用库

使用import指定怎样的命名空间，从一个库引用另一个库。
import唯一要求的参数是指定库的URI。

• dart内置库，URI组合dart:
• 其他库，使用文件路径或package:组合，package:组合式通过包管理工具提供的。

import 'package:flutter/material.dart';
import 'Home.dart';

库的前缀

如果导入的库拥有相互冲突的名字，使用as为其中一个或几个指定不一样的前缀。

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

Element element1 = new Element();           // Uses Element from lib1.
lib2.Element element2 = new lib2.Element(); // Uses Element from lib2.

导入库的一部分

如果只需要使用库的一部分内容，使用show或hide有选择的导入。

// 仅导入foo.
import 'package:lib1/lib1.dart' show foo;
// 除了foo都导入
import 'package:lib2/lib2.dart' hide foo;

延迟加载

延迟加载，也叫懒加载，允许应用程序按需加载库。使用延迟加载的场景：

• 减少程序初始化启动时间。
• 执行A/B测试——尝试替换一个算法的实现。
• 加载很少用的功能，比如可选的屏幕和对话框。
  要延迟加载一个库，首先必须使用deferred as导入它，当需要使用库的时候，使用库名调用loadLibrary()。

import 'package:deferred/hello.dart' deferred as hello;
greet() async {
  // 使用await关键字暂停执行，直到库加载
  await hello.loadLibrary();
  hello.printGreeting();
}

异步(async和await)

使用async函数和await表达式实现异步操作。

当需要使用一个从Future返回的值时，有两个选择：

• 使用async和await。
• 使用Future API。

当需要从一个Stream获取值时，有两个选择：

• 使用async和异步的循环(await for)。
• 使用Stream API。

代码使用了async和await就是异步的，虽然看起来像同步代码。

  static postData(String path, Map<String, String> params,Function successCallBack) async {
    var httpClient = HttpClient();
    var uri = new Uri.https(
        HOST, path, _createPostData(params));
    var request = await httpClient.postUrl(uri);
    var response = await request.close();
    if (response.statusCode == HttpStatus.OK) {
      var json = await response.transform(UTF8.decoder).join();
      var data = JSON.decode(json);

      print("data=====" + data.toString() );
      if(successCallBack!=null){
        successCallBack(data['data']);
      }

    } else {
      print("data=====error");
    }
  }

声明异步函数

异步函数是一个被async标记的函数。
虽然异步的函数中可能执行耗时的操作，但是函数本身在调用后将会立即返回，即使函数体一条语句也没执行。
给函数添加async关键字将使函数返回一个Future类型

checkVersion() async {
  // ...
}
lookUpVersion() async => /* ... */;

案例

   getData(String path, Map<String, String> params) async {
    var httpClient = HttpClient();
    var uri = new Uri.https(
        HOST, path, _createPostData(params));
    var request = await httpClient.postUrl(uri);
    var response = await request.close();
    return await response.transform(UTF8.decoder).join();
  }

调用函数想获得其结果：

void main(){
  String a =  getData("/bbs/list",map);
  print(a);
}

运行后程序报错：

Failed to load "/Users/wangxiaojian/Documents/androidCode/flutter_rong_app/test/widget_test.dart": type 'Future<dynamic>' is not a subtype of type 'String'

test/widget_test.dart 55:14                                                                    main
===== asynchronous gap ===========================
package:test                                                                                   serializeSuite
/var/folders/j7/0w0w7vgd6s5f_gv67_jfzgjr0000gn/T/dart_test_listenerqkAJjf/listener.dart 19:27  main

因为data是String类型，而函数getData()是一个异步操作函数，其返回值是一个await延迟执行的结果。在Dart中，有await标记的运算，其结果值都是一个Future对象，Future不是String类型，所以就报错了。

那如果这样的话，我们就没法获取到延迟执行的结果了？当然可以，Dart规定有async标记的函数，只能由await来调用，比如这样：

void main() async{
 // await 必须在有async标记的函数中运行
  String a = await getData("/bbs/list",map);
  print(a);
}

上面这种方法一般用于调用封装好的异步接口，比如getData()被封装到了其他dart文件，通过使用async函数对其调取使用

• await关键字必须在async函数内部使用
• 调用async函数必须使用await关键字

PS：await关键字真的很形象，等一等的意思，就是说，既然你运行的时候都要等一等，那我调用的时候也等一等吧

为什么要用Future？

在定义Flutter函数时，还可以指定其运行结果返回值的类型，以提高代码的可读性：

Future<String> getData(String path, Map<String, String> params) async {
    var httpClient = HttpClient();
    var uri = new Uri.https(
        HOST, path, _createPostData(params));
    var request = await httpClient.postUrl(uri);
    var response = await request.close();
    return await response.transform(UTF8.decoder).join();
 }

Future最主要的功能就是提供了链式调用，熟悉ES6语法的小伙伴都应该很熟悉，链式调用解决两大问题：明确代码执行的依赖关系和实现异常捕获。
看下面案例：

String _name = "";

void _setName(String name) async{
  _name =  name;
}

void _getName() async{
   await _setName("wangxiaojian");
   print(_name);
}

void main() async{
   await _getName();
}

如果要想先执行_getName再执行_setName，必须在_getName中await _setName();_setName的代码与_getName耦合，将来如果_getName废掉或者改动，_setName中还需要经过修改以适配变更。

为了解决此问题，Future提供了一套非常简洁的解决方案,而async和await无法企及的，因此掌握Future还是很有必要滴：

String _name = "";
_setName() {
  _name = "wangxiaojian";
}
_getName() {
  print(_name);
}
void main() {
  new Future(_setName()).then(_getName());
}

可调用类

Dart 语言中为了能够让类像函数一样能够被调用，可以实现call()方法。

class ClassFunction {
  call(String a, String b, String c) => '$a $b $c!';
}

main() {
  var cf = new ClassFunction();
  var out = cf("wangxiaojian","is","talent");
  print('$out');
  print(cf.runtimeType);
  print(out.runtimeType);
  print(cf is Function);
}
运行结果：
wangxiaojian is talent!
ClassFunction
String
false

类型定义

typedef关键字，用来声明一种类型，当一个函数类型分配给一个变量时，保留类型信息。

// 声明一种 Compare类型
typedef int Compare(int a, int b);

int sort(int a, int b) => a - b;

main() {
  print(sort is Compare); 
}
运行结果：
true

元数据

元数据是以@开始的修饰符。在@ 后面接着编译时的常量或调用一个常量构造函数。

所有dart代码中可用的三个注解：

• @deprecated 被弃用的
• @override 重载
• @proxy 代理

定义自己的元数据

通过library来定义一个库，在库中定义一个相同名字的class，然后在类中定义const 构造方法。

// 定义
library todo;

class todo {
  final String who;
  final String what;

  const todo(this.who, this.what);
}

// 使用
import 'todo.dart';

@todo('seth', 'make this do something')
void doSomething() {
  print('do something');
}

元数据可以修饰library(库), class(类), typedef(类型定义), type parameter(类型参数), constructor(构造函数), factory(工厂函数), function(函数), field(作用域), parameter(参数), 或者 variable declaration(变量声明)。

可以使用reflection反射，在运行时检查元数据。