Dart 学习笔记

技术
,

dart-logo

阅读 language-tour 时做的一些笔记。

Important concepts

  • Dart 中一切皆对象，除了 null 之外，所有对象都继承自 Object
  • Dart 是强类型语言，但是类型标注是可选的，因为 Dart 中存在类型推断的机制，使用 var 关键字后编译器可以推断出具体的类型
  • 当开启了空安全（dart ≧ v2.12）之后，对于可为空的值必须明确指出（用 ?），可为空的值转换成不为空的值时使用 !
  • 当需要接收任意对象时使用 Object?
  • Dart 支持泛型，比如 List<int>
  • Dart 支持顶层函数和局部函数，同样也支持顶层变量
  • 标识符可以以字母或者 _ 开头，Dart 中 _ 开头的方法表示私有方法
  • Dart 中也分为表达式 expressions 和声明 statements，表达式有返回值而声明无返回值
  • Dart 工具提供了两种类型的问题：警告和错误。警告表示代码可能无法正确执行，错误分为编译期错误和运行时错误，编译期错误会导致程序无法执行，而运行时错误是代码执行过程中抛出的异常。

Variables

1
var name = 'Bob';

变量保存了引用，上面的例子中，name 变量包含了一个引用，该引用指向了一个值为 Bob 的 String 对象。

当使用 var 关键字时，变量的类型可以自动被推断出来，当然你也可以显式指出对象的类型。除此之外，如果你不想限定变量的类型，则可以使用 Obejct 或者 dynamic。

默认值

如果没有开启空安全 (dart ≧ v2.12)，则所有未被初始化的变量都会被初始化为 null，哪怕是数字型的变量，因为 Dart 中一切都是对象。但是，如果开启了空安全，则所有不可为空的变量会被要求先初始化才能使用。

Late 变量

Dart 2.12 之后添加了 late 修饰符，主要有两种用途：

  • 声明不可为空的顶层变量或者成员变量而不直接初始化值
  • 延迟初始化变量（使用到时才初始化）

第一种情况很好理解，因为如果开启了空安全，则顶层变量和成员变量必须要在声明的同时进行初始化，否则编译期无法保证空安全，所以引进 late 之后表明我们不想立马初始化该变量，但是它会在稍后被初始化。

第二种情况则适用于，一个变量对于程序来说是非必须的，或者性能消耗比较大，则可以用 late 修饰，这样，只有在使用到该变量时程序才会初始化它。比如：

1
2
// 如果该变量未被使用，则 _readThermometer() 不会被调用
late String temperature = _readThermometer(); // 延迟初始化

final 和 const

final 修饰的变量只能被赋值一次，并且 final 修饰的顶层变量会在第一次被使用时初始化。

1
2
3
4
final name = 'Bob'; // final 修饰的变量可以没有类型标注
final String nickname = 'Bobby';

name = 'Alice'; // Error: a final variable can only be set once.

const 变量是编译期常量（同时也是 final 的）。如果 const 修饰的是成员变量，则需要用 static const。

1
2
const bar = 1000000; // Unit of pressure (dynes/cm2)
const double atm = 1.01325 * bar; // Standard atmosphere

final 和 const 的不同之处在于，final 修饰的对象不能被修改，但是其属性可以被修改；而 const 修饰的对象和属性都不能被修改，它们是不可变的。

Build-in types

Numbers

  • int, 不大于 64 位
  • double, 64 位浮点数

int 和 double 都是 num 的子类，num 类型的数据包含了基本的操作符，比如加减乘以及 abs(), ceil(), floor(), 位运算等。

Strings

  • Dart 中使用 String 可以用单引号或者双引号。不过，在单引号中的 String 对象中需要对 ' 进行转义。
  • 我们可以使用 ${expression} 在 String 中引用变量或者表达式。
  • 我们可以用 == 比较两个 String 的值是否一致。
  • 我们可以在 String 值之前加 r 来表示原始类型 (raw) 的 String，这样就不需要转义。
  • 我们可以使用三个单引号或者双引号来创建多行 String，同样不需要在其中使用转义符。
  • 我们可以使用字符相乘，但是字符必须在乘数系数的左边，如 🔥 * 3。
  • 我们可以使用字符填充方法，比如 paddingLeft 和 paddingRight。

