当前位置：首页 > news >正文

Flutter - dart 语言从入门到精通 - 教程

news 2025/9/28 11:43:41

Flutter - dart 语言从入门到精通 - 教程

文章目录

- 一、Dart 简介
- 二、基础语法详解
- - 1. 变量与类型
  - - 声明方式：
    - 内置类型：
  - 2. 字符串与插值
  - 3. 控制流语句
  - 4. 函数（Function）
  - 5. 操作符
- 三、高级语法详解
- - 1. 空安全（Null Safety）
  - 2. 面向对象编程（OOP）
  - - 类与构造函数
    - 继承与多态
    - 抽象类与接口
    - Mixin（混入）——代码复用利器
  - 3. 泛型（Generics）
  - 4. 异步编程（Asynchronous）
  - - Future（单次异步结果）
    - Stream（持续数据流）
  - 5. Isolates（隔离区）——Dart 的并发模型
  - 6. 扩展方法（Extension Methods）
  - 7. 元数据（Metadata）
  - 8. 库与可见性
- 四、最佳实践建议
- 五、总结：Dart 语法核心亮点
- 学习资源

当然可以。以下是 Dart 语言的基础语法与高级语法的详细解析，适合从入门到深入理解 Dart 的核心特性。

一、Dart 简介

Dart 是由 Google 开发的面向对象、类 C 风格的编程语言，专为构建高性能、跨平台应用而设计。它是 Flutter 框架的官方语言，支持编译为原生代码（AOT）或 JIT（开发时热重载），适用于移动、Web、桌面和服务器端开发。

二、基础语法详解

1. 变量与类型

声明方式：

var name = 'Dart';           // 类型推断
final age = 25;               // 运行时常量（只能赋值一次）
const PI = 3.14;              // 编译时常量
dynamic x = 10;               // 可变类型，运行时可改变
Object y = 'hello';           // 顶级对象类型</code></pre>

⚠️ 推荐使用 final 和 const 提升性能和安全性。

内置类型：

int, double：数值
String：字符串（单/双引号）
bool：true / false
List：有序集合（数组）
Set：无序唯一集合
Map：键值对
Symbol：反射用
Null：空值

List&lt;int&gt; numbers = [1, 2, 3];
Set&lt;String&gt; names = {'Alice', 'Bob'};
Map&lt;String, int&gt; scores = {'math': 90, 'eng': 85};</code></pre>

2. 字符串与插值

String name = 'Tom';
String greeting = 'Hello, $name!';                    // 简单插值
String info = 'Age: ${age + 1}';                      // 表达式插值
String multiLine = '''
This is a
multi-line string.
''';

3. 控制流语句

// if-else
if (score &gt;= 60) {
print('Pass');
} else {
print('Fail');
}
// for 循环
for (int i = 0; i &lt; 3; i++) {
print(i);
}
// for-in（遍历集合）
for (var item in list) {
print(item);
}
// while / do-while
while (condition) { ... }
// switch-case（支持 String 和 int）
switch (color) {
case 'red':
print('Red');
break;
default:
print('Unknown');
}

4. 函数（Function）

// 普通函数
int add(int a, int b) {
return a + b;
}
// 箭头函数（单表达式）
int multiply(int a, int b) =&gt; a * b;
// 可选参数：位置可选（[]）、命名可选（{}）
void sayHello(String name, [String? title]) {
print('Hello $title $name');
}
void createUser({String name = 'Guest', int age = 18}) {
print('Name: $name, Age: $age');
}
// 默认参数
void connect({String host = 'localhost', int port = 8080}) { ... }

5. 操作符

操作符	说明
`??`	如果左边为 null，则返回右边
`??=`	左边为 null 时才赋值
`...`	Spread 操作符（展开列表）
`..`	级联操作符（链式调用）
`?.`	条件成员访问
`as`	类型断言

List&lt;int&gt; more = [0, ...list, 4];         // 展开
obj..name = 'Tom'..age = 20..save();       // 链式设置
String? name = user?.name;                 // 安全访问

三、高级语法详解

1. 空安全（Null Safety）

Dart 2.12+

所有变量默认不可为空，必须显式声明可空类型。

String name = 'Dart';        // 不可为空
String? nullableName = null; // 可为空
// 安全调用
nullableName?.length;
// 非空断言（慎用）
nullableName!.length;
// 条件赋值
String result = nullableName ?? 'default';
// late 关键字：延迟初始化（需确保不会提前访问）
late final String config = loadConfig();

2. 面向对象编程（OOP）

类与构造函数

