跳到正文
CH 01起步Dart12 分钟阅读

Dart 起步:值与变量、函数、基础类型、const/final

第 1 章 · Dart 起步:值与变量、函数、基础类型、const/final

本章示例examples/ch01-dart-basics在线阅读源码下载 zip

run

$cd examples/ch01-dart-basics && dart pub get && dart run

已验证

  • dart analyze(0 告警)、dart test(25 个用例全绿)
  • 完整工程已打包:打包下载
本章目录 · 18 节

1.1 本章目标

读完本章你能做到:

  • 看懂一个纯 Dart 程序从 main() 到输出的全过程,知道它和 C/Go 程序在"启动"上的差别;
  • 正确使用 var / final / const 三种声明,并说清它们分别对应 C/Go 的什么;
  • 掌握 Dart 的数值与字符串类型,知道哪些"整数溢出""取模"行为会坑到 C/Go 老兵;
  • 用命名参数、可选参数、函数类型、闭包写出 Dart 风格的函数,替代 C 的函数指针与 Go 的选项模式;
  • 理解 Dart 没有函数重载、没有二进制字面量、没有结构相等(==)这三大"缺失"。

本章只讲纯 Dart,不涉及 Flutter。下一章(ch02)立刻进入 Flutter,从第 1 章起就保持"Dart 主题 ↔ Flutter 主题"的交替节奏。

1.2 从 main() 说起

dartbin/ch01_dart_basics.dart源文件
// examples/ch01-dart-basics/bin/ch01_dart_basics.dart
import 'package:ch01_dart_basics/basics.dart';

void main() {
  print('--- 1. 数字 ---');
  print('int 溢出回绕: ${intOverflow()}');
  // ...
}

对照三种语言的"入口":

项 C Go Dart
入口签名 int main(int argc, char **argv) func main() void main(List<String> args)
返回值 进程退出码 无(os.Exit) 无;用 exitCode / dart:io 的 exit()
参数 argc/argv os.Args main 的 List<String> args(不含程序名)
打印 printf + 手写格式符 fmt.Println print(),任意对象都能打印
编译 gcc -o x main.c go build dart run(JIT) / dart compile exe(AOT)

要注意的两个差异:

  1. 没有 printf。print() 直接接受任意对象,调用其 toString()。格式化用字符串插值,编译器会检查类型——这是比 printf("%d", "str") 少一整类 bug 的地方。
  2. dart run 不带参数时,执行 bin/<package_name>.dart。包名在 pubspec.yaml 里声明,本例是 ch01_dart_basics,所以入口文件必须叫 bin/ch01_dart_basics.dart。这是新手最常撞的一堵墙(Could not find bin/xxx.dart in package)。

1.3 数字:int / double / num

Dart 的数值模型极其简洁,只有三个类型:

dartlib/basics.dart源文件
// examples/ch01-dart-basics/lib/basics.dart
/// Dart 原生(VM / AOT)的 `int` 是**定长 64 位有符号整数**,溢出静默回绕。
int intOverflow() => 9223372036854775807 + 1; // -9223372036854775808

/// `~/` 是向零截断的整除(等价于 C 的 `/`);`/` 永远返回 `double`。
int truncatingDivision(int a, int b) => a ~/ b;

/// `%` 是**欧几里得取模**:结果永远非负。
int moduloFollowsDivisor(int a, int b) => a % b;

/// `/` 的结果是双精度浮点。
double doubleDivision(int a, int b) => a / b;

实测输出(dart run 的真实结果):

text
int 溢出回绕: -9223372036854775808
7 ~/ 2 = 3, 7 / 2 = 3.5
-7 % 3 = 2 (C/Go 给 -1)
7 % -3 = 1 · 7.remainder(-3) = 1
0.1 + 0.2 == 0.3 ? false

概念对照

项 C Go Dart
整数类型 char/short/int/long/... 一堆 int8..int64、uint8..uint64、int、uint 只有 int(原生 64 位有符号)
浮点 float/double float32/float64 只有 double(64 位 IEEE-754)
无符号 unsigned uint* 没有;需要位运算时用 & 0xFFFFFFFF 自己截
溢出 有符号溢出是 UB 静默回绕 静默回绕(规范保证,非 UB)
整除 a / b(整数相除截断) a / b a ~/ b;a / b 得 double
取模 a % b,符号跟随被除数 同 C 永远非负(欧几里得取模)
类型转换 隐式/显式 cast 显式 int64(x) 显式 toInt() / toDouble() / as