Booleans

Dart 中使用 bool 表示布尔类型的值。

Lists

Dart 中数组是用 List 表示的。可以用如下的方式创建数组：

1
2
3
4
5
6
var list = [1, 2, 3];
var list = [
  'Car',
  'Boat',
  'Plane', // Dart 中允许添加 trailing comma，这样可以防止复制粘贴出错
];

Dart 2.3 之后添加了扩展运算符 (...) 和空值敏感的扩展运算符 (...?)：

1
2
3
var list = [1, 2, 3];
var list2 = [0, ...list];
assert(list2.length == 4);

Dart 中还有提供了集合 if 和集合 for 的操作：

1
2
3
4
5
6
7
8
9
10
11
12
var nav = [
  'Home',
  'Mall',
  'Mine',
  if (promoActive) 'Outlet'
];

var listOfInts = [1, 2, 3];
var listOfStrings = [
  '#0',
  for (var i in listOfInts) '#$i'
];

关于其它常见的 API 见 collections。

Sets

Dart 中同样用 Set 类型表示无序且唯一的集合。

1
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

Set 和 List 一样，支持扩展运算符、集合 if 和集合 for 的操作。

Maps

Map 是包含了 key 和 value 集合，其中 key 必须唯一。Dar 中的 Map 同样使用花括号 {} 表示，而且优先级比集合 Set 更高：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
}; // 自动推断出 map 的类型为 Map<String, String>

// 也可以通过这种方式创建
var gifts = Map<String, String>();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

var names = {}; // 这种方式创建的是 map 而不是 set

// 访问 map 的语法 []，其实类似调用方法，具体获取到的值是不确定的
// 报错：Const variables must be initialized with a constant value
const lightRed = Colors.red[200];

Runes and grapheme clusters

Dart 中，使用 Runes 表示字符串的 Unicode 字符集。我们可以使用 characters 包下的类来操作字符。

1
2
3
4
5
6
import 'package:characters/characters.dart';
...
var hi = 'Hi ✡️';
print(hi);
print('The end of the string: ${hi.substring(hi.length - 1)}');
print('The last character: ${hi.characters.last}\n'); // 使用 characters 才能正常打印 emoji

Dart 中的字符串使用 UTF-16 编码，如果要用字符串表示 Unicode 字符则需要使用 \uXXXX 的语法。

1
print('\u{1f606}'); // 😆

Symbols

Dart 中使用 Symbol 对象表示操作符或者标识符，用 # + 修饰符表示。

Functions

Dart 中一切都是对象，函数的类型用 Function 表示，而且函数也可以作为变量或者作为方法的参数进行传递。

1
2
3
4
5
6
7
8
9
void say(String content) {
  print(content);
}

// Dart 中只有单个表达式的函数可以使用缩写，用 => 代替 { }
bool isEvenNumber(int num) => num > 0 && num % 2 == 0;

// 这里的参数 body 表示一个返回类型为 Future<T> 的函数
void calculate<T>(Future<T> Function() body) {}

参数

Dart 中的函数除了可以有普通的参数，还可以是具名参数或者可选位置参数。如果使用了 Sound null safety (sdk ≧ 2.12)，且没有指明默认值，则这两种类型参数都必须是可为空的，即参数后跟 ?。

具名参数

具名参数 (Named parameters) 是必须写出名字的参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 函数中使用 {} 圈起来的参数即具名参数
void enableFlags({bool? bold, int? index}) {}

// 可以给具名参数添加默认值
void enableFlags({bool? bold = true}) {}

// 用 required 标记具名参数中必须有的参数
void enableFlags({required bool? bold}) {}

// 调用函数，无参数
enableFlags()

