Dart 起步:值与变量、函数、基础类型、const/final
第 1 章 · Dart 起步:值与变量、函数、基础类型、const/final
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() 说起
// 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) |
要注意的两个差异:
- 没有
printf。print()直接接受任意对象,调用其toString()。格式化用字符串插值,编译器会检查类型——这是比printf("%d", "str")少一整类 bug 的地方。 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 的数值模型极其简洁,只有三个类型:
// 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 的真实结果):
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:有符号溢出是 UB,编译器可以任意优化
int64_t f(void) { return INT64_MAX + 1; } // UB!
int64_t m = -7 % 3; // -1
// Go:回绕,符号跟随被除数
func f() int64 { return math.MaxInt64 + 1 } // -9223372036854775808
m := -7 % 3 // -1
// Dart:回绕 + 欧几里得取模
int f() => 9223372036854775807 + 1; // -9223372036854775808
int m() => (-7) % 3; // 2
int cStyle() => (-7).remainder(3); // -1
1.4 字符串:不可变的 UTF-16 码元序列
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 过来最容易糊涂的一块,必须一次讲清。
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(仅限字面量) |
两条实测行为值得记住:
// 内容相同的两个 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 没有函数重载。同一个名字只能有一个函数。取而代之的是可选命名参数:
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
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(记录) 是值语义的元组,按字段结构相等:
({int quotient, int remainder}) divMod(int a, int b) =>
(quotient: a ~/ b, remainder: a % b);
(int, int) minMax(List<int> xs) { /* ... */ return (lo, hi); }
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
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 都开了严格模式:
analyzer:
language:
strict-casts: true
strict-inference: true
strict-raw-types: true
这三项分别禁止:隐式 downcast、推断失败时退化成 dynamic、使用裸泛型(List 而非 List<int>)。它们的定位相当于给 C 开 -Wall -Wextra -Werror。
1.10 运行与验证
cd examples/ch01-dart-basics
dart pub get
dart analyze # 期望:No issues found!
dart test # 期望:All tests passed! (25 个用例)
dart run # 真实输出见下
dart run 的真实输出(节选):
--- 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 惯性:
0b1010—— Dart 没有二进制字面量;final (q, r) = divMod(...)—— 命名 record 必须用:字段解构;- 函数返回类型写成
(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 老兵的三句话:
- 数值上最需要重建直觉的是
/返回 double 和%永远非负; - 类型上最需要重建直觉的是
==默认是引用相等([1,2] == [1,2]为false),结构相等要靠 record 或手写/生成==; - 工程上最需要重建直觉的是 编译期检查无处不在:没有隐式转换、没有重载、没有裸泛型、
null受类型系统约束(ch03)。
下一章我们不再写 print,而是把第一个 Flutter 窗口跑起来——main()、runApp()、Widget、热重载,一个 App 该有的骨架。