Dart 语法基础 - 社亦园的旅行笔记

简单过了一遍 dart 的语法，个人感觉 dart 的语法像是 go 里 go 气的 ts，不愧是谷歌的手笔；dart 代码使用严格分号结尾，这点与 go 刚好相反。

1. 变量与常量#

说明#

var 是类型推断，第一次赋值后类型就确定，不能再赋值为其他类型。
也可以显式写类型，如 String name = "...";，可读性更高。
const 是编译期常量，值必须在编译阶段可确定。
final 是运行期常量，可以在运行时初始化，但只能赋值一次。

1
// var：让编译器根据右侧值推断类型，这里推断为 int
2
var age = 20; // age 之后只能继续接收 int
3

4
// 显式声明：直接把类型写在前面，可读性更好
5
String name = "Sheyiyuan"; // name 的静态类型固定是 String
6

7
// const：编译期常量，值在编译阶段就确定
8
const double pi = 3.141592653589793;
9
const double root2 = 1.4142135623730951;
10

11
// final：运行时初始化一次，之后不可再赋值
12
final DateTime time = DateTime.now(); // 每次运行值可能不同

2. 字符串 String#

说明#

Dart 支持单引号和双引号，本文默认双引号。
字符串插值常用 $var 和 ${expression}。
当拼接表达式或存在变量名歧义时，优先使用 ${}。
字符串模板不是反引号语法，直接使用普通引号即可。

1
// 基本字符串声明
2
String text1 = "故障机器人";
3
String text2 = '坠机了';
4

5
// 字符串插值：变量可直接写 $变量名
6
// 复杂表达式建议用 ${表达式}
7
String text = "${text1}又$text2";
8

9
// 当变量名可能连续时，用空格或 ${} 避免歧义
10
int f = 1;
11
int fg = 2;
12
print("$f $fg"); // 输出: 1 2

3. 数值类型：int / double / num#

说明#

int 表示整数，double 表示浮点数，num 是二者共同父类型。
类型推断下，整数字面量通常推断为 int，小数字面量推断为 double。
Dart 默认不做通用隐式转换，字符串与数字互转需要显式调用 API。
double 可以赋值给 num；num 赋值给 double 需要显式转换。

1
// 明确声明不同数字类型
2
int a = 1;
3
double b = 1.1;
4
num c = 2; // num 可接收 int 或 double
5

6
// 查看运行时类型（调试时很有用）
7
print("a.runtimeType: ${a.runtimeType}, b.runtimeType: ${b.runtimeType}");
8

9
// 显式转换：int -> double
10
double d = a.toDouble();
11

12
// 显式转换：double -> int（会截断小数部分，不是四舍五入）
13
int e = b.toInt();
14

15
// 字符串转数字：解析失败会抛异常
16
int parsed = int.parse("123");
17

18
// 数字转字符串
19
String s = parsed.toString();

4. 布尔类型 bool#

说明#

布尔值只有 true 和 false。
Dart 不允许把非布尔值当作条件表达式。

1
bool isCompleted = false;

5. 列表 List#

说明#

List<T> 是有序集合，索引从 0 开始。
推荐写泛型（如 List<String>），避免 dynamic 扩散。
const 列表是不可变列表，不能做增删改。
常用操作：add、addAll、where、every、remove、removeAt、clear。

1
// 声明一个元素类型为 String 的列表
2
final List<String> names = ["Alice", "Bromia"];
3

4
// add：在尾部追加一个元素
5
names.add("Cecelia");
6

7
// addAll：把另一个集合的元素依次追加到尾部
8
names.addAll(["Defect", "Defect"]);
9
print(names); // [Alice, Bromia, Cecelia, Defect, Defect]
10

11
// forEach：遍历每个元素并执行回调
12
names.forEach((element) {
13
  print(element);
14
});
15

16
// every：判断是否“所有元素都满足条件”
17
bool allDefect = names.every((element) => element == "Defect");
18

19
// where：筛选满足条件的元素，返回 Iterable
20
Iterable<String> defectNames = names.where((element) => element == "Defect");
21
print("All elements are Defect: $allDefect");
22
print("Defect names: ${defectNames.toList()}"); // toList 转回 List 便于打印
23