// 调用时如果有参数名则必须写参数名称
enableFlags(
  bold: true,
  hidden: false
);

Dart 2.17 之后，可选具名参数的位置可以在普通参数之前：

1
2
3
4
5
// Dart 2.17 之前
List.generate(5, (index) => index, growable: true);

// Dart 2.17 之后
List.generate(5, growable: true, (index) => index);
可选位置参数

可选位置参数 (Optional positional parameters) 和普通的参数唯一的不同之处是它是可选的😅。用 [] 圈起来的参数即可选位置参数。比如：

1
2
3
4
5
6
7
8
// title 是必须的位置参数，而 subtitle 是可选的
void say(String title, [String? subtitle]) {
  print(title);
  if (subtitle != null) print(subtitle);
}

// 可选位置参数也可以有默认值
void sing(String song, [String? instrument = 'Piano']) { }

main() 函数

每个应用都有一个 main() 函数作为应用的入口。main() 函数通常返回空，并且可以有数组作为参数。

1
2
3
void main(List<String> arguments) {
  print(arguments);
}

匿名函数

Dart 中的匿名函数和其它语言中类似，可以有多个参数或者没有参数，后跟方法体，形式如下：

1
2
3
([[Type] param1[, …]]) {
  codeBlock;
};

如果只有单个的表达式或者只有返回值，可以使用箭头表达式：

1
([[Type] param1[, …]]) => expression; // 如果是赋值表达式，则该值就是返回值

Lexical scope

Dart 同样是具有词法作用域或静态作用域的语言，即只要还在代码作用域内的值，都能访问到。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideFunction = true;

    void nestedFunction() {
      var insideNestedFunction = true;

      assert(topLevel);
      assert(insideMain);
      assert(insideFunction);
      assert(insideNestedFunction);
    }
  }
}

Lexical closures

词法闭包也叫函数闭包，和 JS 中的闭包概念类似，即定义在函数中的函数，同时使得该函数能够访问其它函数作用域中的变量。

1
2
3
4
5
6
7
8
9
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}

void main() {
  var add2 = makeAdder(2);
  print(add2(3)); // 这里 add2 访问了 makeAdder 中定义的值，也即把 2 保存了下来
  print(makeAdder(10)(3));
}

Operators

Dart 中支持的操作符表，见 Operators。

Cascade notation

1
2
3
4
5
6
7
// cascade notation，可以在赋值的基础上对属性和方法进行调用
// 使得创建对象和属性赋值变得更简单，省去创建临时对象的步骤
var paint = Paint()
  ..color = 'Black'
  ..strokeCap = 'Round'
  ..strokeWidth = 5.0;
print(paint);

Control flow statements

switch and case

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Dart 中的 case 语法有 fall through 机制
// 但是如果定义了 case 内容而没有 break 则会报错
var command = 'CLOSED';
switch (command) {
  case 'EARLY_CLOSE': // fall through to 'CLOSED'
  case 'CLOSED':
    var youCantAccess = 1; // Dart 中的 case 自带作用域
    print('bye bye');
    continue afterClosed; // 可以使用 label 绕过无 break 的限制

  afterClosed:
  case 'CLOSED_AFTER':
    // print(youCantAccess); // undefined

    print('see you tomorrow');
    break;
}

Exceptions

Dart 中所有异常都是 unchecked exceptions，意味着 Dart 不会强制你去捕捉异常。

Catch

Dart 中的 try catch 语法：

1
2
3
4
5
6
7
8
9
10
11
12
try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // 特定类型的异常
  buyMoreLlamas();
} on Exception catch (error, stacktrace) { // 第二个参数为错误栈
  // 其它类型的异常
  print('Unknown exception: $error');
} catch (error) {
  // 所有其它未指定的错误
  print('Something really unknown: $error');
}

Classes

Dart 中一切皆对象，除了 null 之外，所有对象都是某个类的实例。除了可以继承类之外，Dart 还提供了一种基于 mixin 的继承，也就是说可以通过 with 关键字继承某个没有构造器的类来扩展功能，还可以使用扩展函数。

