← 返回首页

Dart 3.6+ 语言基础

Dart 3.6 是 Flutter 3.28 的基础语言，带来了许多现代化特性。掌握 Dart 语言是学习 Flutter 的第一步。本教程将介绍 Dart 3.6+ 的核心概念和语法。

📚 Dart 学习路径

开始学习

↓

变量声明

↓

数据类型

↓

函数

↓

类和对象

↓

异步编程

↓

集合操作

↓

完成基础

提示：Dart 3.6+ 引入了 Records、Patterns、Switch 表达式、增强的类型推断等现代化特性，代码更加简洁和类型安全。

1. 变量声明

Dart 提供了多种声明变量的方式：

使用 var 声明
                        // 使用 var 自动推断类型
var name = 'Flutter';
var age = 5;

// name 的类型是 String
// age 的类型是 int
                    

显式指定类型
                        String language = 'Dart';
int version = 3;
bool isActive = true;
double pi = 3.14159;
                    

使用 dynamic 和 late
                        // dynamic 可以是任何类型
dynamic value = 100;
value = 'Hello';  // 可以重新赋值为不同类型

// late 延迟初始化
late String description;

void init() {
  description = '这是一个延迟初始化的变量';
}
                    

Records（Dart 3.0+ 新特性）
                        // 定义 Record
(String, int) userInfo = ('Alice', 25);
print(userInfo.$1); // Alice
print(userInfo.$2); // 25

// 命名 Record
({String name, int age}) namedUser = (name: 'Bob', age: 30);
print(namedUser.name); // Bob
print(namedUser.age); // 30

// 混合 Record
(String, int, {bool isActive}) mixedRecord = ('Charlie', 35, isActive: true);
print(mixedRecord.$1); // Charlie
print(mixedRecord.isActive); // true
                    

📊 变量声明方式对比

变量声明方式对比表
声明方式	特点	使用场景	示例
`var`	自动推断类型	类型明确且初始化	`var name = 'Flutter';`
`final`	只能赋值一次	不可变变量	`final name = 'Flutter';`
`const`	编译时常量	编译时常量	`const PI = 3.14;`
`dynamic`	任意类型	动态类型	`dynamic value = 100;`
`late`	延迟初始化	延迟赋值	`late String name;`
`Record`	组合多个值	数据传递	`(String, int) info = ('A', 25);`

2. 数据类型

Dart 的基本数据类型包括：

数值类型：int（整数）、double（浮点数）
字符串：String
布尔值：bool
列表：List
映射：Map
Runes：字符串中的 Unicode 字符
Symbols：程序中声明的操作符或标识符

📊 Dart 数据类型总结

Dart 数据类型对比表
类型	子类型	说明	示例
数值	int	64位整数	`int count = 10;`
数值	double	64位浮点数	`double price = 19.99;`
文本	String	字符串	`String name = 'Flutter';`
布尔	bool	真/假值	`bool isActive = true;`
集合	List	有序列表	`List nums = [1, 2, 3];`
集合	Map	键值对	`Map map = {'a': 1};`

数据类型示例
                        // 数值类型
int count = 10;
double price = 19.99;

// 字符串
String greeting = 'Hello, World!';
String multiline = '''
这是一个
多行字符串
''';

// 布尔值
bool isFlutter = true;
bool isNative = false;

// 列表
List fruits = ['Apple', 'Banana', 'Orange'];
List numbers = [1, 2, 3, 4, 5];

// 映射
Map scores = {
  'Alice': 95,
  'Bob': 87,
  'Charlie': 92
};
                    

3. 函数

Dart 中的函数是一等公民，可以作为参数传递，也可以作为返回值。

基本函数定义
                        // 基本函数
void sayHello() {
  print('Hello, Dart!');
}

// 带参数的函数
String greet(String name) {
  return 'Hello, $name!';
}

// 可选参数
void printInfo(String name, [int? age]) {
  print('Name: $name');
  if (age != null) {
    print('Age: $age');
  }
}

// 命名参数
void createUser({
  required String name,
  int age = 0,
  String email = ''
}) {
  print('Creating user: $name');
}

// 箭头函数（单行函数）
int add(int a, int b) => a + b;

// 使用函数
sayHello();
print(greet('Flutter'));
printInfo('Alice');
printInfo('Bob', 30);
createUser(name: 'Alice', age: 25);
print(add(5, 3));  // 输出: 8
                    

Patterns 和 Switch 表达式（Dart 3.0+ 新特性）
                        // Switch 表达式
String describe(int value) {
  return switch (value) {
    0 => '零',
    1 => '一',
    2 => '二',
    _ => '其他',
  };
}

// Pattern 匹配
String describeRecord((String, int) record) {
  return switch (record) {
    ('Alice', _) => '这是 Alice',
    (_, age) when age >= 18 => '成年人，年龄 $age',
    (_, age) => '未成年人，年龄 $age',
  };
}