陷阱清单

  • / 不是整除。final avg = total / count; 得到 double,再赋给 int 变量直接编译失败。Go 程序员第一次写 List<int> 求平均时会立刻撞上。
  • % 是欧几里得取模。C/Go 的 -7 % 3 == -1,Dart 是 2。写环形缓冲区、哈希槽位时这其实是好事(不会得到负下标),但做"符号跟随被除数"的算法(如 CRC、定点数)时必须显式用 a.remainder(b)。
  • 没有无符号类型。做协议解析、CRC32、哈希时这是最大的心智落差;标准做法是全部用 int 装 64 位,用 & 0xFFFFFFFF、>>> (无符号右移)来模拟 32 位无符号语义。
  • int 在 Web 上是 double(53 位),但本项目明确不把 Web 作为目标平台,这条只作背景知识。
  • 没有二进制字面量:C 和 Go 都能写 0b1010,Dart 里是语法错误,只能 int.parse('1010', radix: 2)。这一条在本章示例的第一次编译里就把我拦下来了(见 1.10 的"踩坑记录")。

代码对照:整数回绕与取模

c
// C:有符号溢出是 UB,编译器可以任意优化
int64_t f(void) { return INT64_MAX + 1; }        // UB!
int64_t m = -7 % 3;                              // -1
go
// Go:回绕,符号跟随被除数
func f() int64 { return math.MaxInt64 + 1 }      // -9223372036854775808
m := -7 % 3                                      // -1
dart
// Dart:回绕 + 欧几里得取模
int f() => 9223372036854775807 + 1;              // -9223372036854775808
int m() => (-7) % 3;                             // 2
int cStyle() => (-7).remainder(3);               // -1

1.4 字符串:不可变的 UTF-16 码元序列

dart
String greet(String name, int age) => 'Hello, $name (${age + 1} next year)';
String windowsPath() => r'C:\temp\new\file.txt';   // raw string,反斜杠不转义
int codeUnitLength(String s) => s.length;          // UTF-16 码元数
int runeLength(String s) => s.runes.length;        // Unicode 码点数

'👋' 的 length 是 2,runes.length 是 1——因为 Dart 的 String 像 C# / Java,底层是 UTF-16,增补平面字符由代理对(surrogate pair)表示。

项 C Go Dart
类型 char * / char[](无长度) string(不可变字节序列,带长度) String(不可变 UTF-16 序列,带长度)
len 的语义 到 \0 的距离 字节数 UTF-16 码元数
按字符遍历 手写 UTF-8 解码 for _, r := range s for (final r in s.runes)
拼接 strcat/snprintf +(每次复制) + 或 StringBuffer
格式化 printf 格式符 fmt.Sprintf 插值 ${expr}
可变性 char[] 可变 不可变 不可变

陷阱清单

  • length 不是字符数,s[0] 返回的是码元(String 甚至不支持 s[0] 这种下标,要用 s.codeUnitAt(0)),拿单个字符用 s[0] 在 Dart 里直接不合法。
  • + 在循环里是 O(n²),与 Go 一致。大量拼接用 StringBuffer(对应 Go 的 strings.Builder)。
  • raw string 依然不能跨 '。写正则用 r'\d+' 很舒服,但正则里的 $、{} 仍要注意 Dart 自己的插值只发生在非 raw 字符串里。

1.5 var / final / const:三种"不可变"层次

这是从 C/Go 过来最容易糊涂的一块,必须一次讲清。

dart
const int maxRetries = 3;                 // 编译期常量
const List<int> defaultPorts = [80, 443]; // 编译期常量集合(不可变 + 被规范化)
DateTime requestTimestamp() => DateTime.now(); // 运行期求值
声明 何时确定值 语义 C 类比 Go 类比
var x = ... 运行期 可变,类型由初始值推断且钉死 auto x = ... x := ...
final x = ... 运行期,一次 只赋值一次 Type *const x(指针本身不可改) 无对应物(Go 只有常量)
const x = ... 编译期 编译期常量,可用作常量表达式 #define / static const const x = 3(仅限字面量)

两条实测行为值得记住:

dart
// 内容相同的两个 const 列表 → 同一个对象(规范化 canonicalization)
identical(defaultPorts, const [80, 443]);        // true

// 内容相同的普通列表 → 两个对象,且 == 是 identity
<int>[80, 443] == <int>[80, 443];                // false

const 的"规范化为同一对象"是 Dart 独有的优化:编译期就能确定常量池,identical() 为 true。这也意味着 const 对象深度不可变——defaultPorts.add(8080) 抛 UnsupportedError,集合本身被冻结。