Using class members

所有对象都由成员变量和方法构成，使用 . 的语法访问对象的属性或者方法，使用 ?. 访问可为空对象的属性和方法。

Using constructors

Dart 中创建构造器除了可以使用类名，也可以使用 类名.构造器名() 的形式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class DummyClass {
  int i = 0;
  
  // 默认构造函数
  DummyClass(this.i);
  
  // 我们可以为构造函数定义名称，这种构造器被称为「具名构造器」
  DummyClass.create(int i, String message) {
    print(message);
    this.i = i;
  }
  
  // 在「具名构造器」后为成员变量赋值
  DummyClass.ten() : i = 10 { // :后的部分称为 initializer list
    print('Ten ${this.i}'); // print: Ten 10
  }
}

Getting an object’s type

我们可以使用 runtimeType 获得对象的类型 Type。

1
2
var dummy = DummyClass.create(1);
print('The type of a is ${dummy.runtimeType}');

Instance variables

  • 所有未初始化可为空的实例变量都会被初始化为 null。
  • 所有实例变量都会默认自带 getter 函数，非 final 的实例变量和不带初始化器的 late final 实例变量会自动生成 setter 函数。
  • 非延迟初始化的实例变量的值会在对象创建之后，构造器和初始化器列表执行之前，就被赋值。可为空的赋值为 null，不可为空的赋值为初始值。
  • 实例变量可以是 final 的，但是必须在构造器或者初始化列表中进行赋值。

Constructors

Dart 中类的构造器和其它语言类似：

1
2
3
4
5
6
7
8
9
class Point {
  double x = 0;
  double y = 0;

  Point(double x, double y) {
    this.x = x;
    this.y = y;
  }
}

不过，Dart 提供了一种语法糖的写法：

1
2
3
4
5
6
class Point {
  double x = 0;
  double y = 0;

  Point(this.x, this.y);
}
具名构造器

我们可以通过具名构造器 (Named constructors) 为一个类实现多个构造器。不过具名构造器不能被继承，如果想在子类中使用和父类相同的构造器，只能为子类单独实现。

1
2
3
4
5
6
7
8
9
class Weather {
  var humidity = '';

  Weather.display(this.humidity);
}

class Shower extends Weather{
  Shower.display(String humidity) : super.display(humidity);
}
构造器初始化列表

除了调用父类构造器之外，我们还可以在构造器方法体执行之前初始化成员变量，称为 Initializer list。

1
2
3
4
5
6
Point.fromJson(Map<String, double> json)
    : x = json['x']!,
      y = json['y']!,
			super(x) {
  print('In Point.fromJson(): ($x, $y)');
}

初始化起列表中，调用父类构造器必须放到最后。

构造器初始化顺序

默认情况下，子类会先调用父类中的默认构造函数（未定义的话会生成一个无参构造器），如果存在构造器初始化列表 (Initializer list) 则会先调用它们。所以，当使用默认构造函数创建对象时，构造器的初始化顺序为：

  1. 构造器初始化列表
  2. 父类无参构造器
  3. 子类无参构造器

另外，如果父类未定义默认构造器，则子类实现构造器时必须先调用父类的某个具名构造器。

重定向构造器
1
2
3
4
5
6
7
8
class Point {
  double x, y;

  Point(this.x, this.y);

  // 使用 this 关键字重定向到默认构造器
  Point.alongXAxis(double x) : this(x, 0);
}
常量构造器

当你想要创建的对象是编译期常量时（比如用于创建注解），可以使用 const 修饰构造器：

1
2
3
4
5
6
7
class ImmutablePoint {
  static const ImmutablePoint origin = ImmutablePoint(0, 0);

  final double x, y; // 记得所有的变量都要是 final 的

  const ImmutablePoint(this.x, this.y);
}