// 模式匹配
String describeObject(Object obj) {
  return switch (obj) {
    String s when s.isEmpty => '空字符串',
    String s => '字符串: $s',
    int i when i > 0 => '正整数: $i',
    int i => '非正整数: $i',
    _ => '其他类型',
  };
}
                    

📊 Dart 函数类型对比

函数定义方式对比表
函数类型	语法	特点	使用场景
基本函数	`returnType name(params) { }`	标准函数定义	通用函数
可选参数	`[Type? name]`	可选位置参数	可选输入
命名参数	`{required Type name}`	命名参数	清晰参数名
箭头函数	`returnType name(params) => expr`	单行表达式	简单函数
匿名函数	`(params) { }`	无名函数	回调函数

4. 类和对象

Dart 是面向对象的语言，一切皆对象。

类定义
                        class Person {
  // 属性
  String name;
  int age;

  // 构造函数
  Person(this.name, this.age);

  // 命名构造函数
  Person.fromMap(Map map)
      : name = map['name'],
        age = map['age'];

  // 方法
  void introduce() {
    print('Hello, I am $name, $age years old.');
  }

  // getter
  bool get isAdult => age >= 18;

  // setter
  set age(int value) {
    if (value > 0) {
      age = value;
    }
  }
}

// 使用类
void main() {
  var person = Person('Alice', 25);
  person.introduce();

  var person2 = Person.fromMap({'name': 'Bob', 'age': 30});
  person2.introduce();

  print(person.isAdult);  // true
}
                    

5. 异步编程

Dart 提供了强大的异步编程支持。

Future 和 async/await
                        // 定义异步函数
Future fetchUserData() async {
  await Future.delayed(Duration(seconds: 2));
  return 'User Data Loaded';
}

// 使用 async/await
void loadData() async {
  print('Loading...');
  String data = await fetchUserData();
  print(data);
}

// Future.then 方式
void loadDataAlternative() {
  fetchUserData().then((data) {
    print(data);
  }).catchError((error) {
    print('Error: $error');
  });
}

// 并发执行多个 Future
Future loadMultipleData() async {
  var results = await Future.wait([
    fetchUserData(),
    fetchUserData(),
    fetchUserData()
  ]);
  print('Loaded ${results.length} items');
}
                    

Stream
                        // 创建 Stream
Stream numberStream() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

// 监听 Stream
void listenToStream() {
  numberStream().listen(
    (number) => print('Received: $number'),
    onError: (error) => print('Error: $error'),
    onDone: () => print('Stream completed')
  );
}
                    

6. 集合操作

Dart 提供了丰富的集合操作方法。

常用集合操作
                        void main() {
  List numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  // 映射
  var doubled = numbers.map((n) => n * 2).toList();
  print(doubled);  // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

  // 过滤
  var evenNumbers = numbers.where((n) => n % 2 == 0).toList();
  print(evenNumbers);  // [2, 4, 6, 8, 10]

  // 归约
  var sum = numbers.reduce((a, b) => a + b);
  print(sum);  // 55

  // 排序
  var sorted = numbers.reversed.toList();
  print(sorted);  // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

  // 查找
  var firstEven = numbers.firstWhere((n) => n % 2 == 0);
  print(firstEven);  // 2

  // 检查
  var hasLarge = numbers.any((n) => n > 8);
  print(hasLarge);  // true

  var allPositive = numbers.every((n) => n > 0);
  print(allPositive);  // true
}
                    

7. 异常处理

Dart 使用 try-catch 来处理异常。

异常处理示例
                        void main() {
  try {
    int result = divide(10, 0);
    print(result);
  } on IntegerDivisionByZeroException {
    print('Cannot divide by zero!');
  } catch (e, stackTrace) {
    print('Error: $e');
    print('Stack trace: $stackTrace');
  } finally {
    print('This always executes');
  }
}

int divide(int a, int b) {
  if (b == 0) {
    throw IntegerDivisionByZeroException();
  }
  return a ~/ b;
}
                    

注意：在 Flutter 开发中，异步错误通常通过 Future 的 catchError 方法处理，而不是使用传统的 try-catch。

8. 扩展方法

Dart 2.7+ 支持扩展方法，可以为现有类型添加功能。

扩展示例
                        // 为 String 扩展方法
extension StringExtensions on String {
  bool get isEmail {
    return this.contains('@');
  }

  String capitalize() {
    return this[0].toUpperCase() + this.substring(1);
  }
}

void main() {
  String email = 'user@example.com';
  print(email.isEmail);  // true

  String name = 'dart';
  print(name.capitalize());  // Dart
}
                    

9. 最佳实践

使用 const 创建编译时常量
优先使用类型推断（var）而非显式类型
使用 final 声明不会改变的变量
为函数添加返回类型注解
使用命名参数提高代码可读性
在异步操作中使用 try-catch 处理错误
使用 Records 简化数据传递
使用 Patterns 和 Switch 表达式简化条件逻辑

下一步：掌握 Dart 基础后，继续学习 Widget 基础。

← 返回教程列表 Widget 基础 →