24
// 常见属性
25
print("Number of elements: ${names.length}"); // 长度
26
print("First element: ${names.first}"); // 首元素
27
print("Last element: ${names.last}"); // 尾元素
28
print("Is the list empty? ${names.isEmpty}"); // 是否为空
29

30
// 删除操作示例
31
names.remove("Defect"); // remove：删除第一个匹配项
32
names.removeLast(); // 删除最后一个元素
33
names.removeRange(0, 2); // 删除区间 [0, 2)，左闭右开
34
if (names.isNotEmpty) {
35
  names.removeAt(0); // 删除指定索引元素
36
}
37
print(names);

6. 字典 Map<K, V>#

说明#

Map 是键值对集合，键唯一、值可重复。
推荐总是声明泛型，提升可读性和类型安全。
常用操作：map[key] = value、keys、values、length、remove、containsKey、containsValue、addAll、forEach、clear。
字符串插值中访问键时常写成 ${map['name']}，这里使用单引号可避免转义。

1
// 声明键和值都为 String 的 Map
2
final Map<String, String> typedInformMap = {
3
  "name": "Sheyiyuan",
4
  "age": "18",
5
};
6

7
// 通过索引语法新增或覆盖键值
8
typedInformMap["gender"] = "male";
9
typedInformMap["age"] = "20"; // 覆盖原 age
10
print(typedInformMap); // {name: Sheyiyuan, age: 20, gender: male}
11

12
// 读取与属性查看
13
print("Name: ${typedInformMap['name']}"); // 读取指定键
14
print("Keys: ${typedInformMap.keys}"); // 所有键
15
print("Values: ${typedInformMap.values}"); // 所有值
16
print("Number of key-value pairs: ${typedInformMap.length}"); // 键值对数量
17

18
// 删除与判断
19
typedInformMap.remove("age"); // 返回被删掉的值（若不存在则为 null）
20
print("Contains key \"name\"? ${typedInformMap.containsKey("name")}");
21
print("Contains value \"male\"? ${typedInformMap.containsValue("male")}");
22

23
// addAll：合并另一个 Map（同名键会被覆盖）
24
typedInformMap.addAll({
25
  "name": "社亦园",
26
  "hobby": "coding",
27
  "age": "20",
28
});
29

30
// forEach：遍历每一组 key-value
31
typedInformMap.forEach((key, value) {
32
  print("$key: $value");
33
});
34

35
// clear：清空 Map
36
typedInformMap.clear();
37
print(typedInformMap); // {}

7. 动态类型 dynamic#

说明#

dynamic 可以在运行时变更实际类型。
适合边界场景（如 JSON 反序列化过渡阶段），不建议滥用。
过多使用 dynamic 会削弱静态检查能力。

1
// dynamic 可在运行时持有任意类型
2
// 代价是编译期类型检查能力变弱
3
dynamic variable = "Hello, Dart";
4
print(variable); // Hello, Dart
5

6
// 同一个变量可改成 int
7
variable = 42;
8
print(variable); // 42
9

10
// 也可改成 List<int>
11
variable = [1, 2, 3];
12
print(variable); // [1, 2, 3]

8. 空安全（Null Safety）#

说明#

Dart 默认非空，变量默认不能为 null。
可空类型使用 ?，如 String?。
安全访问使用 ?.，空合并默认值使用 ??。
非空断言 ! 需谨慎，判断错了会触发运行时错误。

1
// String?：可空字符串，允许赋值 null
2
String? nullableString = "Hello, Dart";
3
print(nullableString); // Hello, Dart
4

5
nullableString = null;
6
print(nullableString); // null
7

8
// String：非空字符串，不能赋值 null
9
String nonNullableString = "Hello, Dart";
10
print(nonNullableString);
11

12
// ?.：当左侧为 null 时，整条表达式返回 null，不会抛异常
13
int? length = nullableString?.length;
14
print(length); // null
15

16
// ??: 左侧为 null 时使用右侧默认值
17
String defaultString = nullableString ?? "Default String";
18
print(defaultString); // Default String

9. 运算符#

说明#

算术：+、-、*、/、~/（整除）、%。
赋值：=、+=、-=、*=、/=、~/=、%=。
比较：==、!=、>、<、>=、<=。
逻辑：&&、||、!，并且 && / || 具备短路特性。

