Dart语言快速入门 - 元素码农

发布时间: 2025-03-22 22:12

↑

# Dart语言快速入门

## 什么是Dart？

Dart是由Google开发的一种面向对象的编程语言，它是Flutter框架的基础语言。Dart具有以下特点：

- 强类型语言，但具有类型推断功能
- 支持JIT（即时编译）和AOT（预先编译）
- 单线程执行模型，但支持异步编程
- 丰富的内置库和包管理系统

## 变量与数据类型

### 变量声明

```dart
// 使用var让Dart自动推断类型
var name = 'Bob';

// 显式声明类型
String name = 'Bob';

// 使用final声明不可变变量
final age = 30;

// 使用const声明编译时常量
const pi = 3.14159;
```

### 基本数据类型

```dart
// 数字类型
int age = 30;
double price = 99.99;
num value = 42; // 可以是int或double

// 字符串
String name = 'Bob';
String message = "Hello, $name"; // 字符串插值

// 布尔值
bool isValid = true;

// List（数组）
List<String> fruits = ['apple', 'banana', 'orange'];
var numbers = [1, 2, 3]; // 类型推断为List<int>

// Map（字典）
Map<String, int> scores = {
  'Bob': 90,
  'Alice': 95,
};

// Set（集合）
Set<int> numbers = {1, 2, 3};
```

## 函数

### 函数声明与使用

```dart
// 基本函数声明
int add(int a, int b) {
  return a + b;
}

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

// 可选参数
String greet(String name, [String? title]) {
  if (title != null) {
    return 'Hello, $title $name';
  }
  return 'Hello, $name';
}

// 命名参数
void printPerson({required String name, int? age}) {
  print('Name: $name, Age: ${age ?? "Unknown"}');
}

// 函数作为参数
void processNumbers(List<int> numbers, int Function(int) processor) {
  for (var number in numbers) {
    print(processor(number));
  }
}
```

## 类与对象

### 类的定义

```dart
class Person {
  // 属性
  String name;
  int age;
  
  // 构造函数
  Person(this.name, this.age);
  
  // 命名构造函数
  Person.guest() {
    name = 'Guest';
    age = 0;
  }
  
  // 方法
  void introduce() {
    print('My name is $name, I am $age years old.');
  }
}

// 使用类
void main() {
  var person = Person('Bob', 30);
  person.introduce();
  
  var guest = Person.guest();
  guest.introduce();
}
```

### 继承

```dart
class Employee extends Person {
  String company;
  
  Employee(String name, int age, this.company) : super(name, age);
  
  @override
  void introduce() {
    super.introduce();
    print('I work at $company.');
  }
}
```

## 异步编程

### Future和async/await

```dart
// 异步函数
Future<String> fetchUserData() async {
  // 模拟网络请求
  await Future.delayed(Duration(seconds: 2));
  return 'User Data';
}

// 使用async/await
void main() async {
  print('Fetching user data...');
  String data = await fetchUserData();
  print('Data received: $data');
}

// 错误处理
Future<void> fetchData() async {
  try {
    String data = await fetchUserData();
    print(data);
  } catch (e) {
    print('Error: $e');
  }
}
```

### Stream

```dart
Stream<int> countStream(int max) async* {
  for (int i = 1; i <= max; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

void main() async {
  // 监听Stream
  await for (int number in countStream(5)) {
    print(number);
  }
}
```

## 空安全

Dart 2.12版本引入了空安全特性：

```dart
// 可空类型
String? nullableName; // 可以为null
String nonNullableName = 'Bob'; // 不能为null

// 空值检查
void printName(String? name) {
  // 使用?.
  print(name?.toUpperCase());
  
  // 使用!.
  print(name!.toUpperCase()); // 如果name为null会抛出异常
  
  // 使用??运算符
  String displayName = name ?? 'Unknown';
  print(displayName);
}
```

## 集合操作

### List操作

```dart
// 创建和操作List
var fruits = ['apple', 'banana', 'orange'];

// 添加元素
fruits.add('grape');

// 删除元素
fruits.remove('banana');

// 查找元素
var index = fruits.indexOf('apple');

// 遍历List
for (var fruit in fruits) {
  print(fruit);
}

// 使用map转换元素
var upperFruits = fruits.map((f) => f.toUpperCase()).toList();

// 使用where过滤元素
var longFruits = fruits.where((f) => f.length > 5).toList();
```

### Map操作

```dart
// 创建和操作Map
var scores = {
  'Bob': 90,
  'Alice': 95,
};

// 添加或更新元素
scores['Charlie'] = 85;

// 获取所有键或值
var names = scores.keys.toList();
var allScores = scores.values.toList();

// 遍历Map
scores.forEach((name, score) {
  print('$name: $score');
});
```

## 最佳实践

1. **使用类型推断**：在局部变量声明时，优先使用`var`而不是显式类型声明。

2. **命名规范**：
   - 类名使用大驼峰命名法（UpperCamelCase）
   - 变量和函数名使用小驼峰命名法（lowerCamelCase）
   - 常量使用下划线分隔的大写字母（UPPER_SNAKE_CASE）

3. **空安全**：
   - 尽可能避免使用非空断言操作符（!）
   - 合理使用空值检查和默认值

4. **异步编程**：
   - 优先使用async/await而不是直接使用Future
   - 正确处理异步操作中的错误

5. **代码组织**：
   - 相关的代码放在同一个文件中
   - 使用适当的注释说明复杂逻辑
   - 遵循DRY（Don't Repeat Yourself）原则

## 总结

本文介绍了Dart语言的核心概念和基本用法，包括：

1. 变量和数据类型
2. 函数定义和使用
3. 类和对象
4. 异步编程
5. 空安全特性
6. 集合操作

掌握这些基础知识将帮助你更好地进行Flutter开发。建议：

- 多练习和实践这些概念
- 阅读Dart官方文档深入学习
- 在实际项目中逐步应用这些知识
- 关注Dart语言的新特性和最佳实践