class Person {
String name;
int age;
// 构造函数（语法糖）
Person(this.name, this.age);
// 命名构造函数
Person.adult(String name) : this(name, 18);
// 工厂构造函数（可返回子类或缓存实例）
factory Person.fromMap(Map&lt;String, dynamic&gt; map) {
return Person(map['name'], map['age']);
}
// 方法
void introduce() {
print('Hi, I am $name, $age years old.');
}
}

继承与多态

class Student extends Person {
String major;
Student(String name, int age, this.major) : super(name, age);
@override
void introduce() {
print('I study $major.');
}
}

抽象类与接口

abstract class Flyable {
void fly(); // 抽象方法
}
class Bird extends Person implements Flyable {
@override
void fly() {
print('Flying...');
}
}

Mixin（混入）——代码复用利器

mixin Singable {
void sing() {
print('Singing...');
}
}
class Musician extends Person with Singable {
// 同时拥有 Person 和 Singable 的能力
}

3. 泛型（Generics）

提高类型安全性和复用性。

// 泛型类
class Box&lt;T&gt; {
T content;
Box(this.content);
}
// 泛型方法
T firstElement&lt;T&gt;(List&lt;T&gt; list) =&gt; list[0];
// 使用
Box&lt;String&gt; stringBox = Box('Hello');
String first = firstElement(['a', 'b', 'c']);</code></pre>> 泛型还能用于限制类型：<pre style="background: none"><code class="language-dart" data-language="dart" identifier="d47820124a6d47a8a7b19452a64a0c60-12" index="12" total="19">class Cache&lt;T extends num&gt; { ... } // T 必须是 num 或其子类

4. 异步编程（Asynchronous）

Dart 使用 Future 和 Stream 处理异步操作。

Future（单次异步结果）

Future&lt;String&gt; fetchData() async {
await Future.delayed(Duration(seconds: 2));
return 'Data loaded';
}
void main() async {
try {
String data = await fetchData();
print(data);
} catch (e) {
print('Error: $e');
}
}

Stream（持续数据流）

Stream&lt;int&gt; countStream(int max) async* {
for (int i = 1; i &lt;= max; i++) {
await Future.delayed(Duration(seconds: 1));
yield i; // 发送数据
}
}
void listenStream() async {
await for (var num in countStream(5)) {
print(num);
}
}

5. Isolates（隔离区）——Dart 的并发模型

Dart 是单线程事件循环模型，通过 Isolates 实现并发（非共享内存）。

import 'dart:isolate';
void spawnFunction(SendPort sendPort) {
int result = 10 * 2;
sendPort.send(result);
}
void main() async {
ReceivePort receivePort = ReceivePort();
await Isolate.spawn(spawnFunction, receivePort.sendPort);
int result = await receivePort.first;
print('Result: $result');
}

6. 扩展方法（Extension Methods）

为现有类添加新方法，无需继承或修改源码。

extension StringExtensions on String {
bool get isEmail =&gt; this.contains('@');
String capitalize() =&gt; '${this[0].toUpperCase()}${this.substring(1)}';
}
// 使用
print('hello'.capitalize());     // Hello
print('a@b.com'.isEmail);        // true

7. 元数据（Metadata）

用于注解类、方法、变量。

@deprecated
void oldMethod() { ... }
@override
void build(BuildContext context) { ... }
// 自定义注解
class Todo {
final String who;
const Todo(this.who);
}
@Todo('Alice')
void featureA() { }

8. 库与可见性

使用 import 引入库
使用 part / part of 拆分文件
_ 开头标识私有成员

import 'package:http/http.dart' as http;
import 'my_utils.dart' hide privateHelper; // 隐藏某些符号
import 'config.dart' as config show API_URL; // 只导入部分
// 私有成员
String _privateField = 'internal';

四、最佳实践建议

项目	推荐做法
变量	多用 `final`，少用 `var` 和 `dynamic`
空值	合理使用 `?`, `??`, `?.`，避免 `!`
构造函数	使用命名构造和工厂构造提升可读性
异步	`async`/`await` 替代 `.then()` 更清晰
代码组织	使用 `mixin` 复用逻辑，避免多重继承
性能	多用 `const` 对象，减少运行时开销
格式化	使用 `dart format` 统一风格

五、总结：Dart 语法核心亮点

特性	说明
空安全	编译期预防空指针异常
级联操作符 `..`	链式调用，代码简洁
Mixin	强大的代码复用机制
扩展方法	安全增强已有类功能
Future/Stream	异步编程简洁高效
Isolates	安全并发，避免竞态
AOT/JIT 双编译	开发快，运行快