个人主页：ujainu

引言

如果你既关注Flutter的跨平台灵动，也好奇HarmonyOS的全场景生态，那Dart就是你打通这两大技术体系的‘通用钥匙’。这门由谷歌打造的语言，既在Flutter里承担着从UI渲染到业务逻辑的核心角色，又凭借静态类型、AOT编译等特性，完美适配HarmonyOS对性能和多设备协同的要求。今天我们就从最基础的语法开始拆解，帮你快速建立Dart的知识框架，为后续深入两大平台开发筑牢根基。”

1.环境需要

为适配后续 Flutter + HarmonyOS 集成，Windows 系统仅需完成以下配置：

配置 Dart SDK

1.官网下载 Windows 版 Dart SDK（zip 格式），解压至 D:\dart-sdk

2.系统环境变量「Path」新增 D:\dart-sdk\bin（你的存放路径）；

3.查看安装成果：终端执行 dart --version，输出版本号即成功。

dart --version

2.安装 Trae 工具

1.下载 Windows 版 Trae 并安装（路径避中文 / 空格）访问 ：

https://www.trae.cn

在 Trae 插件市场搜「Dart」安装插件，重启生效。

3. 变量和常量声明

3.1变量声明（var）

var 自动推导变量类型，声明后可修改值，但类型固定：

void main() {
  // 声明并初始化，自动推导为String类型
  var platform = "HarmonyOS";
  // 可修改值（同类型）
  platform = "Flutter + HarmonyOS";
  
  var version = 4.2; // 自动推导为double类型
  // 错误：类型固定，不能赋值字符串
  // version = "4.2";
}

3.2 常量声明

（1）final：运行时常量
值初始化后不可改，适用于鸿蒙设备参数、Flutter 固定配置（运行时确定的值）：

// 鸿蒙设备型号（运行时获取，不可改）
final String deviceModel = "HarmonyOS Phone";
// 错误：final常量不可重新赋值
// deviceModel = "Tablet";

（2）const：编译时常量
值编译时确定，适用于固定常量（如版本号、适配标识），性能优于 final：

// Flutter + 鸿蒙适配标识（编译时确定）
const int dartVersion = 3;
const bool isHarmonyAdapt = true;
// 错误：const需编译时确定值，不可用变量赋值
// const String temp = platform;

4. 字符串、布尔、数字类型

4.1 数字类型（int/double/num）

num 是 int 和 double 的父类型，三者的转换是 Dart 数字处理的核心，开发中常用于尺寸计算、数据格式化等场景：

void main() {
  // 1. 基础声明
  int a = 10;        // 整数
  double b = 20.5;   // 浮点数
  num c = 30;        // num可接收int/double类型值
  num d = 40.8;

  // 2. 核心转换
  // int → double（直接调用toDouble()）
  double aToDouble = a.toDouble(); // 结果：10.0
  
  // double → int（两种常用方式）
  int bToInt1 = b.toInt();        // 直接截断小数，结果：20
  int bToInt2 = b.round();        // 四舍五入，结果：21
  
  // num → int/double（需先判断类型，避免报错）
  int cToInt = c.toInt();         // num(30)→int，结果：30
  double dToDouble = d.toDouble();// num(40.8)→double，结果：40.8
}

4.2 布尔类型（bool）

仅支持 true/false 两个值，无隐式转换，常用于判断转换条件：

bool isInt = a is int; // 判断是否为int类型，结果：true
bool isDouble = b is double; // 结果：true

4.3 字符串类型（String）

补充数字与字符串的互转（开发中高频场景）：

// 数字 → 字符串
String aStr = a.toString(); // int→String，结果："10"
String bStr = b.toStringAsFixed(1); // double保留1位小数转字符串，结果："20.5"

// 字符串 → 数字
int strToInt = int.parse("5"); // 结果：5
double strToDouble = double.parse("8.9"); // 结果：8.9

5. 列表和字典类型

5.1 列表（List）

有序集合，核心操作示例：

void main() {
  List<String> fruits = ["苹果", "香蕉", "橙子"];

  // 新增
  fruits.add("葡萄"); // 单个添加
  fruits.addAll(["草莓", "芒果"]); // 批量添加
  
  // 删除
  fruits.remove("香蕉"); // 删除指定内容
  fruits.removeLast(); // 删除最后一个元素
  fruits.removeRange(1, 3); // 删除索引1-2（含头不含尾）
  
  // 遍历/筛选/判断
  fruits.forEach((i) => print("水果：$i")); // 遍历
  bool allHasWord = fruits.every((i) => i.contains("果")); // 全量判断
  List<String> filterList = fruits.where((i) => i.contains("草")).toList(); // 筛选
  
  // 属性
  int len = fruits.length; // 长度
  String first = fruits.first; // 首个元素
  String last = fruits.last; // 最后一个元素
  bool empty = fruits.isEmpty; // 判空
}