1
int a1 = 10;
2
int b1 = 3;
3

4
// 算术运算
5
print("a1 + b1 = ${a1 + b1}");
6
print("a1 - b1 = ${a1 - b1}");
7
print("a1 * b1 = ${a1 * b1}");
8
print("a1 / b1 = ${a1 / b1}"); // / 结果是 double
9
print("a1 ~/ b1 = ${a1 ~/ b1}"); // ~/ 是整除
10
print("a1 % b1 = ${a1 % b1}");
11

12
int c1 = 5;
13

14
// 复合赋值运算
15
c1 += 2;
16
c1 -= 3;
17
c1 *= 4;
18
c1 ~/= 5;
19
c1 %= 2;
20
print("c1 = $c1");
21

22
int d1 = 10;
23
int d2 = 20;
24

25
// 比较运算
26
print("d1 == d2: ${d1 == d2}");
27
print("d1 != d2: ${d1 != d2}");
28
print("d1 > d2: ${d1 > d2}");
29
print("d1 < d2: ${d1 < d2}");
30
print("d1 >= d2: ${d1 >= d2}");
31
print("d1 <= d2: ${d1 <= d2}");
32

33
bool e1 = true;
34
bool e2 = false;
35

36
// 逻辑运算（&& / || 支持短路）
37
print("e1 && e2: ${e1 && e2}");
38
print("e1 || e2: ${e1 || e2}");
39
print("!e1: ${!e1}");

10. 流程控制#

说明#

条件语句：if / else if / else、switch。
循环语句：for、while、do-while。
三目表达式可在简单分支中替代 if。

1
int f1 = 10;
2

3
// if / else if / else 分支判断
4
if (f1 > 5) {
5
  print("f1 is greater than 5");
6
} else if (f1 == 5) {
7
  print("f1 is equal to 5");
8
} else {
9
  print("f1 is less than 5");
10
}
11

12
// 三目表达式：简洁地返回分支结果
13
String result = (f1 > 5) ? "Greater than 5" : "Not greater than 5";
14
print(result);
15

16
int g1 = 2;
17

18
// switch：适合离散值匹配
19
switch (g1) {
20
  case 1:
21
    print("g1 is 1");
22
    break; // 不加 break 会继续执行后续 case
23
  case 2:
24
    print("g1 is 2");
25
    break;
26
  case 3:
27
    print("g1 is 3");
28
    break;
29
  default:
30
    print("g1 is something else");
31
}
32

33
// for：已知循环次数时常用
34
for (int i = 0; i < 5; i++) {
35
  print("i: $i");
36
}
37

38
// while：先判断条件，再决定是否进入循环
39
int j = 0;
40
while (j < 5) {
41
  print("j: $j");
42
  j++;
43
}
44

45
// do-while：先执行一次，再判断条件
46
int k = 0;
47
do {
48
  print("k: $k");
49
  k++;
50
} while (k < 5);

11. 函数#

说明#

Dart 不支持传统函数重载。
可选参数分两类：可选位置参数 []、可选命名参数 {}。
箭头函数适合单表达式返回。
闭包可以捕获外层函数变量。

1
// 普通函数：有函数名、参数和函数体
2
void greet(String name) {
3
  print("Hello, $name!");
4
}
5

6
greet("Cecelia");
7

8
// 可选位置参数：放在 [] 中，调用时可省略
9
void greetWithOptional(String name, [String? greeting]) {
10
  if (greeting != null) {
11
    print("$greeting, $name!");
12
  } else {
13
    print("Hello, $name!");
14
  }
15
}
16

17
greetWithOptional("Cecelia");
18
greetWithOptional("Cecelia", "Hi");
19

20
// 可选命名参数：放在 {} 中，调用时用 参数名:值
21
void greetWithNamed(String name, {String? sign, String? greeting}) {
22
  String actualGreeting = greeting ?? "Hello"; // 提供默认问候语
23
  String actualSign = sign ?? "!"; // 提供默认标点
24
  print("$actualGreeting, $name$actualSign");
25
}
26

27
greetWithNamed("Cecelia", sign: "?");
28
greetWithNamed("Cecelia", greeting: "Hi");
29

