Dart 教程
Dart 教程
Dart 是 Google 开发的编程语言,用于构建高性能的移动端(Flutter)、Web 和桌面应用,以简洁语法与强类型著称。
本教程包含
- 基础篇:简介、环境搭建、第一个程序、基础语法、变量与数据类型
- 进阶篇:控制流、集合、函数、类与对象、泛型、异常、异步编程
- 应用篇:库与导入、面向对象特性、Flutter 集成、工具链
为什么学习 Dart
- Flutter 的唯一开发语言(跨平台 UI 框架)
- JIT 热重载 + AOT 编译,开发快运行快
- 同时支持移动/Web/桌面/服务端
- 类型安全、语法现代
Dart 的特点
强类型(可推断)
一切皆对象
基于类的 OOP
异步: Future/Stream
空安全(null safety)
集合: List/Set/MapDart 简介
Dart 简介
Dart 于 2011 年由 Google 发布,2018 年随着 Flutter 发布而流行,2021 年起支持空安全。
核心特性
- 类型安全:编译期发现类型错误
- 空安全:变量默认非空,避免空指针
- 多范式:面向对象 + 函数式特性
- 双编译器:JIT(开发热重载)/ AOT(发布高性能)
- 单线程 + 隔离:Isolate 并发模型
Hello World
void main() {
print("Hello, Dart!");
}运行方式
# 脚本运行
dart run hello.dart
# 或创建项目
dart create my_app
cd my_app
dart run
# 测试
dart test应用领域
Flutter 移动/桌面/Web 应用
服务器端(Server-side, shelf/dart_frog)
命令行工具
Web 前端(编译为 JS)DartPad(在线体验)
dartpad.dev 无需安装,浏览器即可编写运行Dart 开发环境搭建
Dart 开发环境搭建
搭建 Dart 开发环境:SDK 安装 + IDE 配置。
1. 安装 Dart SDK
# 方式一: 独立安装
brew install dart # macOS
sudo apt install dart # Debian/Ubuntu(需官方源)
# 方式二: 随 Flutter 安装(推荐)
# 安装 Flutter SDK 后自带 Dart
flutter --version2. 验证安装
dart --version
# Dart SDK version: 3.x.x3. IDE 配置
VS Code:
安装 "Dart" 和 "Flutter" 扩展
支持语法高亮、自动补全、调试、热重载
Android Studio / IntelliJ:
安装 Dart 与 Flutter 插件4. 创建项目
# 控制台项目
dart create console_app
dart create -t console my_console
# Flutter 项目
flutter create my_flutter_app
# 模板类型
console 控制台
web Web 应用
package Dart 包/库5. 常用命令
dart run 运行
dart test 运行测试
dart analyze 静态分析
dart format . 代码格式化
dart pub get 安装依赖第一个 Dart 程序
第一个 Dart 程序
编写并运行第一个 Dart 程序,熟悉基本结构。
Hello World
// main.dart
void main() {
print("Hello, Dart!");
print(1 + 2);
print("计算: ${3 * 4}");
}
// 输出:
// Hello, Dart!
// 3
// 计算: 12运行
dart run main.dart程序结构解析
void main() {
// 程序入口,必须有 main
}
// void: 无返回值
// 花括号: 代码块
// print(): 输出到控制台
// // 单行注释 /* */ 多行注释 /// 文档注释变量与输出
void main() {
var name = "老王";
int age = 30;
double height = 1.75;
bool isStudent = false;
print("$name $age 岁");
print("身高: ${height}m");
}字符串插值
var city = "北京";
print("我在 $city"); // 简单变量
print("总价: ${2 + 3} 元"); // 表达式用 ${}运行方式
dart run <文件名>.dart
或进入交互模式: dart 后直接输入表达式(旧版 dart repl)Dart 基础语法
Dart 基础语法
Dart 语法接近 C/Java/JavaScript,同时融合了现代语言特性。
语句与分号
每条语句以分号 ; 结束
var x = 10;
print(x);注释
// 单行注释
/* 多行
注释 */
/// 文档注释(用于生成文档)
/// 对函数/类写文档注释是良好习惯变量声明
var name = "Dart"; // 类型推断
final city = "北京"; // 常量(运行期确定)
const pi = 3.14159; // 编译期常量
String lang = "Dart"; // 显式类型
int count = 10;
double price = 9.9;
bool ok = true;
// final vs const
final t = DateTime.now(); // OK: 运行期赋值
// const t2 = DateTime.now(); // 错误: 必须编译期常量动态类型(dynamic)
dynamic x = 10;
x = "hello"; // 可改类型(慎用,失去类型检查)
var y = 10; // var 推断后类型固定
// y = "hello"; // 错误: y 是 int标识符规则
字母/数字/下划线/$,不能数字开头
变量驼峰: myVariable
类名大写: MyClass
常量: 小驼峰或 SCREAMING_CASE关键字
class/extends/implements/void/main
var/final/const/if/else/for/while/return
(与多数语言相似)Dart 变量与数据类型
Dart 变量与数据类型
深入 Dart 的核心类型:数字、字符串、布尔与集合。
数字类型
int a = 10; // 整数
double b = 3.14; // 浮点
num c = 42; // 数字父类型(可存 int 或 double)
num d = 3.5;
print(a.isEven); // true 偶数判断
print(b.round()); // 3 四舍五入
print(a.abs()); // 绝对值
// 转换
int x = int.parse("42");
double y = double.parse("3.14");
String s = 42.toString();字符串
String s1 = "双引号";
String s2 = '单引号';
String s3 = """多行
字符串"""; // 三双引号
String s4 = '''也可以'''; // 三单引号
var name = "Dart";
print("Hello $name"); // 插值
print(r"原始字符串
"); // raw 字符串(不转义)布尔
bool isDone = true;
bool isOk = false;
// 条件必须为布尔(与 JS 不同,无真值转换)
if (isDone) { print("完成"); }
// if (1) {...} 错误: 1 不是布尔集合
List nums = [1, 2, 3];
Set tags = {"a", "b"};
Map scores = {"math": 90};
// 推断写法
var list = [1, 2, 3];
var map = {"name": "老王", "age": 30}; 空安全
String name = "ok"; // 非空类型
String? nullable = null; // 可空类型(带?)
// 访问可空变量
print(nullable?.length); // null(安全访问)
print(nullable!.length); // 强制非空(危险,慎用)
if (nullable != null) { ... } // 判空后安全使用Dart 控制流
Dart 控制流
条件判断与循环控制,和主流语言类似。
if-else
int score = 85;
if (score >= 90) {
print("优秀");
} else if (score >= 60) {
print("及格");
} else {
print("不及格");
}switch-case
String grade = "B";
switch (grade) {
case "A":
print("优秀");
break;
case "B":
case "C":
print("良好");
break;
default:
print("其他");
}
// Dart 3 支持 switch 表达式
var result = switch (grade) {
"A" => "优秀",
"B" || "C" => "良好",
_ => "其他",
};for 循环
for (int i = 0; i < 5; i++) {
print(i);
}
// 遍历集合
var list = [1, 2, 3];
for (var item in list) {
print(item);
}
// 带索引
for (var i = 0; i < list.length; i++) {
print("$i: ${list[i]}");
}while / do-while
int n = 0;
while (n < 3) {
print(n);
n++;
}
int m = 0;
do {
print(m); // 至少执行一次
m++;
} while (m < 3);break / continue
for (var i = 0; i < 10; i++) {
if (i == 3) continue; // 跳过
if (i == 7) break; // 终止
print(i);
}集合的 forEach / map
list.forEach((item) => print(item));
var doubled = list.map((x) => x * 2).toList();
var evens = list.where((x) => x.isEven).toList();Dart 集合类型
Dart 集合类型
List、Set、Map 三大集合的完整使用。
List(列表,有序)
var list = [1, 2, 3];
list.add(4); // 追加
list.addAll([5, 6]); // 批量
list.remove(3); // 删值
list.removeAt(0); // 删索引
list[0] = 10; // 修改
print(list.length); // 长度
print(list.contains(2));// 包含
// 遍历
list.forEach(print);
for (var x in list) { print(x); }
// 操作
list.reversed // 反转(迭代器)
list.sublist(1, 3) // 子列表
list.sort() // 排序Set(集合,去重无序)
var tags = {"dart", "flutter"};
tags.add("ai");
tags.remove("dart");
print(tags.contains("flutter")); // true
print(tags.length);
// 集合运算
var a = {1, 2, 3};
var b = {2, 3, 4};
print(a.union(b)); // {1,2,3,4}
print(a.intersection(b)); // {2,3}
print(a.difference(b)); // {1} Map(键值对)
var scores = {"math": 90, "english": 85};
scores["chinese"] = 95; // 新增/修改
scores.remove("math"); // 删除
print(scores["english"]); // 85
print(scores.containsKey("math")); // false
// 遍历
scores.forEach((k, v) => print("$k: $v"));
for (var key in scores.keys) { print(key); }
for (var value in scores.values) { print(value); }常用构造
var filled = List.filled(5, 0); // [0,0,0,0,0]
var generated = List.generate(5, (i) => i * i); // [0,1,4,9,16]
var spread = [...list1, ...list2]; // 展开合并
var growable = []; // 空列表 Dart 函数
Dart 函数
Dart 函数是对象,支持箭头语法、可选参数、闭包等高阶特性。
基本函数
int add(int a, int b) {
return a + b;
}
// 箭头语法(单表达式)
int multiply(int a, int b) => a * b;
// 调用
print(add(1, 2)); // 3可选参数
// 命名参数(推荐,可读性好)
void greet({required String name, int age = 18, String? city}) {
print("你好 $name, $age 岁");
if (city != null) print("来自 $city");
}
greet(name: "老王");
greet(name: "小李", age: 25, city: "北京");
// 位置可选参数
void info(String name, [int age = 0, String? email]) { ... }
info("老王");
info("老王", 30);匿名函数与箭头
var list = [1, 2, 3];
// 匿名函数
list.forEach((item) {
print(item * 2);
});
// 箭头
list.forEach((item) => print(item));
// 赋值给变量
var square = (int x) => x * x;
print(square(5)); // 25闭包
Function makeCounter() {
int count = 0;
return () => ++count; // 捕获 count
}
var counter = makeCounter();
print(counter()); // 1
print(counter()); // 2
print(counter()); // 3高阶函数
int apply(int x, int Function(int) f) => f(x);
print(apply(5, (x) => x * 2)); // 10
// 返回函数
Function addN(int n) => (int x) => x + n;
var add5 = addN(5);
print(add5(10)); // 15可选返回值与命名函数
String? findName(List names, String target) {
for (var n in names) {
if (n == target) return n;
}
return null; // 可空返回
} Dart 类与对象
Dart 类与对象
Dart 是纯面向对象语言,一切皆对象,类为基础单元。
定义类
class Person {
String name; // 属性
int age;
// 构造函数(简写语法)
Person(this.name, this.age);
// 方法
void greet() {
print("你好,我是 $name, $age 岁");
}
}
void main() {
var p = Person("老王", 30);
p.greet();
print(p.name); // 老王
}命名构造函数
class Person {
String name;
int age;
Person(this.name, this.age);
// 命名构造函数
Person.baby(this.name) : age = 0;
// 重定向构造函数
Person.anonymous() : this("匿名", 0);
}
var baby = Person.baby("小宝宝");
print(baby.age); // 0初始化列表
class Point {
final double x, y;
double distance;
Point(this.x, this.y) : distance = (x * x + y * y).sqrt() {
// 构造体(初始化列表之后执行)
}
}Getter / Setter
class Circle {
double radius;
Circle(this.radius);
// getter
double get area => 3.14159 * radius * radius;
// setter
set diameter(double d) => radius = d / 2;
}
var c = Circle(2);
print(c.area); // 12.57...
c.diameter = 10; // 设置直径
print(c.radius); // 5静态成员
class MathUtil {
static const pi = 3.14159;
static int square(int x) => x * x;
}
print(MathUtil.pi); // 3.14159
print(MathUtil.square(4)); // 16级联操作(..)
var p = Person("老王", 30)
..age = 31
..greet();
// 连续调用同一对象的方法/属性Dart 泛型
Dart 泛型
泛型让代码适用于多种类型,同时保持类型安全。
泛型集合
List nums = [1, 2, 3];
List names = ["a", "b"];
Map scores = {"math": 90};
Set doubles = {1.5, 2.5};
// 不写泛型则默认 dynamic
var anything = [1, "a", true]; // List 泛型函数
T first(List items) {
return items[0];
}
print(first([1, 2, 3])); // 1
print(first(["a", "b"])); // a
print(first([1, 2])); // 显式指定 泛型类
class Box {
T value;
Box(this.value);
T getValue() => value;
}
var intBox = Box(42);
var stringBox = Box("hello");
print(intBox.getValue()); // 42
print(stringBox.getValue()); // hello 泛型约束
// T 必须是 num 的子类
T maxOf(T a, T b) {
return a > b ? a : b;
}
print(maxOf(3, 5)); // 5
print(maxOf(3.5, 2.1)); // 3.5
// maxOf("a", "b"); // 错误: String 不是 num 泛型与类型检查
var box = Box(10);
print(box is Box); // true
// 泛型类型在运行时保留(与 Java 不同)
var b1 = Box(1);
var b2 = Box("x");
print(b1 is Box); // true
print(b2 is Box); // false Dart 面向对象特性
Dart 面向对象特性
继承、抽象类、接口、混入等面向对象高级特性。
继承
class Animal {
String name;
Animal(this.name);
void speak() => print("$name 发出声音");
}
class Dog extends Animal {
Dog(String name) : super(name);
@override
void speak() => print("$name 汪汪叫");
}
var dog = Dog("旺财");
dog.speak(); // 旺财 汪汪叫抽象类
abstract class Shape {
double area(); // 抽象方法(无实现)
String describe() => "面积: ${area()}"; // 普通方法
}
class Circle extends Shape {
final double radius;
Circle(this.radius);
@override
double area() => 3.14159 * radius * radius;
}
// Shape s = Shape(); // 错误: 抽象类不能实例化
var c = Circle(2);
print(c.describe());implements(实现接口)
class Printable {
void printInfo() {}
}
class User implements Printable {
String name;
User(this.name);
@override
void printInfo() => print("用户: $name");
}
// Dart 类可隐式作为接口
var u = User("老王");
u.printInfo();混入(mixin, with)
mixin Flyable {
void fly() => print("飞行中...");
}
mixin Swimmable {
void swim() => print("游泳中...");
}
class Bird with Flyable {}
class Duck with Flyable, Swimmable {} // 多混入
var duck = Duck();
duck.fly();
duck.swim();运算符重载
class Vector {
final double x, y;
Vector(this.x, this.y);
Vector operator +(Vector other) =>
Vector(x + other.x, y + other.y);
@override
String toString() => "($x, $y)";
}
var v1 = Vector(1, 2);
var v2 = Vector(3, 4);
print(v1 + v2); // (4.0, 6.0)Dart 异常处理
Dart 异常处理
异常处理保证程序健壮性,优雅处理错误。
抛出异常
void checkAge(int age) {
if (age < 0) {
throw ArgumentError("年龄不能为负");
}
if (age > 150) {
throw StateError("年龄不合法");
}
}
// 自定义异常
class BusinessException implements Exception {
final String message;
BusinessException(this.message);
@override
String toString() => "业务异常: $message";
}捕获异常
try {
int.parse("abc");
} on FormatException catch (e) {
print("格式错误: $e");
} on Exception catch (e) {
print("其他异常: $e");
} catch (e, stackTrace) {
print("未知错误: $e");
print(stackTrace);
} finally {
print("无论是否异常都会执行");
}安全转换与断言
// 转换失败返回 null
int? parsed = int.tryParse("abc");
print(parsed); // null
// assert(仅调试模式生效)
void setScore(int s) {
assert(s >= 0 && s <= 100, "分数范围 0-100");
// ...
}测试异常
// 测试中验证抛异常
// expect(() => checkAge(-1), throwsArgumentError);最佳实践
1. 用户输入错误: 返回值或 Option 风格
2. 系统错误: 抛异常
3. 捕获后必须处理(至少记录日志)
4. 不要捕获所有异常而不处理Dart 异步编程
Dart 异步编程
Future 和 Stream 是 Dart 异步编程的核心,支撑 Flutter 的非阻塞 UI。
Future(一次性异步结果)
// 模拟异步任务
Future fetchData() async {
await Future.delayed(Duration(seconds: 1));
return "数据加载完成";
}
void main() async {
// await 等待结果
String data = await fetchData();
print(data);
// then 链式
fetchData().then((d) => print(d)).catchError((e) => print(e));
} async / await
Future addAsync(int a, int b) async {
await Future.delayed(Duration(milliseconds: 100));
return a + b;
}
void main() async {
var result = await addAsync(3, 4);
print(result); // 7
// 并行执行(Future.wait)
var results = await Future.wait([
addAsync(1, 2),
addAsync(3, 4),
]);
print(results); // [3, 7]
} Stream(多次异步结果)
// 生成数据流
Stream countStream(int max) async* {
for (int i = 1; i <= max; i++) {
await Future.delayed(Duration(seconds: 1));
yield i; // 逐个产出
}
}
void main() async {
// 监听流
await for (var n in countStream(3)) {
print(n); // 每秒输出 1 2 3
}
// 或 listen
countStream(2).listen((n) => print("收到: $n"));
} 错误处理
Future risky() async {
try {
await Future.error("出错了");
} catch (e) {
print("捕获: $e");
}
}
// Stream 错误
stream.listen(
(data) => print(data),
onError: (e) => print("流错误: $e"),
onDone: () => print("流结束"),
); 在 Flutter 中使用
// FutureBuilder 异步构建 UI
FutureBuilder(
future: fetchData(),
builder: (context, snapshot) {
if (snapshot.hasData) return Text(snapshot.data!);
return CircularProgressIndicator(); // 加载中
},
); Dart 库与导入
Dart 库与导入
使用内置库、第三方包与自定义库组织代码。
导入库
// 核心库
import "dart:math";
import "dart:convert";
import "dart:io";
// 自定义库
import "utils/math_utils.dart";
// 包库(第三方)
import "package:http/http.dart";
// 前缀与部分导入
import "dart:math" as math;
import "package:foo/bar.dart" show Bar, baz;
import "package:foo/baz.dart" hide Baz;常用内置库
import "dart:math";
print(pow(2, 10)); // 1024
print(sqrt(16)); // 4.0
print(max(3, 7)); // 7
print(Random().nextInt(100)); // 随机数
import "dart:convert";
var json = jsonEncode({"name": "老王"});
var map = jsonDecode(json);创建自定义库
// utils/calculator.dart
library calculator;
int add(int a, int b) => a + b;
int sub(int a, int b) => a - b;
// 使用
import "utils/calculator.dart";
print(add(1, 2)); // 3pub 包管理
# pubspec.yaml 声明依赖
dependencies:
http: ^1.1.0
# 安装
dart pub get
# 添加
dart pub add http
# 使用
import "package:http/http.dart" as http;
Future main() async {
var resp = await http.get(Uri.parse("https://example.com"));
print(resp.statusCode);
} 常用第三方包
http HTTP 请求
dio HTTP 高级封装
path 路径处理
uuid UUID 生成
intl 国际化/格式化
equatable 对象相等性
provider Flutter 状态管理Dart 常用内置库
Dart 常用内置库
深入最常用的几个内置库:math、convert、io、collection。
dart:math
import "dart:math";
pow(2, 8) // 256
sqrt(81) // 9.0
sin(pi / 2) // 1.0
max(1, 9) // 9
min(1, 9) // 1
Random().nextInt(100) // 0-99
Random().nextDouble() // 0.0-1.0
Random().nextBool() // true/falsedart:convert
import "dart:convert";
// JSON
var jsonStr = jsonEncode({"name": "老王", "age": 30});
var obj = jsonDecode(jsonStr) as Map;
// Base64
var encoded = base64Encode(utf8.encode("hello"));
var decoded = utf8.decode(base64Decode(encoded));
// UTF-8
var bytes = utf8.encode("中文");
print(utf8.decode(bytes)); // 中文 dart:io(文件系统)
import "dart:io";
// 读文件
final file = File("data.txt");
if (await file.exists()) {
String content = await file.readAsString();
print(content);
}
// 写文件
await File("out.txt").writeAsString("内容");
// 目录
var dir = Directory("mydir");
if (!await dir.exists()) await dir.create();
final entries = await dir.list().toList();
// 环境变量与命令行参数
print(Platform.environment["PATH"]);
print(Platform.operatingSystem); // macos/windows/linuxdart:collection
import "dart:collection";
// 队列
final queue = Queue();
queue.add(1);
queue.removeFirst();
// 链表/哈希映射等
final map = HashMap(); dart:async(定时器)
import "dart:async";
// 延迟执行
Timer(Duration(seconds: 2), () => print("2秒后"));
// 周期执行
Timer.periodic(Duration(seconds: 1), (t) {
print("每秒执行");
if (条件) t.cancel();
});Dart Isolate 并发
Dart Isolate 并发
Dart 用 Isolate(隔离区)实现并发:每个 Isolate 有独立内存,通过消息通信。
什么是 Isolate
单线程模型: 主 Isolate 处理事件循环
并发: 创建多个 Isolate 并行执行
隔离: 各 Isolate 独立内存,不共享变量
通信: 通过消息(SendPort/ReceivePort)
类似: 进程(而非线程)模型创建 Isolate
import "dart:isolate";
void worker(SendPort sendPort) {
// 在隔离区中执行(独立内存)
sendPort.send("来自 worker 的消息");
}
void main() async {
final receivePort = ReceivePort();
// 启动 Isolate
await Isolate.spawn(worker, receivePort.sendPort);
// 接收消息
final msg = await receivePort.first;
print(msg); // 来自 worker 的消息
}compute(Flutter 常用)
// Flutter 中用 compute 简化(在 Flutter 中 import)
import "package:flutter/foundation.dart";
int heavyWork(int n) {
var sum = 0;
for (var i = 0; i < n; i++) sum += i;
return sum;
}
// 在后台 Isolate 执行,不阻塞 UI
Future result = compute(heavyWork, 1000000); Isolate 之间传数据
// 双向通信: 两个端口
void worker(SendPort mainPort) {
final workerPort = ReceivePort();
mainPort.send(workerPort.sendPort); // 回传自己的端口
workerPort.listen((msg) {
print("worker 收到: $msg");
mainPort.send("收到确认");
});
}何时使用
CPU 密集计算(JSON 解析、图像处理)
复杂加密/压缩
大数据处理
(避免阻塞 UI 线程)
I/O 操作(文件/网络)本身异步,无需 Isolate限制
无法共享内存(需消息复制)
大数据传递开销大
Isolate 创建有成本(复用池)
UI 只能主 Isolate 操作Dart 与 Flutter
Dart 与 Flutter
Dart 是 Flutter 的开发语言,理解两者关系是学习 Flutter 的前提。
Flutter 是什么
Flutter = Google 跨平台 UI 框架
用 Dart 编写
一套代码 → iOS/Android/Web/桌面
Dart 是 Flutter 的唯一语言
(Dart 语言特性支撑 Flutter 的响应式 UI)Flutter 中 Dart 的应用
// Widget(组件)就是 Dart 类
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
home: Scaffold(
appBar: AppBar(title: Text("标题")),
body: Center(child: Text("内容")),
),
);
}
}热重载(开发体验)
JIT 编译支持热重载:
修改代码 → 保存 → 界面秒级更新(保留状态)
发布时 AOT 编译:
高性能、启动快、包体小状态管理与异步
// setState 更新界面
class Counter extends StatefulWidget {
@override
State createState() => _CounterState();
}
class _CounterState extends State {
int count = 0;
void _increment() {
setState(() => count++);
}
@override
Widget build(BuildContext context) {
return ElevatedButton(
onPressed: _increment,
child: Text("点击: $count"),
);
}
} 学习路径
1. Dart 语法(本教程)
2. Flutter Widget 体系
3. 布局与组件
4. 状态管理(Provider/Riverpod/Bloc)
5. 网络与数据持久化
6. 打包发布工具
flutter doctor 环境检查
flutter create 创建项目
flutter run 运行
flutter build 构建发布
flutter analyze 静态分析Dart 工具链
Dart 工具链
掌握 Dart 开发工具链:格式化、分析、测试、调试。
dart format(格式化)
dart format lib/ # 格式化目录
dart format main.dart # 格式化文件
dart format --output=none --set-exit-if-changed . # CI 检查dart analyze(静态分析)
dart analyze
# 检查代码问题: 类型错误、未使用变量、lint 警告
# analysis_options.yaml 配置规则
linter:
rules:
- prefer_const_constructors
- avoid_printdart test(测试)
// test/calculator_test.dart
import "package:test/test.dart";
int add(int a, int b) => a + b;
void main() {
group("加法", () {
test("正整数", () {
expect(add(1, 2), 3);
});
test("负数", () {
expect(add(-1, 1), 0);
});
});
}
// 运行
dart test调试
VS Code:
设置断点 → F5 调试
Debug Console 查看变量
命令行:
dart run --enable-vm-service main.dart
打开 devtools 调试 UIdart pub(包管理)
dart pub get 安装依赖
dart pub add x 添加依赖
dart pub upgrade 升级依赖
dart pub outdated 查看过期依赖
dart pub publish 发布包(pub.dev)项目管理工具
melos 多包仓库管理
very_good_cli 项目脚手架
Dart Code Metrics 代码质量指标Dart 最佳实践
Dart 最佳实践
编写高质量 Dart 代码的推荐实践。
命名规范
类/类型: UpperCamelCase(MyClass)
变量/函数: lowerCamelCase(myVariable)
常量: lowerCamelCase 或 SCREAMING_CASE
私有: 前缀下划线(_privateVar)
文件: snake_case(my_file.dart)
导入别名: 小写(library as lib)空安全实践
// 使用可空类型表达可能为空
String? findName() => null;
// 安全访问
var name = findName();
print(name?.length); // null
print(name ?? "默认值"); // 默认值
// late 延迟初始化
late String config;
config = loadConfig();类型优先
// 避免 dynamic
dynamic x = "str"; // 不推荐
String x = "str"; // 推荐: 类型明确
// 使用泛型集合
List names = []; // 而非 List names = [] 不可变优先
class Config {
final String host; // final 不可变
final int port;
const Config(this.host, this.port); // const 构造
}
// 数据类
class User {
final String name;
const User(this.name);
@override
bool operator ==(Object other) =>
other is User && other.name == name;
@override
int get hashCode => name.hashCode;
}其他实践
1. 集合操作优先函数式(map/filter)
2. 异常: 不要吞掉错误
3. 异步: 用 await 而非大量 then
4. 性能: 复用对象、避免不必要重建
5. 依赖注入替代全局状态
6. 注释: 解释为什么,而非是什么Dart 总结与资源
Dart 总结与资源
恭喜完成 Dart 教程!回顾知识体系并给出后续资源。
知识体系回顾
- 基础:环境搭建、第一个程序、变量与数据类型、控制流
- 数据:List/Set/Map 集合、泛型
- 函数:参数、匿名函数、闭包、高阶函数
- OOP:类、继承、抽象、接口、mixin、运算符重载
- 健壮性:异常处理、空安全、断言
- 异步:Future、Stream、async/await、Isolate
- 工程:库、pub 包、工具链、测试、最佳实践
下一步学习路线
- Flutter 入门:Widget、布局、状态管理
- Dart 服务端:shelf / dart_frog 构建 API
- Dart Web:编译为 JavaScript 的 Web 开发
- 深入语言:扩展、宏(Dart 3)、模式匹配
学习资源
官方文档: dart.dev
语言之旅: dart.dev/language
DartPad: dartpad.dev(在线练习)
中文社区: Dart 中文文档 / Flutter 中文社区
示例: github.com/dart-lang/samples实践建议
1. 用 DartPad 每天练 30 分钟语法
2. 做一个命令行小工具(文件整理/爬虫)
3. 用 Flutter 复刻一个常用 App 界面
4. 阅读优秀开源 Flutter 项目源码
5. 坚持 dart analyze 零警告Dart 语法简洁现代,配合 Flutter 生态,是当前跨平台开发的优选语言。掌握本教程,你已具备继续深入 Flutter 开发的坚实基础。
第 1 / 21 节