使用常量构造器 (Constant Constructors) 初始化对象时，使用相同的值的对象只会在第一次创建时被初始化，也就是说相同值的对象只会初始化一次。

工厂构造器

使用 factory 关键字的构造器，适用于不需要每次创建新对象的情况，比如使用了缓存。另一个使用场景是通过 JSON 数据初始化对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Logger {
  final String name;
  bool mute = false;

  static final Map<String, Logger> _cache = <String, Logger>{};

  factory Logger(String name) {
    return _cache.putIfAbsent(name, () => Logger._internal(name));
  }

  factory Logger.fromJson(Map<String, Object> json) {
    return Logger(json['name'].toString());
  }

  Logger._internal(this.name);

  void log(String msg) {
    if (!mute) print(msg);
  }
}

Getters and setters

使用 getters 和 setters 方法定义一些需要通过计算得到的值。

1
2
3
4
5
6
7
8
9
10
11
12
class Rectangle {
  double left, top, width, height;

  Rectangle(this.left, this.top, this.width, this.height);

  // Define two calculated properties: right and bottom.
  double get right => left + width;
  set right(double value) => left = value - width;

  double get bottom => top + height;
  set bottom(double value) => top = value - height;
}

Abstract classes

Dart 中的抽象类同样无法被直接实例化，如果需要实例化可以通过工厂构造器。

1
2
3
4
5
abstract class AbstractContainer {
  // Define constructors, fields, methods...

  void updateChildren(); // Abstract method.
}

Implicit interfaces

Dart 中所有的类都可以作为接口被实现 (通过 implement 关键字)：

1
2
// 使用 implement 关键字实现一个或多个接口
class Point implements Comparable, Location {...}

我们可以使用直接继承获得所有父类的实现，也可以使用 implements 将类作为接口实现，此时子类必须提供所有父类的属性和方法的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
abstract class Animal {
  abstract String name;

  int age;
  
  Animal(this.age);
}

class Dog extends Animal {
  
  @override
  String name = "Dog";
  
  Dog() : super(2);
}

// 如果使用 implements 则必须实现所有类属性
class Cat implements Animal {

  @override
  String name = "Cat"; 
  
  @override
  int age = 3;
}

Extending a class

Dart 中所有类都可以被继承，使用 extends 关键字继承父类，使用 super 引用父类。

Dart 2.17 之后允许在构造器中使用 super 语法：

1
2
3
4
5
6
7
8
9
10
class OutlinedButton extends Button {
  const OutlinedButton({
    super.key,
    super.onPress = () {
      print('Pressed OutlinedButton');
    },
    super.onLongPress,
    required Widget super.child
  });
}

这样就不需要调用父类构造器，写出 super(…) 这样的模板代码了。

Extension methods

和 Kotlin 类似，在 Dart 中我们同样可以通过扩展函数扩充函数库。

1
2
3
4
5
6
7
8
9
extension NumberParsing on String {
  int parseInt() {
    return int.parse(this);
  }
  
  double parseDouble() {
    return double.parse(this);
  }
}

Enumerated types

Dart 中的枚举类和 Java 中类似。

1
enum Color { red, green, blue }

Dart 2.17 之后允许在 enum 类中使用成员变量：

1
2
3
4
enum Water {
  final int temperature;
  const Water(this.temperature);
}

枚举类有以下限制：

  • 无法继承、实现或者混用 (mixin) 枚举类
  • 无法直接实例化

Adding features to a class: mixins

Dart 中还提供了另外一种复用代码的方式 mixin，我们可以把可复用的代码放到 mixin 类中。子类使用 with 关键字进行关联。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
mixin Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;

  void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}

class Musician with Musical {
  // ···
}

class Maestro extends Person with Musical {
  Maestro(String maestroName) : super(maestroName) {
    canPlayPiano = true;
  }
}

除此之外，我们还可以限制 mixin 的使用范围 (on)，以及像接口一样使用逗号 (,) 分割继承多个 mixin：