30
// 匿名函数：没有函数名，通常赋值给变量
31
var anonymousGreet = (String name) {
32
  print("Hello, $name!");
33
};
34
anonymousGreet("Cecelia");
35

36
// 箭头函数：只有一个表达式时可简写
37
String arrowGreet(String name) => "Hello, $name!";
38
print(arrowGreet("Cecelia"));
39

40
// 闭包：返回的函数可“记住”外层变量 addBy
41
Function makeAdder(int addBy) {
42
  return (int i) => addBy + i;
43
}
44

45
var add2 = makeAdder(2);
46
print(add2(3)); // 5

12. 类#

说明#

Dart 是纯面向对象语言，几乎所有值都是对象。
类由字段（属性）、方法、构造函数组成。
支持普通构造、命名构造、工厂构造、继承、抽象类、接口实现、静态成员。
私有成员通过“库私有”规则实现：以下划线 _ 开头的成员仅在当前库可见。

1
// 一个基础类：演示字段、构造函数、实例方法、getter/setter
2
class Person {
3
  // 普通实例字段：每个对象各自拥有一份
4
  String name;
5
  int age;
6

7
  // 私有字段：以下划线开头，仅当前库可见
8
  String _id;
9

10
  // 主构造函数：this.name / this.age 是参数到字段的简写绑定
11
  Person(this.name, this.age, this._id);
12

13
  // 命名构造函数：更适合表达不同初始化语义
14
  Person.guest() : name = "Guest", age = 0, _id = "GUEST";
15

16
  // getter：对外暴露只读视图
17
  String get maskedId => "***${_id.substring(_id.length - 2)}";
18

19
  // setter：集中做数据校验
20
  set updateAge(int value) {
21
    if (value >= 0) {
22
      age = value;
23
    }
24
  }
25

26
  // 实例方法
27
  void introduce() {
28
    print("Hi, I am $name, age: $age, id: $maskedId");
29
  }
30
}
31

32
// 继承：Student 继承 Person 的字段与方法
33
class Student extends Person {
34
  // 新增子类字段
35
  String major;
36

37
  // super(...) 调用父类构造函数
38
  Student(String name, int age, String id, this.major) : super(name, age, id);
39

40
  // override：重写父类方法
41
  @override
42
  void introduce() {
43
    print("Hi, I am $name, major in $major, age: $age");
44
  }
45
}
46

47
// 抽象类：不能直接实例化，通常用于定义能力规范
48
abstract class Animal {
49
  void speak(); // 抽象方法：子类必须实现
50
}
51

52
// implements：按“接口契约”实现
53
class Dog implements Animal {
54
  @override
55
  void speak() {
56
    print("Woof!");
57
  }
58
}
59

60
// 静态成员：属于类本身，不属于实例
61
class MathHelper {
62
  static const double pi = 3.141592653589793;
63

64
  static double circleArea(double radius) {
65
    return pi * radius * radius;
66
  }
67
}
68

69
// 工厂构造函数：可返回缓存实例，或返回子类型实例
70
class Logger {
71
  final String name;
72

73
  // 私有命名构造：仅类内部可直接调用
74
  Logger._internal(this.name);
75

76
  // 缓存池（静态）
77
  static final Map<String, Logger> _cache = <String, Logger>{};
78

79
  // factory：可以不每次都 new 新对象
80
  factory Logger(String name) {
81
    return _cache.putIfAbsent(name, () => Logger._internal(name));
82
  }
83

84
  void log(String message) {
85
    print("[$name] $message");
86
  }
87
}
88

89
void main() {
90
  // 主构造
91
  Person p1 = Person("Sheyiyuan", 18, "ID2026");
92
  p1.introduce();
93

94
  // 命名构造
95
  Person guest = Person.guest();
96
  guest.introduce();
97

98
  // setter 校验
99
  p1.updateAge = 19;
100
  p1.introduce();
101

102
  // 继承与多态
103
  Person stu = Student("Cecelia", 20, "ST01", "Computer Science");
104
  stu.introduce(); // 实际调用 Student 的重写方法
105

106
  // 抽象类 + 接口实现
107
  Animal dog = Dog();
108
  dog.speak();
109

110
  // 静态成员访问方式：类名.成员
111
  print("Area: ${MathHelper.circleArea(2)}");
112

113
  // 工厂构造缓存验证
114
  Logger l1 = Logger("app");
115
  Logger l2 = Logger("app");
116
  print(identical(l1, l2)); // true，说明命中了缓存
117
  l1.log("Started");
118
}