5.2 字典（Map）

操作实例如下：

void main() {
  Map<String, dynamic> user = {
    "name": "张三",
    "age": 20,
    "gender": "男"
  };

  // 新增/批量新增
  user["phone"] = "123456"; // 单个添加键值对
  user.addAll({"email": "test@163.com", "isVip": false}); // 批量添加

  // 删除
  user.remove("age"); // 删除指定key的键值对
  user.removeWhere((key, value) => key == "gender"); // 按条件删除
  user.clear(); // 清空所有键值对（补充高频操作）

  // 遍历/筛选/判断
  user.forEach((key, value) => print("$key: $value")); // 遍历
  // 所有value是否为字符串（全量判断）
  bool allIsStr = user.values.every((v) => v is String); 
  // 筛选key包含"e"的键值对
  Map<String, dynamic> filterMap = Map.fromEntries(
    user.entries.where((e) => e.key.contains("e"))
  );

  // 属性
  int len = user.length; // 长度
  bool empty = user.isEmpty; // 判空
  bool hasKey = user.containsKey("name"); // 是否包含指定key
  bool hasValue = user.containsValue("张三"); // 是否包含指定value
  dynamic firstValue = user.values.first; // 首个value（无序，仅取第一个）
  dynamic lastValue = user.values.last; // 最后一个value（无序，仅取最后一个）
}

6. 算数、赋值、比较、逻辑运算符

6.1 算数运算符

用于数值计算，核心运算符及示例：

void main() {
  int a = 10, b = 3;
  print(a + b); // 加法，结果：13
  print(a - b); // 减法，结果：7
  print(a * b); // 乘法，结果：30
  print(a / b); // 除法（返回浮点数），结果：3.333...
  print(a ~/ b); // 整除（返回整数），结果：3
  print(a % b); // 取余，结果：1
  print(++a); // 自增（先加后用），结果：11
  print(b--); // 自减（先用后减），结果：3
}

6.2 赋值运算符

用于给变量赋值，基础赋值 = 结合算数运算符可简化写法：

void main() {
  int x = 8;
  x += 2; // 等价于 x = x + 2，结果：10
  x -= 3; // 等价于 x = x - 3，结果：7
  x *= 2; // 等价于 x = x * 2，结果：14
  x /= 2; // 等价于 x = x / 2，结果：7.0
  x %= 3; // 等价于 x = x % 3，结果：1.0
}

6.3 比较运算符

用于判断两个值的关系，返回布尔值（true/false），是条件判断的核心：

void main() {
  int m = 5, n = 5;
  print(m == n); // 等于，结果：true
  print(m != n); // 不等于，结果：false
  print(m > n); // 大于，结果：false
  print(m < n); // 小于，结果：false
  print(m >= n); // 大于等于，结果：true
  print(m <= n); // 小于等于，结果：true
}

6.4 逻辑运算符

用于组合多个布尔条件，返回布尔值，常用在多条件判断场景：

void main() {
  bool isAdult = true, hasId = false;
  print(isAdult && hasId); // 逻辑与（都为true才true），结果：false
  print(isAdult || hasId); // 逻辑或（一个为true就true），结果：true
  print(!isAdult); // 逻辑非（取反），结果：false
}

7. if 分支和三元运算符

7.1 if 分支

支持 if、if-else、if-else if-else 多分支结构，条件表达式必须返回布尔值：

void main() {
  int score = 85;

  // 单分支
  if (score >= 60) {
    print("及格");
  }

  // 双分支
  if (score >= 90) {
    print("优秀");
  } else {
    print("非优秀");
  }

  // 多分支
  if (score >= 90) {
    print("优秀");
  } else if (score >= 80) {
    print("良好");
  } else if (score >= 60) {
    print("及格");
  } else {
    print("不及格");
  }
}

7.2 三元运算符

语法：条件表达式 ? 表达式1 : 表达式2，条件为 true 执行表达式 1，否则执行表达式 2，简化简单的 if-else 逻辑：

