Dart 语言核心速查指南：从变量与运算符到枚举、Mixin、级联与异步的完整语言特性解析
【免费下载链接】reference面向开发者的技术速查清单（Cheat Sheets）集合，整理常见技术、工具与开发流程，帮助快速查阅关键信息，提高开发效率。项目地址: https://gitcode.com/GitHub_Trending/referen/reference
本篇基于 Quick Reference 技术速查清单仓库中的 Dart 备忘清单，系统梳理 Dart 语言从环境安装到高级特性的完整知识脉络。读完本文，你将掌握 Dart 的变量声明与不可变性体系（var/final/const/late）、全套运算符、控制流与集合、函数式写法与扩展函数、类/接口/继承/Mixin 的对象模型、增强型枚举、异常处理，以及基于Future的async/await异步编程模式，所有示例代码均可直接复制运行。
需要说明的是，本仓库（Quick Reference）是一个面向开发者的技术速查清单集合，文档均以 Markdown 形式维护在 docs 目录下，Dart 条目在 README.md 的"编程"分类中被收录，图标资源为 assets/dart.svg。Dart 也是 Flutter 速查清单 的底层语言，两份文档可以配套阅读。
Dart 环境安装与第一个程序
备忘清单的第一部分按三大平台给出了安装方式，以下完整保留原文档的实操命令。
各平台安装 Dart SDK
Windows 平台可直接通过 Chocolatey 安装：
C:\> choco install dart-sdk # WindowsLinux（Debian/Ubuntu）需要先完成一次性源配置，再安装 Dart：
$ sudo apt-get update $ sudo apt-get install apt-transport-https $ wget -qO- https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor -o /usr/share/keyrings/dart.gpg $ echo 'deb [signed-by=/usr/share/keyrings/dart.gpg arch=amd64] https://storage.googleapis.com/download.dartlang.org/linux/debian stable main' | sudo tee /etc/apt/sources.list.d/dart_stable.list配置完成后再安装 SDK：
$ sudo apt-get update $ sudo apt-get install dartmacOS 平台则通过 Homebrew：
$ brew tap dart-lang/dart $ brew install dart原文档提示，更完整的安装教程请参阅 Dart 官方文档（dart.dev）及 Dart 中文社区文档（dart.cn），安装前建议以官方最新说明为准。
hello.dart 与编译执行
Dart 程序的入口是每个应用程序都有的main()顶级函数：
// 应用执行开始的顶级函数 void main() { print("Hello World!"); // 打印到控制台 }安装完成后，可以通过dart compile exe将脚本编译为可执行文件并运行计时：
$ dart compile exe hellow.dart $ time ./hello.exe Hello World!变量声明与数据类型
变量：显式类型、类型推断与不可变性
Dart 提供三种变量声明方式，核心区别在于类型确定方式和是否允许重新赋值：
int x = 2; // 显式键入 var p = 5; // 类型推断 - 具有类型推断的通用var dynamic z = 8; // 变量可以采用任何类型 z = "cool"; // cool // 如果您从不打算更改变量，请使用 final 或 const final email = "temid@gmail.com"; // 与 var 相同，但不能重新分配 final String email = "temid@gmail.com"; // 你不能改变价值 const qty = 5; // 编译时常数要点归纳：
var由编译器推断类型，推断后类型固定，不允许重新赋值成其他类型；dynamic放弃静态类型检查，运行期可赋任何值，应谨慎使用；final变量只能赋值一次，且可以省略类型声明；const是编译期常量，值在编译时确定。
基础数据类型
// 整数，范围 -2^63 到 2^63 - 1 int age = 20; // 浮点数字 double height = 1.85; // 您还可以将变量声明为 num // x 可以同时具有 int 和 double 值 num x = 1; x += 2.5; print(x); // 打印: 3.5 String name = "Nicola"; bool isFavourite = true; bool isLoaded = false;值得注意的类型设计是num这个抽象数值类型：int与double都是num的子类型，num变量可以在整数值与浮点值之间切换，这在涉及金额、比率等混合运算场景非常实用。
注释
Dart 支持单行注释与文档注释两种形式：
// 这是一条正常的单行注释 /// 这是一个文档注释，用于文档库， /// 类及其成员。 IDE 和 dartdoc 等工具 /// doc 特别注释。 /* 也支持此类注释 *////开头的文档注释会被 dartdoc 工具采集生成 API 文档，是编写可复用库时的推荐实践。
字符串插值
Dart 的字符串可以用$直接嵌入变量，也可以用${}嵌入任意表达式：
// 可以对字符串类型使用单引号或双引号 var firstName = 'Nicola'; var lastName = "Tesla"; // 可以用 $ 将变量嵌入到字符串中 String fullName = "$firstName $lastName"; // 与 + 连接 var name = "Albert " + "Einstein"; String upperCase = '${firstName.toUpperCase()}'; print(upperCase); // 打印: NICOLA导入（Imports）
备忘清单完整覆盖了 Dart 的五种导入形态，这是组织大型 Dart 项目的基础：
// 导入核心库 import 'dart:math'; // 从外部包导入库 import 'package:test/test.dart'; // 导入文件 import 'path/to/my_other_file.dart'; // 指定前缀 import 'package:lib/lib.dart' as lib; lib.Element element = lib.Element(); // 仅导入 foo import 'package:lib1/lib1.dart' show foo; // 不导入 foo import 'package:lib2/lib2.dart' hide foo; // 延迟导入，仅在需要时导入 import 'package:greetings/hello.dart' deferred as hello;其中show/hide用于精确控制导入面（白名单/黑名单），as用于命名空间前缀避免冲突，deferred延迟导入则将库代码的加载推迟到首次使用时，适合按需加载的重型依赖。
运算符体系
算术运算符
print(2 + 3); // 打印: 5 print(2 - 3); // 打印: -1 print(2 * 3); // 打印: 6 print(5 / 2); // 打印: 2.5 - 结果是 double print(5 ~/ 2); // 打印: 2 - 结果是 int print(5 % 2); // 打印: 1 - 余 int a = 1, b;Dart 中/永远返回double，取整数商必须用~/，取模用%。
自增/自减运算符的前置与后置区别：
// 增 b = ++a; // 前增量 - 在 b 获得其值之前增加 a b = a++; // 后增量 - 在 b 获得它的值之后增加 a // 递 b = --a; // 前减量 - 在 b 获得它的值之前减少 a b = a--; // 后减量 - 在 b 获得它的值之后递减 a逻辑运算符
// !expr 反转表达式（将 false 更改为 true，反之亦然） // || 逻辑或 // && 逻辑与 bool isOutOfStock = false; int quantity = 3; if (!isOutOfStock && (quantity == 2 || quantity == 3)) { // ...Order the product... }等式和关系运算符
print(2 == 2); // 打印: true - 平等的 print(2 != 3); // 打印: true - 不相等 print(3 > 2); // 打印: true - 比...更棒 print(2 < 3); // 打印: true - 少于 print(3 >= 3); // 打印: true - 大于或等于 print(2 <= 3); // 打印: true - 小于或等于运算符优先级
// 括号可以提高可读性。 if ((n % i == 0) && (d % i == 0)) ... // 虽然难以阅读，但等效。 if (n % i == 0 && d % i == 0) ...位运算符与移位运算符
原文档以表格形式汇总了全部位运算能力，此处完整保留：
| 操作符 | 含义 | |:-|-| |&| 与（AND） | |\|| 或（OR） | |^| 异或（XOR） | |~expr| 一元位补码（0 变为 1；1 变为 0） | |<<| 左移 | |>>| 右移 | |>>>| 无符号右移 |
配合assert验证的示例：
final value = 0x22; final bitmask = 0x0f; // 与（AND） assert((value & bitmask) == 0x02); // 非与（AND NOT） assert((value & ~bitmask) == 0x20); // 或（OR） assert((value | bitmask) == 0x2f); // 异或（XOR） assert((value ^ bitmask) == 0x2d); assert((value << 4) == 0x220); // 左移 assert((value >> 4) == 0x02); // 右移级联表示法（..）
级联（..、?..）允许对同一对象连续执行一系列操作，省去临时变量，是 Flutter 中配置对象时极高频的写法：
var paint = Paint() ..color = Colors.black ..strokeCap = StrokeCap.round ..strokeWidth = 5.0;上例等价于：
var paint = Paint(); paint.color = Colors.black; paint.strokeCap = StrokeCap.round; paint.strokeWidth = 5.0;以?..开头可确保不会对该空对象进行任何级联操作，原文档给出的 Web 场景示例：
querySelector('#confirm') // 获取一个对象 ?..text = 'Confirm' // 使用它的成员 ..classes.add('important') ..onClick.listen((e) => { window.alert('Confirmed!') }) ..scrollIntoView();在"各种各样"章节中，原文档另给出了级联的日常用法对照：
// 允许您对同一对象进行一系列操作 // 而不是这样做 var user = User(); user.name = "Nicola"; user.email = "nicola@g.c"; user.age = 24; // 你可以这样做 var user = User() ..name = "Nicola" ..email = "nicola@g.c" ..age = 24;控制流
if 和 else if
if(age < 18){ print("Teen"); } else if( age > 18 && age <60){ print("Adult"); } else { print("Old"); }switch case
enum Pet {dog, cat} Pet myPet = Pet.dog; switch(myPet) { case Pet.dog: print('My Pet is Dog.'); break; case Pet.cat: print('My Pet is Cat.'); break; default: print('I don\'t have a Pet'); } // 打印: My Pet is Dog.三元操作符及其嵌套
int age = 20; String message = age >= 18 ? "成人" : "儿童"; print("年龄类别: $message"); // 输出: 年龄类别: 成人嵌套使用时需注意右侧结合性：
int x = 10; int y = 5; int result = x > y ? x : y > 0 ? y : 0; print("Result: $result"); // 输出: Result: 10循环结构
while循环在每次迭代之前检查条件，do-while则在执行循环体之后才验证条件，因此do-while循环体至少执行一次：
while (!dreamsAchieved) { workHard(); }do { workHard(); } while (!dreamsAchieved);for循环与for-in列表遍历：
for(int i=0; i< 10; i++){ print(i); } var numbers = [1,2,3]; // 列表的 for-in 循环 for(var number in numbers){ print(number); }集合（Collections）
Lists
// 有序的对象组 var list = [1, 2, 3]; print(list.length); //Print: 3 print(list[1]); //Print: 2 // 列表声明和初始化的其他方式 List<String> cities = <String>["New York", "Mumbai", "Tokyo"]; // 创建一个编译时常量的列表 const constantCities = const ["New York", "Mumbai", "Tokyo"];Maps
// 映射是关联键和值的对象 var person = Map<String, String>(); // 要初始化映射，请执行以下操作： person['firstName'] = 'Nicola'; person['lastName'] = 'Tesla'; print(person); // 打印: {firstName:Nicola, lastName:Tesla} print(person['lastName']); // 打印: Tesla var nobleGases = { // Key: Value 2: 'helium', 10: 'neon', 18: 'argon', };Sets
// Dart 中的集合是唯一项的无序集合 var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'}; // 创建一个空集 var names = <String>{}; Set<String> names = {}; // 这也有效 //var names = {}; // 创建映射，而不是集合最后一个注释点出了 Dart 的一个经典易错点：{}字面量默认创建的是Map而非Set，空集合必须显式标注类型参数或类型名。
函数
函数是一等对象
Dart 中的函数是对象并且有一个类型，因此可以赋值给变量、作为参数传递：
// dart 中的函数是对象并且有一个类型 int add(int a, int b){ return a+b; } // 函数可以分配给变量 int sum = add(2,3); // 回报：5 // 可以作为参数传递给其他函数 int totalSum = add(2, add(2,3)); // 返回：7箭头函数（=>）
只包含一个表达式的函数可以使用简写语法：
bool isFav(Product product) => favProductsList.contains(product);匿名（lambda）函数
// 没有名字的小单行函数 int add(a,b) => a+b; // lambda 函数大多作为参数传递给其他函数 const list = [ 'apples', 'bananas', 'oranges' ]; list.forEach( (item) => print('${list.indexOf(item)}: $item') ); // 打印: 0: apples 1: bananas 2: oranges扩展函数（Extension）
Extension 允许在不修改原类的前提下为其"追加"方法，这是 Dart 扩展标准类型能力（如给String加工具方法）的核心机制：
//extension 定义扩展名称 on 扩展类 extension StringExtension on String { //扩展方法 String capitalize() { if (isEmpty) { return this; } // 将字符串的首字母大写 String topStr = this[0].toUpperCase(); return '${topStr}${substring(1)}'; } } void main(List<String> args) { print("apple".capitalize()); // Print: Apple print("苹果apple".capitalize()); // Print: 苹果apple }原文档指出：该示例在不修改String类的前提下为其新增了capitalize方法。
运算符重载（Extension）
扩展函数还可以定义operator，让自定义类支持+等运算符运算：
class Money { final num amount; Money({required this.amount}); } // 利用扩展函数特性 extension MoneyOperatorExtension<T> on Money { // operator 重载运算符 Money operator +(Money elements) { Money newMoney = Money(amount: this.amount + elements.amount); return newMoney; } } void main(List<String> args) { // 怎么样？两个类加起来了 Money appleMoney = Money(amount: 10.0); Money cardMoney = Money(amount: 6.0); Money allMoney = cardMoney + appleMoney; print(allMoney.amount); //Print: 16.0 }类和对象
类与对象
class Cat { String name; // 方法 void voice(){ print("Meow"); } }// 类的实例 // 在 myCat 下面是 Cat 类的对象 void main(){ Cat myCat = Cat(); myCat.name = "Kitty"; myCat.voice(); // 打印: Meow }构造函数
通过this.name简化构造参数到字段的映射：
class Cat { String name; Cat(this.name); } void main(){ Cat myCat = Cat("Kitty"); print(myCat.name); // 打印: Kitty }抽象类
不能实例化的类，用于定义公共契约：
// 抽象类——不能实例化的类 // 这个类被声明为抽象的，因此不能被实例化 abstract class AbstractContainer { // 定义构造函数、字段、方法... void updateChildren(); // 抽象方法 }Getters 与 Setters
提供对对象属性的读写访问：
class Cat { String name; // getter String get catName { return name; } // setter void set catName(String name){ this.name = name; } }隐式接口与类扩展
隐式接口
Dart 中每个类都隐式定义了一个接口：公共成员进入接口，私有字段（_前缀）与构造函数不进入接口。实现类只需重写公共成员即可：
// 一个人。隐式接口包含 greet()。 class Person { // 在接口中，但仅在此库中可见。 final String _name; // 不在接口中，因为这是一个构造函数。 Person(this._name); // 在接口中 String greet(String who) => 'Hello, $who. I am $_name.'; } // Person 接口的实现。 class Impostor implements Person { String get _name => ''; String greet(String who) => 'Hi $who. Do you know who I am?'; } String greetBob(Person person) => person.greet('Bob'); void main() { print(greetBob(Person('Kathy'))); // 打印: Hello, Bob. I am Kathy. print(greetBob(Impostor())); // 打印: Hi Bob. Do you know who I am? }这段代码同时展示了依赖注入式的多态调用：greetBob只依赖Person类型，Impostor实例可以无缝替换。
类扩展（extends）
class Phone { void use(){ _call(); _sendMessage(); } } // 使用 extends 创建子类 class SmartPhone extends Phone { void use(){ // 使用 super 来引用超类 super.use(); _takePhotos(); _playGames(); } }枚举（Enum）
备忘清单中枚举内容最为详尽，分基础用法与增强型枚举两部分。原文档在"各种各样"章节也给出了枚举的概念定义：enum（"enumeration"的缩写）是一种特殊的数据类型，可使变量成为一组预定义的常量；枚举用于定义只能从一小组可能值中选择一个的变量，通过为这些值集提供有意义的名称，提高代码可读性并减少出错率。
定义与基本访问
enum Color { red, green, blue }枚举值像访问其他静态变量一样访问：
final favoriteColor = Color.blue; if (favoriteColor == Color.blue) { print('Your favorite color is blue!'); }每个枚举值都有一个索引获取器，返回其在声明中从零开始的位置：
assert(Color.red.index == 0); assert(Color.green.index == 1); assert(Color.blue.index == 2);通过values常量获取全部枚举值：
List<Color> colors = Color.values; assert(colors[2] == Color.blue);在switch中使用枚举时，若不处理所有枚举值会收到警告：
var aColor = Color.blue; switch (aColor) { case Color.red: print('Red as roses!'); break; case Color.green: print('Green as grass!'); break; default: // 没有这个，你会看到一个警告 print(aColor); // 'Color.blue' }使用.name属性获取枚举值名称：
print(Color.blue.name); // 'blue'增强型枚举
枚举可以携带构造参数、字段与 getter，下面是原文档声明的具有多个实例、实例变量、一个 getter 的增强型枚举：
// 简单定义一个枚举类型 enum PlanetType { terrestrial, gas, ice } // 定义一个行星复杂的枚举类型 enum Planet { mercury(planetType: PlanetType.terrestrial, moons: 0, hasRings: false), venus(planetType: PlanetType.terrestrial, moons: 0, hasRings: false), uranus(planetType: PlanetType.ice, moons: 27, hasRings: true), neptune(planetType: PlanetType.ice, moons: 14, hasRings: true); // 定义一个构造函数 const Planet({required this.planetType, required this.moons, required this.hasRings}); // 声明枚举类型中的变量 final PlanetType planetType; final int moons; final bool hasRings; // 实现枚举类型中的get 方法 bool get isGiant => planetType == PlanetType.gas || planetType == PlanetType.ice; } // 使用枚举类型 void main() { final yourPlanet = Planet.mercury; if (!yourPlanet.isGiant) { print('Your planet is not a "giant planet".'); } }枚举实战示例：交通灯
// 定义枚举类型 enum TrafficLight { red, yellow, green } // 根据交通灯状态打印消息的函数 void printTrafficLightMessage(TrafficLight light) { switch (light) { case TrafficLight.red: print('Stop!'); break; case TrafficLight.yellow: print('Get ready...'); break; case TrafficLight.green: print('Go!'); break; } } void main() { // 枚举类型的示例用法 TrafficLight currentLight = TrafficLight.green; // 打印当前交通灯状态的消息 printTrafficLightMessage(currentLight); }Mixin（混入）
Dart 中类只能单继承，Mixin提供了在不破坏单继承体系的前提下复用多个类中代码的方式。
定义与使用 Mixin
// 定义Mixin mixin Piloted { int astronauts = 1; void describeCrew() { print('Number of astronauts: $astronauts'); } }使用with关键字并在其后跟上 Mixin 类的名字来使用：
// 使用with将Piloted混入 class PilotedCraft extends Spacecraft with Piloted { // ··· }支持混入多个 Mixin，如果出现相同的方法，后混入的 Mixin 会覆盖前面的：
class Musician extends Performer with Musical { // ··· } // 混入多个Mixin class Maestro extends Person with Musical, Aggressive, Demented { Maestro(String maestroName) { name = maestroName; canConduct = true; } }用 on 限定 Mixin 的适用类
使用关键字on可以指定哪些类可以使用该 Mixin，比如MusicalPerformer只能被Musician类使用：
class Musician { // ... } // 现在MusicalPerformer 只能在 Musican及其子类中使用 mixin MusicalPerformer on Musician { // ... } class SingerDancer extends Musician with MusicalPerformer { // ... }异常处理
Throw 抛出异常
// 抛出 throws 或引发 raises 和异常 exception throw IntegerDivisionByZeroException(); // 你也可以抛出任意对象 throw "Product out of stock!";Catch 捕获异常
on子句按类型精确匹配异常，多个子句从上到下依次尝试：
try { int c = 3/0; print(c); } on IntegerDivisionByZeroException { // 一个特定的异常 print('Can not divide integer by 0.') } on Exception catch (e) { // 任何其他异常情况 print('Unknown exception: $e'); } catch (e) { // 没有指定类型，处理所有 print('Something really unknown: $e'); }Finally 保证清理
// 确保某些代码无论是否抛出异常都能运行 try { cookFood(); } catch (e) { print('Error: $e'); // 先处理异常 } finally { cleanKitchen(); // 然后清理 }Futures 与 async/await
Dart 用Future表示"未来才完成的值"，配合async/await关键字实现异步编程：
// 异步函数：它们在设置可能耗时的操作后返回 // async 和 await 关键字支持异步编程 Future<String> login() { String userName="Temidjoy"; return Future.delayed( Duration(seconds: 4), () => userName ); } // 异步 main() async { print('Authenticating please wait...'); String result = await login(); print(result); }要点：返回Future<T>的函数用await挂起当前协程直到值就绪，Future.delayed是延迟执行的典型构造，这一模式在 Flutter 中发起网络请求、读取文件等场景随处可见，可以结合本仓库的 Flutter 速查清单 继续阅读组件层用法。
空安全（Null Safety）与实用特性
Null 和 Null 感知运算符
int x; // 任何对象的初始值为 null // ?? 空感知运算符 x ??=6; // ??= 赋值运算符，仅当变量当前为 null 时才为其赋值 print(x); // 打印: 6 x ??=3; print(x); // 打印: 6 - 结果仍然是 6 print(null ?? 10); // 打印: 10。如果不为空，则显示左侧的值，否则返回右侧的值??与??=是空安全体系中最常用的两个运算符：前者取"非空左侧或右侧默认值"，后者是"仅当为 null 时赋值"的惰性初始化。
三元运算符作为表达式语句
// 条件 ? 条件如果为真 : 条件如果为假 bool isAvailable; isAvailable ? orderproduct() : addToFavourite();条件属性访问
userObject?.userName // 上面的代码片段等效于以下代码： (userObject != null) ? userObject.userName : null // 您可以将 ? 的多种用途链接起来。一起在一个表达式中 userObject?.userName?.toString() // 如果 userObject 或 userObject.userName 为 null，则前面的代码返回 null 并且从不调用 toString()?.的链式调用（null 感知的级联）确保链条中任一环为 null 时整体短路返回 null，避免空指针异常。
扩展运算符（...）
将多个值展开插入到集合中：
// 将多个值插入到集合中 var list = [1, 2, 3]; var list2 = [0, ...list]; print(list2.length); // 打印: 4延迟初始化（late）
// token 类型非空，但是不用立即赋值 late String token; void main(List<String> args) { /// print(token); /// 字段 "token "尚未初始化 /// 在初始化前调用就会报错 token = "tokenContent"; print(token); }late声明的变量跳过初始化时的空检查，在首次访问前必须赋值，否则抛出运行时错误。它常用于依赖注入场景——变量声明时依赖尚未就绪，无法当场初始化。
小结与延伸阅读
Dart 备忘清单 按"入门 → 操作符 → 控制流（条件/循环）→ 集合 → 函数 → 类与对象 → 隐式接口 → 枚举 → Mixin → 异常 → Futures → 各种各样"的脉络，覆盖了 Dart 语言日常开发所需的几乎全部语法点。从原文档的结构可以看出两个值得记忆的体系化设计：
- 不可变优先的类型系统：
var/final/const/late四种声明方式覆盖了从推断到编译期常量的完整不可变光谱； - 组合优于继承的对象模型：单继承（
extends）+ 隐式接口（implements）+ 能力混入（mixin ... with ... on）+ 类型扩展（extension），四者配合使 Dart 无需多重继承就能表达复杂的类型复用关系。
延伸阅读路径：
- 本仓库中与 Dart 强相关的另一份清单是 Flutter 速查清单，讲解组件、布局与状态管理，其代码基础正是本文的语言特性；
- 两份清单的收录情况与分类可参考仓库入口 README.md；
- 原文档"另见"部分推荐了 Dart 官方文档（dart.dev）与 Dart 中文社区文档（dart.cn），安装配置与语言规范的权威细节请以这两处为准。
【免费下载链接】reference面向开发者的技术速查清单（Cheat Sheets）集合，整理常见技术、工具与开发流程，帮助快速查阅关键信息，提高开发效率。项目地址: https://gitcode.com/GitHub_Trending/referen/reference
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