13. 抽象类与接口实现#

说明#

抽象类用 abstract class 声明，不能直接实例化。
抽象类可以同时包含：
- 抽象成员（只有声明，没有实现）；
- 已实现成员（子类可直接复用）。
extends 表示继承实现：子类会复用父类已实现的逻辑。
implements 表示按接口契约实现：必须重写接口中的所有成员（包括 getter/setter）。
Dart 没有单独的 interface 关键字，任何类都可以被 implements 当作接口使用。

1
// 抽象类：定义“设备”这一抽象概念
2
abstract class Device {
3
  // 抽象 getter：子类必须提供具体返回值
4
  String get model;
5

6
  // 抽象方法：子类必须实现
7
  void start();
8

9
  // 已实现方法：子类可直接继承复用
10
  void shutdown() {
11
    print("$model is shutting down");
12
  }
13
}
14

15
// 普通类被当作“接口”使用（用于 implements）
16
class Chargeable {
17
  int batteryLevel = 0;
18

19
  void charge(int amount) {}
20
}
21

22
// 另一个可被实现的接口
23
class Connectable {
24
  bool get isConnected => false;
25

26
  void connect(String target) {}
27
}
28

29
// extends：继承 Device 已实现方法
30
// implements：必须完整实现 Chargeable / Connectable 的成员
31
class Phone extends Device implements Chargeable, Connectable {
32
  @override
33
  final String model;
34

35
  @override
36
  int batteryLevel;
37

38
  bool _connected = false;
39

40
  Phone(this.model, {this.batteryLevel = 20});
41

42
  @override
43
  void start() {
44
    print("$model is starting");
45
  }
46

47
  @override
48
  bool get isConnected => _connected;
49

50
  @override
51
  void connect(String target) {
52
    _connected = true;
53
    print("$model connected to $target");
54
  }
55

56
  @override
57
  void charge(int amount) {
58
    batteryLevel += amount;
59
    if (batteryLevel > 100) {
60
      batteryLevel = 100;
61
    }
62
    print("$model battery: $batteryLevel%");
63
  }
64
}
65

66
void main() {
67
  Phone phone = Phone("Pixel", batteryLevel: 35);
68

69
  // 来自抽象类约定的方法
70
  phone.start();
71

72
  // 来自接口契约的方法
73
  phone.connect("WiFi-Home");
74
  phone.charge(30);
75

76
  // 来自抽象类已实现的复用方法
77
  phone.shutdown();
78
}

14. 类的混入（mixin）#

说明#

mixin 用于“复用一组方法/字段实现”，避免多层继承导致结构僵硬。
使用方式：class A with M1, M2，可以一次混入多个 mixin。
冲突规则：如果多个 mixin 有同名方法，后写的 mixin 优先级更高。
on 约束：限制该 mixin 只能用于某些父类体系。
mixin 不是普通类，不能被 new 实例化；它是“能力片段”。

1
// 基础类：被混入目标类继承
2
class User {
3
  final String name;
4

5
  User(this.name);
6
}
7

8
// 普通 mixin：提供可复用能力
9
mixin LoggerMixin {
10
  void log(String message) {
11
    print("[LOG] $message");
12
  }
13
}
14

15
// 带状态的 mixin：可声明字段
16
mixin CounterMixin {
17
  int _count = 0;
18

19
  int get count => _count;
20

21
  void increase() {
22
    _count++;
23
  }
24
}
25

26
// 带 on 约束的 mixin：只能混入到 User 或其子类
27
mixin UserInfoMixin on User {
28
  String get displayName => "User<$name>";
29
}
30

31
// with：把多个 mixin 的能力拼装到同一个类里
32
class Admin extends User with LoggerMixin, CounterMixin, UserInfoMixin {
33
  Admin(super.name);
34

35
  void work() {
36
    increase(); // 来自 CounterMixin
37
    log("$displayName working, count=$count"); // Logger + UserInfo
38
  }
39
}
40