1
2
3
4
5
6
7
8
9
class Musician {
  // ...
}
mixin MusicalPerformer on Musician {
  // ...
}
class SingerDancer extends Musician with MusicalPerformer, DancerPerformer {
  // ...
}

Class variables and methods

Dart 中的类同样可以使用静态变量和常量，以及静态方法。

1
2
3
4
5
class DummyClass {
  static const a = 1;
  static var b = 2;
  static void f() { }
}

Generics

Dart 中的泛型（参数化类型）和 Java 以及 Kotlin 等语言非常相似，使用 <> 表示泛型。

为什么使用泛型

使用泛型一般有两个目的：

  • 指明泛型类型之后，减少代码出错。比如在集合中加入不该加入的值。
  • 使用泛型减少复制粘贴的代码。比如持有某个对象的类，当需要改变持有的对象而其它部分不发生变化时，如果使用了泛型就不用重新复制一个新的类。

Using collection literals

即在使用集合时定义集合类型，形式如 <type>[] or <type>{} or <keyType, valueType>{}。

1
2
var names = <String>['Seth', 'Kathy', 'Lars'];
var uniqueNames = <String>{'Seth', 'Kathy', 'Lars'};

泛型集合及其类型

Java 中，由于泛型存在类型擦除，所以是无法确定集合的确切类型的。但是，Dart 中的泛型是 reified 的，也就是说在运行时也能得到集合的类型信息。

1
2
3
var names = <String>[];
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List<String>); // true

泛型参数类型的限制

Dart 中限制泛型参数边界同样使用 extends 关键字。

1
2
3
4
5
6
class Foo<T extends SomeBaseClass> {
  // Implementation goes here...
  String toString() => "Instance of 'Foo<$T>'";
}

class Extender extends SomeBaseClass {...}

Libraries and visibility

Dart 中，我们可以通过 import 和 library 指示符创建模块化的、可共享的代码库。另外，即使不使用 library 指示符，每个 dart app 都是一个 library。

导入一个 library 的语法：

1
import 'dart:html'; // html 是 dart 内建的库，所以使用 dart 作为命名空间

其它库可以使用文件路径或者 package: 命名空间：

1
import 'package:test/test.dart'; // 导入一些三方库，比如通过 pub 包管理工具发布的三方库

指定库的前缀

如果两个库有相同的名称，可以通过 as 指定前缀解决冲突。

1
2
3
4
5
6
7
8
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// Uses Element from lib1.
Element element1 = Element();

// Uses Element from lib2.
lib2.Element element2 = lib2.Element();

部分导入

如果只使用到库的一部分，可以使用部分导入的语法，通过 show 和 hide 做到。

1
2
3
4
5
// 只导入 foo
import 'package:lib1/lib1.dart' show foo;

// 导入除了 foo 意外的部分
import 'package:lib2/lib2.dart' hide foo;

实现 libraries

见 Create Library Packages

Asynchrony support

Dart 中有很多返回 Future 和 Stream 对象的函数，我们可以使用它们编写出异步的代码。除此之外，Dart 还提供了 async 和 await 关键字，让你可以像 JS 一样，更方便地写出一些更具易读性的异步代码。

常见的用法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
Future<String> lookUpVersion() async => '1.0.0';

// 在方法末尾添加 async 关键字，说明方法执行耗时操作，返回值通常是 Future
// 如果 async 方法无有意义的返回值，可以返回 Future<void>
Future<String> checkVersion() async {
  var version = '';
  try {
    version = await lookUpVersion();
  } catch (e) {
    // React to inability to look up the version
  }
  return verion;
}

Stream 和 Future 的不同之处在于，它可以连续接收多个异步事件。我们可以通过 StreamBuilder 对持续发生变化的数据流进行监听，比如通过 WebSocket 获取数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
StreamBuilder(
    stream: webSocketChannel.stream,
    builder: (context, snapshot) {
      String message = '';
      if (snapshot.connectionState != ConnectionState.active ||
          snapshot.hasError) {
        message = 'has error';
      }
      if (snapshot.hasData) {
        message = snapshot.data.toString();
      } else {
        message = 'no data';
      }
      return Container(
        padding: EdgeInsets.symmetric(vertical: 10),
        child: Text('$message',
            style: Theme.of(context).textTheme.headline6),
      );
    },
  ),
)