陷阱清单

  • const 不是"只读视图",它是编译期常量。const x = DateTime.now(); 编译失败。想要"运行期一次赋值"就用 final。
  • final 只冻结引用:final list = <int>[1]; list.add(2); 完全合法,改变的是列表内容而不是引用。等价于 C 的 int *const p(指针不可变,指向内容可变)。
  • const 构造函数能传染:如果类有 const 构造,const Foo() 会把整棵树变成编译期常量。这是 Flutter 里 const Text('hi') 能省掉重建的关键(ch02 会讲)。
  • Go 的 const 只有字面量,而 Dart 的 const 表达式支持算术、字符串拼接、其他 const 变量、const 构造——比 Go 强,比 C 的 #define 安全(有类型检查)。

1.6 函数:命名参数替代重载

Dart 没有函数重载。同一个名字只能有一个函数。取而代之的是可选命名参数:

dart
String buildUser({
  required String name,
  int age = 0,
  String tag = 'default',
  bool active = true,
}) =>
    'User(name: $name, age: $age, tag: $tag, active: $active)';

int sumAll(List<int> xs, [int start = 0]) => xs.fold(start, (a, x) => a + x);
  • {} 包裹的是命名参数,调用时用 name: value 形式,顺序任意;
  • required 强制调用方必须传(编译期检查);
  • [] 包裹的是可选位置参数,只能从尾部省略——这是 Go 里"默认参数"的最近替代;
  • 默认值必须是编译期常量(所以不能写 DateTime.now())。

Go 里你会写一坨 type Option func(*Config) + WithTimeout(...);Dart 里直接在签名上写默认值即可。C 里则根本没有可选参数,只能靠 argc 判断或用 struct 填充。

陷阱清单

  • 没有重载,foo(int) 和 foo(String) 不能共存。要么改名(fooInt/fooString),要么用命名参数,要么用 dynamic(不推荐)。
  • required 不是关键字意义上的"必填位置参数",它是命名参数的必填标记。
  • 可选位置参数不能跳中间:sumAll(x, , 3) 不合法;需要"随意省略"就用命名参数。
  • 顶层函数 vs 方法:Dart 允许顶层函数(像 C 的全局函数、Go 的包级函数),但也可以把一切都塞进类。本项目风格是"纯逻辑写成顶层函数或工具类,方便单测"。

1.7 函数是一等公民、闭包与 tear-off

dart
typedef IntBinOp = int Function(int a, int b);   // 等价 C 的 typedef int (*op)(int,int)
int add(int a, int b) => a + b;
int applyOp(IntBinOp op, int a, int b) => op(a, b);

int Function(int delta) makeAccumulator({int start = 0}) {
  var total = start;          // 被闭包捕获 → 逃逸到堆
  return (int delta) => total += delta;
}

List<int> capturedLoopVariables(int n) {
  final fns = <int Function()>[];
  for (var i = 0; i < n; i++) {
    fns.add(() => i);         // 每轮迭代的 i 是独立的
  }
  return fns.map((f) => f()).toList();  // [0, 1, 2]
}

实测:capturedLoopVariables(3) 返回 [0, 1, 2]。

这是 Dart 比老 Go 舒服的地方:for (var i = ...) 的循环变量每轮迭代都是新变量,闭包各捕获各的。Go 在 1.22 之前所有闭包共享同一个 i(for i := 0; i < 3; i++ { fns = append(fns, func() { print(i) }) } 会打印 3 3 3)。Dart 从一开始就是 1.22 之后的语义,&i 那套"每轮拷一份"的写法在这里不需要。

makeAccumulator 则演示了另一半:闭包捕获变量本身,写操作作用在同一个堆上的 total。C 里要手动做这个,得 malloc 一个 struct 并把函数指针和状态绑在一起(就是 GoF 的"函数对象");Dart 的 GC 帮你延长生命周期——这既是便利,也是内存泄漏的常见来源(ch05 会讲"忘了取消的 Stream 订阅会一直持有闭包")。

函数类型速查

C Go Dart
int (*op)(int,int) func(int, int) int int Function(int, int)
typedef ... op_fn; type Op func(int,int) int typedef Op = int Function(int,int);
&add 取地址 直接写 add 直接写 add(tear-off)
op(a,b) op(a,b) op(a,b)

1.8 record:最像 Go 多返回值的类型

Dart 3 引入的 record(记录) 是值语义的元组,按字段结构相等:

dart
({int quotient, int remainder}) divMod(int a, int b) =>
    (quotient: a ~/ b, remainder: a % b);

(int, int) minMax(List<int> xs) { /* ... */ return (lo, hi); }
dart
final (:quotient, :remainder) = divMod(17, 5);           // 解构(命名 record 用 :字段 模式)
divMod(17, 5) == (quotient: 3, remainder: 2);            // true,结构相等
项 C Go Dart
多返回值 出参指针 int divmod(int,int,int*,int*) 原生 (int, int) record ({int quotient, int remainder})
相等性 逐字段手写比较 结构体 ==(若全字段可比较) 自动逐字段比较
可变性 struct 可变 struct 可变 不可变(final 字段)
解构 手写 多赋值 q, r := divmod() 模式解构 final (q, r) = ...