41
// 演示同名方法冲突：后面的 mixin 会覆盖前面的实现
42
mixin WalkMixin {
43
  void move() {
44
    print("walk");
45
  }
46
}
47

48
mixin RunMixin {
49
  void move() {
50
    print("run");
51
  }
52
}
53

54
class Athlete with WalkMixin, RunMixin {}
55

56
void main() {
57
  Admin admin = Admin("Sheyiyuan");
58
  admin.work();
59
  admin.work();
60

61
  Athlete athlete = Athlete();
62
  athlete.move(); // 输出 run（因为 RunMixin 写在后面）
63
}

补充#

mixin：只能被混入，不能直接 new。
class：普通类，可实例化、可继承。
mixin class（Dart 3）：既可以被实例化（像类），也可以被 with 混入（像 mixin）。

1
// Dart 3：mixin class 同时具备 class + mixin 的能力
2
mixin class Timestamped {
3
  final DateTime createdAt = DateTime.now();
4

5
  String createdLabel() => createdAt.toIso8601String();
6
}
7

8
class Task with Timestamped {
9
  final String title;
10
  Task(this.title);
11
}
12

13
void main() {
14
  Task t = Task("Write notes");
15
  print(t.createdLabel());
16

17
  // 也可直接实例化（这是 mixin class 与 mixin 的关键区别）
18
  Timestamped ts = Timestamped();
19
  print(ts.createdLabel());
20
}

实践建议：
- 只复用行为，用 mixin；
- 既要“可复用”又要“可单独实例化”，可考虑 mixin class；
- 有明显 is-a 关系时优先 extends，不要滥用 mixin。
常见坑：
- 多个 mixin 同名方法冲突时，后写覆盖前写；
- on 约束不满足会直接编译报错；
- mixin 中状态字段过多会提高耦合度，建议保持轻量。

extends / implements / with 速记#

关键字	核心含义	会继承实现吗	典型场景	注意点
`extends`	继承父类（is-a）	会	明确父子层级关系	单继承；子类可 `@override`
`implements`	按接口契约实现	不会	只要能力约束，不要父类实现	必须实现所有成员
`with`	混入复用能力片段	会（来自 mixin）	横切能力复用（日志、计数、缓存标记）	多个 mixin 冲突时后者覆盖前者

15. 泛型（Generics）#

说明#

泛型的核心价值：把“类型”参数化，提升复用性与类型安全。
常见写法：List<String>、Map<String, int>、class Box<T>、T identity<T>(T value)。
当类型不满足预期时，问题会在编译期暴露，而不是拖到运行时。
可以用 extends 给泛型参数加约束，如 T extends num。

1
// 1) 集合中的泛型：限制元素类型，避免 dynamic 扩散
2
List<String> names = ["Alice", "Bronia"];
3
// names.add(123); // 编译报错：int 不能放进 List<String>
4

5
Map<String, int> scoreMap = {
6
  "math": 95,
7
  "english": 88,
8
};
9
print(scoreMap["math"]);
10

11
// 2) 泛型函数：输入什么类型，就返回什么类型
12
T identity<T>(T value) {
13
  return value;
14
}
15

16
void testGenericFunction() {
17
  String s = identity<String>("hello");
18
  int n = identity<int>(100);
19

20
  // 大多数时候可省略类型参数，让编译器推断
21
  bool flag = identity(true);
22

23
  print("$s, $n, $flag");
24
}
25

26
// 3) 泛型类：把类型作为类的一部分
27
class Box<T> {
28
  T value;
29

30
  Box(this.value);
31

32
  T getValue() => value;
33

34
  void setValue(T newValue) {
35
    value = newValue;
36
  }
37
}
38

39
void testGenericClass() {
40
  Box<String> stringBox = Box<String>("Dart");
41
  print(stringBox.getValue());
42

43
  Box<int> intBox = Box<int>(42);
44
  intBox.setValue(100);
45
  print(intBox.getValue());
46
}
47

48
// 4) 泛型约束：限制 T 必须是 num 或其子类型
49
T addNum<T extends num>(T a, T b) {
50
  // num 的 + 返回 num，这里通过 as T 转回目标类型
51
  return (a + b) as T;
52
}
53

