Dart 学习笔记

下面是对原文的重写与扩展，结合了 Dart 初学者所需的知识点，按照作者的写作习惯进行整理并补充了遗漏内容。

---

第一章 Dart 入门基础

Dart 是一种开源的编程语言，具备高易用性、高生产力，能够在多个平台上快速运行。它适用于客户端开发（如 Flutter）和服务器端开发，特别是在跨平台开发中具有很强的优势。

Hello World

第一个 Dart 程序就是打印 “Hello, World!”。可以通过以下代码实现：

void main() {
  print("Hello, World!");
}

变量与常量

Dart 是一种强类型语言，但同时支持类型推导。常见的变量声明方式有 var、final 和 const。

变量声明

var 用于声明一个变量，编译器会根据赋值自动推断类型：

var name = "张三";  // 编译器推断为 String 类型

常量声明

使用 const 或 final 来声明常量：

• const：常量的值在编译时就必须确定，并且不可更改。
• final：常量的值在运行时可以初始化，但只能被赋值一次。

const pi = 3.14;  // 编译时常量
final nowTime = DateTime.now();  // 运行时常量

变量引用与字符串连接

变量引用

Dart 提供了两种方式来引用变量：

var name = "张三";
print("Hello, $name"); // 使用 $ 符号插入变量值
print("Hello, ${name}"); // 使用 ${} 插入复杂表达式

字符串连接

Dart 也支持通过 + 操作符连接字符串：

print("你好 " + "张三");

数据类型基础

Dart 支持多种数据类型，常见的有：

数据类型	描述	示例
整型	int	int a = 10;
数值型	num	num b = 5;
字符串型	String	String name = "张三";
浮点型	double	double height = 5.9;
布尔型	bool	bool isReady = true;
集合/数组	List<T>	List<int> numbers = [1, 2, 3];
集合(Set)	Set<T>	Set<String> colors = {"blue", "red"};
键值对	Map<K, T>	Map<String, String> map = {"key": "value"};

布尔类型

布尔类型只有两个值：true 和 false。可以通过 is 关键字检查一个变量是否为布尔类型：

var test = true;
print(test is bool);  // 输出 true

数值类型 (Number)

Dart 有两种数值类型：

• int：整数类型，不能超过 64 位。
• double：浮点数类型。

常见的数值操作：

var a = 10;
int b = 20;
double c = 10.5;

print(a + b);  // 加法
print(c - b);  // 减法
print(a * c);  // 乘法
print(b / c);  // 除法
print(a ~/ b); // 整数除法

数字的转换

可以将字符串转换为数字：

print(int.parse("1"));      // 转换为整数
print(double.parse("3.14")); // 转换为浮点数

常见的数字方法

print(10.isEven);  // 判断是否为偶数
print(3.abs());    // 获取绝对值
print(1.8.floor()); // 向下取整
print(2.6.truncate()); // 去除小数部分

字符串类型

Dart 的字符串可以使用单引号或双引号定义，也可以使用三引号进行多行字符串定义：

String str = "Hello";
String name = '张三';
String multilineStr = '''This is 
a multiline
string''';

常见的字符串方法：

print(str.length);          // 获取字符串长度
print(str[0]);              // 获取字符
print(str.contains("H"));   // 检查是否包含某个子串
print(str.toLowerCase());   // 转小写
print(str.toUpperCase());   // 转大写

列表 (List)

Dart 的 List 类型支持存储有序集合。你可以使用 [] 创建列表，或者使用 List<T> 创建泛型列表：

var list = [1, 2, 3, 4, 5]; // 第一种声明方式
List<int> list1 = [10, 20, 30];  // 第二种声明方式

常见的列表操作：

list.add(6);          // 添加元素
list.insert(0, 0);    // 插入元素
list.remove(3);       // 移除元素
print(list.length);   // 获取列表长度

集合 (Set)

Set 是一个无序且不允许重复元素的集合：

var set = {"apple", "banana", "orange"};
Set<String> set1 = {"blue", "green"};

常见的集合操作：