void main() {
  int age = 18;
  // 基础用法：判断是否成年
  String result = age >= 18 ? "成年" : "未成年";
  print(result); // 结果：成年

  // 嵌套用法（慎用，避免可读性差）
  int score = 75;
  String level = score >= 90 ? "优秀" : (score >= 60 ? "及格" : "不及格");
  print(level); // 结果：及格
}

8. switch 和 case

8.1 基础用法

语法：switch(表达式) { case 常量值: 执行逻辑; break; default: 默认逻辑; }，需注意：

• 表达式结果需为常量类型（int/String/enum 等）； 每个 case 末尾需加
• break（否则会穿透到下一个 case）；
• default 处理所有未匹配的情况（可选）。

void main() {
  String week = "周二";

  switch (week) {
    case "周一":
      print("开始一周的工作");
      break; // 终止当前case，避免穿透
    case "周二":
      print("继续推进任务");
      break;
    case "周五":
      print("准备周末");
      break;
    default: // 匹配不到以上case时执行
      print("正常上班");
  }
}

8.2 特殊场景：case 穿透（慎用）

若省略 break，会执行当前 case 及后续所有 case 逻辑，仅在特定场景使用：

void main() {
  int num = 1;

  switch (num) {
    case 1:
    case 2: // 1和2执行同一逻辑
      print("数字是1或2");
      break;
    case 3:
      print("数字是3");
      break;
  }
}

9. while 和 for 循环

9.1 while 循环

语法：while(条件表达式) { 循环体 }，先判断条件（布尔值），为 true 则执行循环体，直到条件为 false 终止；do-while 是变体，先执行一次循环体再判断条件。

void main() {
  // 基础while循环
  int count = 0;
  while (count < 3) { // 条件为true时执行
    print("循环次数：${count + 1}");
    count++; // 必须修改条件变量，否则死循环
  } // 输出：循环次数1/2/3

  // do-while循环（至少执行一次）
  int num = 5;
  do {
    print("数字：$num");
    num++;
  } while (num < 3); // 条件为false，但仍执行1次，输出：数字：5
}

9.2 for 循环

语法：for(初始化变量; 条件表达式; 更新变量) { 循环体 }，适合已知循环次数的场景，还有 for-in 简化遍历集合的写法。

void main() {
  // 基础for循环
  for (int i = 0; i < 3; i++) { // 初始化→判断→执行→更新
    print("i的值：$i"); // 输出：0/1/2
  }

  // for-in循环（遍历集合，常用）
  List<String> fruits = ["苹果", "香蕉", "橙子"];
  for (String fruit in fruits) {
    print("水果：$fruit"); // 依次输出列表中的每个元素
  }

  // 嵌套for循环（慎用，避免性能问题）
  for (int i = 1; i <= 2; i++) {
    for (int j = 1; j <= 2; j++) {
      print("i=$i, j=$j"); // 输出：i=1j=1 / i=1j=2 / i=2j=1 / i=2j=2
    }
  }
}

9.3 循环控制：break 和 continue

break：终止整个循环，直接跳出；
continue：跳过当前次循环，进入下一次循环。

void main() {
  // break示例：循环到第2次终止
  for (int i = 0; i < 5; i++) {
    if (i == 2) break;
    print("break示例：$i"); // 输出：0/1
  }

  // continue示例：跳过第2次循环
  for (int i = 0; i < 5; i++) {
    if (i == 2) continue;
    print("continue示例：$i"); // 输出：0/1/3/4
  }
}

结尾

到这里，Dart 语言上篇的核心内容就全部讲完啦！从搭建好 Dart 的开发环境，到学会声明变量常量、处理数字 / 字符串等基础数据，再到用列表 / 字典管理数据、用分支和循环控制代码逻辑，这些都是 Dart 最基础也最实用的语法，也是后续做 Flutter 开发、对接 HarmonyOS 的必备技能。

比如你现在掌握的列表遍历，能用来存储鸿蒙不同设备的配置信息；学会的 if 分支和循环，能帮你控制 Flutter 组件在鸿蒙系统里的展示逻辑。建议你趁热打铁，把本文的示例代码多敲几遍，试着改改参数、加加逻辑，比如用循环计算一组数据，或用字典存一份简单的设备信息，在实操中把这些基础记牢。

而这只是 Dart 学习的上半场，下篇我们会接着讲 Dart 的函数和类等进阶内容。打好现在的基础，下篇的进阶学习会更轻松，咱们下篇见！