注意:命名 record 解构要用 final (:quotient, :remainder) = ...(冒号写在字段名左边),写成 final (q, r) = ... 会编译报错——这也是本章示例第一次编译时的报错之一。位置 record 才能用 final (lo, hi) = ...。

1.9 静态类型与 dynamic

dart
String inferredTypeOf(int x) => 'x 的类型是 ${x.runtimeType}';  // int
String dynamicDispatch(dynamic value) => value.toString();       // 运行时才检查
  • var / final 推断出的类型是静态钉死的,之后不能换类型(和 C 的 auto、Go 的 := 一样)。
  • dynamic 关闭静态检查,相当于 C 的 void* + 强转、Go 的 any,但连方法名都不检查,写错了要运行到那一行才炸(NoSuchMethodError)。生产代码里应避免,需要"任意类型"时用 Object。

本项目所有示例的 analysis_options.yaml 都开了严格模式:

yaml
analyzer:
  language:
    strict-casts: true
    strict-inference: true
    strict-raw-types: true

这三项分别禁止:隐式 downcast、推断失败时退化成 dynamic、使用裸泛型(List 而非 List<int>)。它们的定位相当于给 C 开 -Wall -Wextra -Werror。

1.10 运行与验证

bash
cd examples/ch01-dart-basics
dart pub get
dart analyze        # 期望:No issues found!
dart test           # 期望:All tests passed! (25 个用例)
dart run            # 真实输出见下

dart run 的真实输出(节选):

text
--- 1. 数字 ---
int 溢出回绕: -9223372036854775808
7 ~/ 2 = 3, 7 / 2 = 3.5
-7 % 3 = 2 (C/Go 给 -1)
7 % -3 = 1 · 7.remainder(-3) = 1

--- 2. 字符串 ---
Hello, Gopher (31 next year)
raw: C:\temp\new\file.txt
"👋 Dart" code units = 7, runes = 6

--- 5. 函数作为值 / 闭包 ---
applyOp(add, 3, 4) = 7
accumulator: 11, 13, 16
循环变量捕获: [0, 1, 2]

--- 6. record ---
divMod(17, 5) = (3, 2)
minMax([3,1,4,1,5]) = (1, 5)

踩坑记录(真实发生):本章示例第一次编译时出现了三个错误,全部是 C/Go 惯性:

  1. 0b1010 —— Dart 没有二进制字面量;
  2. final (q, r) = divMod(...) —— 命名 record 必须用 :字段 解构;
  3. 函数返回类型写成 (int, String) 但返回 (lo, hi) —— record 的类型是结构化的,字段类型必须精确匹配。

这正是本章想说明的事:Dart 的类型系统比 C 严格得多,但比 Go 的接口更"结构",习惯之后编译器基本能替你拦住大部分 bug。

1.11 本章小结 + C/Go 对照清单

主题 C Go Dart 陷阱
数值类型 7 种整型 + 2 种浮点 10 种整型 + 2 种浮点 int(64 位) + double + num 没有无符号数
整除 / 取模 / 截断;% 跟随被除数 同 C ~/ 截断;% 永非负 要 C 语义用 remainder()
溢出 UB 回绕 回绕 Web 上 int 变 53 位(本项目不涉及)
字符串 char*,可写 不可变字节串 不可变 UTF-16 length 是码元数
常量 #define / const const(字面量) const(编译期)/ final(运行期一次) final 只冻结引用
函数参数 只能位置传参 只能位置传参 命名 / 可选 / 默认值 没有重载
函数值 函数指针 func 值 函数类型 + tear-off —
多返回值 出参指针 原生多返回值 record + 模式解构 命名 record 用 :字段
类型宽松 隐式转换 显式转换 严格,dynamic 才放开 开 strict-* 当 -Werror

给 C/Go 老兵的三句话:

  1. 数值上最需要重建直觉的是 / 返回 double 和 % 永远非负;
  2. 类型上最需要重建直觉的是 == 默认是引用相等([1,2] == [1,2] 为 false),结构相等要靠 record 或手写/生成 ==;
  3. 工程上最需要重建直觉的是 编译期检查无处不在:没有隐式转换、没有重载、没有裸泛型、null 受类型系统约束(ch03)。

下一章我们不再写 print,而是把第一个 Flutter 窗口跑起来——main()、runApp()、Widget、热重载,一个 App 该有的骨架。