set.add("grape");    // 添加元素
set.remove("banana"); // 移除元素

映射 (Map)

Map 是一个键值对的集合，每个键必须唯一：

var map = {"name": "张三", "age": 18, "address": "Beijing"};
Map<String, String> map2 = {"key1": "value1", "key2": "value2"};

常见的映射操作：

map["phone"] = "123456";   // 添加或更新键值对
map.remove("address");     // 删除键值对

方法与参数

Dart 支持函数声明，支持位置参数、命名参数以及可选参数。

方法声明

int add(int a, int b) {
  return a + b;
}
print(add(2, 3));  // 输出 5

可选命名参数

void getPerson(String name, {int? age, String? city}) {
  print("Name: $name, Age: $age, City: $city");
}
getPerson("张三", age: 28, city: "Beijing");

可选位置参数

void greet(String name, [int? age, String? city]) {
  print("Hello $name, Age: $age, City: $city");
}
greet("张三", 28, "Beijing");

闭包

闭包允许函数访问其外部作用域的变量。在 Dart 中，闭包是通过返回一个函数来实现的：

void main() {
  var counter = 0;
  var increment = () {
    counter++;
    print(counter);
  };
  increment();
  increment();
}

类与对象

Dart 是面向对象的，所有的代码都是在类中定义的。类用 class 关键字定义，实例化对象时可以使用 new 关键字（虽然 Dart 允许省略 new）。

class Person {
  String name;
  int age;

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

void main() {
  var person = Person("张三", 28);
  print(person.name);
}

命名构造函数

class Student {
  String name;
  int age;

  Student(this.name, this.age);  // 默认构造函数

  // 命名构造函数
  Student.now() {
    print("当前时间是 ${DateTime.now()}");
  }
}

void main() {
  var student = Student.now();
}

identical 函数

identical 用于检查两个对象是否为同一个实例。特别地，常量构造函数创建的对象会共享内存地址。

void main() {
  var obj1 = const Object();
  var obj2 = const Object();
  print(identical(obj1, obj2));  // 输出 true，因为它们是同一个实例
}

---

第二章 高级教程

异常处理 (try-catch)

Dart 支持使用 try-catch 语句进行异常处理。你可以通过 on 捕获特定类型的异常，或使用 finally 来执行最终清理操作。

void main() {
  try {
    int result = 10 ~/ 0; // 故意引发一个异常
  } catch (e) {
    print("捕获异常：$e");
  } finally {
    print("不管发生什么，finally 块都会被执行");
  }
}

异步编程

Dart 提供了 Future 和 async-await 来处理异步操作。

Future

Future 表示一个异步计算的结果，可以使用 .then() 或 async-await 来处理。

Future<int> calculateSum() async {
  return await Future.delayed(Duration(seconds: 2), () => 5 + 10);
}

void main() async {
  var sum = await calculateSum();
  print("异步计算结果：$sum");
}

async 和 await

async 标记一个方法是异步的，而 await 用来等待一个异步操作的完成。

Future<void> fetchData() async {
  print("开始获取数据...");
  await Future.delayed(Duration(seconds: 3));
  print("数据获取成功！");
}

void main() async {
  await fetchData();
}

I/O 操作

Dart 提供了强大的 I/O 库来处理文件、网络和其他输入输出操作。

文件操作

Dart 通过 dart:io 库提供了文件操作的支持。

import 'dart:io';

void main() async {
  // 写文件
  var file = File('example.txt');
  await file.writeAsString('Hello, Dart!');

  // 读文件
  var contents = await file.readAsString();
  print(contents); // 输出：Hello, Dart!
}

网络请求

Dart 使用 http 包来进行 HTTP 请求。你可以用它来发送 GET 或 POST 请求。

import 'package:http/http.dart' as http;

Future<void> fetchData() async {
  var response = await http.get(Uri.parse('https://jsonplaceholder.typicode.com/posts'));
  if (response.statusCode == 200) {
    print("请求成功：${response.body}");
  } else {
    print("请求失败：${response.statusCode}");
  }
}

void main() async {
  await fetchData();
}