另外，我们还可以通过 Stream 实现事件总线的功能，比如 event_bus 就是基于 Stream 实现的。

Generators

Dart 中的 Generator 函数和 ES6 中相似，如果你想要延迟生成一系列值，可以考虑使用生成器。Dart 中的 Generator 函数分为两种：

  • 同步生成器：返回 Iterable 对象
  • 异步生成器：返回 Stream 对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 同步生成器
Iterable<int> naturalsTo(int n) sync* {
  int k = 0;
  while (k < n) yield k++;
}

// 异步生成器
Stream<int> asynchronousNaturalsTo(int n) async* {
  int k = 0;
  while (k < n) yield k++;
}

// 递归的生成器，使用 yield* 提高性能
Iterable<int> naturalsDownFrom(int n) sync* {
  if (n > 0) {
    yield n;
    yield* naturalsDownFrom(n - 1);
  }
}

Callable classes

我们可以通过给某个类实现 call() 方法，使得该类可以像方法一样被调用。

1
2
3
4
5
6
7
8
9
class WannabeFunction {
  String call(String a, String b, String c) {
    print('WannabeFunction.call()');
    return '$a $b $c!';
  }
}

var wf = WannabeFunction(); // 初始化该类对象，然后可以像方法一样调用它们
wf('Hi', 'there,', 'gang') // 实际调用的是 call() 方法

Isolates

与其它语言的并发机制不同，Dart 中并没有采用共享状态的并发机制 (shared-state concurrency)，而是使用了 isolates。所有的代码都运行在自己的 isolate 中，每个 isolate 都有自己的内存堆，保证了相互独立性。

更多资料见：Isolates。

Typedefs

Dart 中，一切皆是对象，函数也是对象，但是函数对象的信息在运行时往往会被丢失，比如下面这个例子：

1
2
3
4
5
6
7
8
9
10
11
12
class SortedCollection {
  Function compare;

  SortedCollection(int f(Object a, Object b)) : compare = f;
}

int sort(Object a, Object b) => 0;

SortedCollection sc = SortedCollection(sort);

// 只知道 compare 是 Function，但是其具体类型被丢失了
assert(sc.compare is Function);

typedef 就是为了解决上面这个问题而出现的，我们可以给方法类型一个别名，这样，当方法被赋值到一个变量上时就能保留其类型信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 函数的信息被保存在 Compare 中
typedef Compare = int Function(Object a, Object b);

class SortedCollection {
  Compare compare; // 用于接收我们定义的函数

  SortedCollection(this.compare);
}

int sort(Object a, Object b) => 0;

SortedCollection sc = SortedCollection(sort);
assert(sc.compare is Compare); // 现在可以确定函数的具体类型了

typedef 也可以使用泛型：

1
2
3
4
5
typedef Compare<T> = int Function(T a, T b);

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

assert(sort is Compare<int>); // True!

Metadata

通过元信息注解，我们可以为类和方法提供额外的信息。Dart 中自带的注解有 @deprecated 和 @override，除此之外，你也可以自定义注解，只要在类的构造器上使用 const 关键字就可以了：

1
2
3
4
5
6
class Todo {
  final String who;
  final String what;

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

Comments

Dart 支持三种类型的注释：单行注释、多行注释和文档注释。

1
2
3
4
5
6
7
8
9
10
/// 文档注释，使用 [] 给成员属性或者方法添加链接，比如查看 [main] 方法
/// 虽然 Dart 中也能用 /** */ 作为文档注释，但是编辑器会提醒你用 /// 代替
void main() {
  // 单行注释
  print('Howdy!');
  /*
   * 多行注释
   */
   print('Hola!');
}