54
void testGenericConstraint() {
55
  int i = addNum<int>(1, 2);
56
  double d = addNum<double>(1.5, 2.5);
57
  print("$i, $d");
58

59
  // addNum<String>("1", "2");
60
  // 编译报错：String 不满足 T extends num
61
}
62

63
void main() {
64
  testGenericFunction();
65
  testGenericClass();
66
  testGenericConstraint();
67
}

泛型实践建议#

集合一律写泛型：List<T> / Map<K, V>，不要偷懒写裸类型。
能用编译器推断就让其推断，但公开 API 建议显式写清类型参数。
写库代码时优先泛型 + 约束，减少 dynamic 与强转。
遇到类型推断不稳定时，手动补上 <T> 通常能快速解题。

常见坑#

把 List 写成裸类型（不带 <T>）会回退到弱约束，容易埋雷。
泛型约束过弱会让 API 太宽泛，过强会影响复用，需平衡。
在泛型方法里滥用 as 强转可能引入运行时异常。

16. 异步编程（Future）#

说明#

Dart 采用事件循环模型：同步代码先执行，再处理微任务队列，最后处理事件队列。
耗时操作（网络请求、文件 IO、定时器）应使用异步 API，避免阻塞主线程。
Future<T> 用于表示“未来某个时刻会得到一个 T 或抛出错误”的结果。
常见写法有两种：
- async/await：可读性高，接近同步代码；
- 链式调用：then / catchError / whenComplete。

事件循环#

执行顺序可简化理解为：

同步代码 -> 微任务队列 -> 事件队列

微任务队列：Future.microtask、scheduleMicrotask。
事件队列：Future(() {})、Future.delayed、Timer 等。

1
import "dart:async";
2

3
void main() {
4
  print("A. sync start");
5

6
  scheduleMicrotask(() {
7
    print("B. microtask");
8
  });
9

10
  Future(() {
11
    print("C. event queue task");
12
  });
13

14
  print("D. sync end");
15
}
16

17
// 常见输出顺序：
18
// A. sync start
19
// D. sync end
20
// B. microtask
21
// C. event queue task

Future 基础#

1
// 模拟异步请求
2
Future<String> fetchData() async {
3
  await Future.delayed(Duration(seconds: 1));
4
  return "Data fetched";
5
}
6

7
// async/await 写法：推荐业务代码优先使用
8
Future<void> runWithAwait() async {
9
  print("[await] start");
10

11
  try {
12
    String result = await fetchData();
13
    print("[await] result: $result");
14
  } catch (e) {
15
    print("[await] error: $e");
16
  }
17
}

链式调用#

1
Future<String> step1() async {
2
  await Future.delayed(Duration(milliseconds: 200));
3
  return "step1";
4
}
5

6
Future<String> step2(String input) async {
7
  await Future.delayed(Duration(milliseconds: 200));
8
  return "$input -> step2";
9
}
10

11
Future<void> runWithChain() async {
12
  step1()
13
      // then 可串联下一个 Future，形成链式流程
14
      .then((value) {
15
        print("chain value1: $value");
16
        return step2(value);
17
      })
18
      .then((value) {
19
        print("chain value2: $value");
20
      })
21
      // catchError 统一处理上游抛出的异常
22
      .catchError((error) {
23
        print("chain error: $error");
24
      })
25
      // whenComplete 无论成功或失败都会执行
26
      .whenComplete(() {
27
        print("chain finished");
28
      });
29
}

Future 与 Promise 对比（Dart vs JavaScript）#

维度	Dart Future	JavaScript Promise
作用	表示未来结果（值或错误）	表示未来结果（值或拒绝）
主要链式 API	`then` / `catchError` / `whenComplete`	`then` / `catch` / `finally`
`async` 函数返回	`Future<T>`	`Promise<T>`
组合并发	`Future.wait` / `Future.any`	`Promise.all` / `Promise.race`
调度模型重点	微任务 + 事件队列（Event Loop）	微任务队列 + 宏任务队列
错误处理习惯	`try/catch` + `catchError`	`try/catch` + `.catch()`

结论：

概念非常接近，可以把 Future 理解为 Dart 世界里的 Promise。
API 命名略有差异：whenComplete 对应 JS 的 finally。
在 Dart 业务代码中通常优先使用 async/await，链式调用适合做流程拼装与中间步骤拦截。