dart学习第 22 节：性能优化基础 —— 从代码层面提速

在前几节课中，我们学习了代码规范与静态检查，掌握了写出高质量代码的基础。今天我们将聚焦于性能优化------ 从代码层面提升程序运行效率。性能是用户体验的核心，尤其是在移动应用和高性能需求场景中，哪怕是毫秒级的优化都可能带来显著的体验提升。

一、类型优化：避免不必要的 dynamic 类型

Dart 是一门强类型语言，但也支持 dynamic 类型（动态类型），它会关闭类型检查，让变量可以存储任意类型的值。然而，过度使用 dynamic 会严重影响性能和代码安全性。

1. dynamic 类型的性能问题

• 运行时类型检查开销 ：使用 dynamic 时，Dart 虚拟机需要在运行时不断检查变量的实际类型，而静态类型（如 String、int）在编译时就确定了类型，无需运行时开销。
• 阻碍编译器优化 ：静态类型让编译器可以进行更多优化（如内联、类型特化），而 dynamic 会让这些优化失效。
• 隐藏潜在错误：编译时无法检查类型错误，可能导致运行时异常。

2. 替换 dynamic 为具体类型

// 不推荐：使用 dynamic
void processData(dynamic data) {
  print(data.length); // 编译时无法检查 data 是否有 length 属性
}

// 推荐：使用具体类型
void processList(List<String> data) {
  print(data.length); // 编译时明确类型，安全且高效
}

// 推荐：使用泛型（兼顾灵活性和类型安全）
void processGeneric<T>(List<T> data) {
  print(data.length);
}

3. 性能测试对比

安装benchmark_harness库

import 'dart:math';
import 'package:benchmark_harness/benchmark_harness.dart';

// 动态类型版本
class DynamicBenchmark extends BenchmarkBase {
  const DynamicBenchmark() : super('Dynamic type');

  @override
  void run() {
    dynamic list = [1, 2, 3, 4, 5];
    int sum = 0;
    for (int i = 0; i < 1000; i++) {
      for (var item in list) {
        sum += item as int;
      }
    }
  }
}

// 静态类型版本
class StaticBenchmark extends BenchmarkBase {
  const StaticBenchmark() : super('Static type');

  @override
  void run() {
    List<int> list = [1, 2, 3, 4, 5];
    int sum = 0;
    for (int i = 0; i < 1000; i++) {
      for (var item in list) {
        sum += item;
      }
    }
  }
}

void main() {
  const DynamicBenchmark().report();
  const StaticBenchmark().report();
}

测试结果（仅供参考）：

Dynamic type(RunTime): 116.65289702467736 us.
Static type(RunTime): 107.3150159744409 us.

静态类型版本比动态类型版本快约 8.01%，在复杂场景中差距可能更大。

最佳实践：除非在处理 JSON 解析等必须动态类型的场景，否则始终使用具体类型或泛型。

---

二、集合操作优化：循环与遍历的性能对比

集合（List、Set、Map）是编程中最常用的数据结构，其遍历操作的性能直接影响程序效率。不同的遍历方式在性能上的差异并非绝对，而是取决于列表类型 、循环体复杂度 和类型操作等因素。

1. 三种常见循环的性能对比

我们通过实际测试来分析 for 循环、forEach 和 for-in 循环的性能差异：

import 'package:benchmark_harness/benchmark_harness.dart';

// 测试用动态列表（模拟复杂场景）
final list = List.generate(10000, (i) => i).cast<dynamic>();

// for 循环遍历（索引访问）
class ForLoopBenchmark extends BenchmarkBase {
  const ForLoopBenchmark() : super('For loop');

  @override
  void run() {
    int sum = 0;
    for (int i = 0; i < list.length; i++) {
      if (list[i] % 2 == 0) {
        sum += (list[i] * 2) as int; // 包含条件判断和类型转换
      }
    }
  }
}

// forEach 遍历（函数回调）
class ForEachBenchmark extends BenchmarkBase {
  const ForEachBenchmark() : super('forEach');

  @override
  void run() {
    int sum = 0;
    list.forEach((item) {
      if (item % 2 == 0) {
        sum += item * 2 as int;
      }
    });
  }
}

// for-in 循环遍历（迭代器）
class ForInBenchmark extends BenchmarkBase {
  const ForInBenchmark() : super('for-in loop');

  @override
  void run() {
    int sum = 0;
    for (final item in list) {
      if (item % 2 == 0) {
        sum += item * 2 as int;
      }
    }
  }
}

void main() {
  const ForLoopBenchmark().report();
  const ForEachBenchmark().report();
  const ForInBenchmark().report();
}

测试结果：

For loop(RunTime): 483.3015179392824 us.
forEach(RunTime): 594.60975 us.
for-in loop(RunTime): 460.9502030348365 us.

2. 结果分析：为什么 for-in 表现最优？

在这个动态列表 + 包含类型转换的场景中，三种循环的性能差异源于它们的底层实现机制：

循环类型	性能表现	核心原因分析
for-in	最优	使用迭代器（Iterator）遍历，对动态列表做了特殊优化： 1. 一次性获取遍历权限，减少重复的边界检查 2. 缓存元素类型信息，降低 dynamic 转换开销 3. 迭代器实现被编译器深度优化（如循环展开）
for	次之	索引访问模式存在额外开销： 1. 每次 list[i] 都需要独立的边界检查 2. 动态列表的索引访问会触发更多类型验证 3. 循环条件 i < list.length 可能重复计算长度
forEach	最慢	函数回调引入额外开销： 1. 匿名函数调用的固定成本（参数传递、栈操作） 2. 动态类型下，函数参数的类型检查更频繁 3. 复杂循环体放大了函数调用的性能损耗

3. 场景对性能的影响

循环性能并非一成不变，而是高度依赖场景：

• 列表类型：

  • 静态类型列表（List<int>）中，for 循环的索引访问可能更优（编译器可移除多余检查）；
  • 动态类型列表（List<dynamic>）中，for-in 的迭代器优化更明显。

• 循环体复杂度：

  • 简单操作（如纯累加）时，迭代方式的差异影响更大；
  • 复杂操作（如大量计算、网络请求）时，三种循环的性能差距会被稀释（循环体开销成为主导）。

• 是否需要索引：

  • 需要索引时，for 循环是唯一选择；
  • 无需索引时，for-in 或 forEach 更简洁（根据性能需求选择）。

最佳实践：根据场景选择循环方式 ------ 动态列表 + 复杂类型操作优先用 for-in；静态列表 + 简单操作可用 for 循环；追求代码简洁且性能不敏感时用 forEach。

---

三、对象创建优化：const 构造函数与对象复用

对象创建是内存分配的主要来源，频繁创建短命对象会增加垃圾回收（GC）压力，导致性能波动。使用 const 构造函数和对象复用可以有效减少对象创建。

1. const 构造函数：编译时创建的不可变对象

const 构造函数创建的对象是编译时常量 ，相同的 const 对象在内存中只会存在一份，且不会触发运行时内存分配。

// 普通构造函数
class Point {
  final int x;
  final int y;

  Point(this.x, this.y);
}

// 常量构造函数
class ConstPoint {
  final int x;
  final int y;

  const ConstPoint(this.x, this.y); // 注意 const 关键字
}

void main() {
  // 普通对象：每次创建都是新实例
  final p1 = Point(1, 2);
  final p2 = Point(1, 2);
  print(identical(p1, p2)); // 输出：false（不同实例）

  // 常量对象：相同参数的实例完全相同
  final cp1 = const ConstPoint(1, 2);
  final cp2 = const ConstPoint(1, 2);
  print(identical(cp1, cp2)); // 输出：true（同一实例）
}

2. const 构造函数的适用场景

• 存储不变的数据（如配置项、常量定义）。
• Flutter 中构建静态 Widget（如文本、图标），避免重建时重复创建对象。

// Flutter 示例：使用 const 减少 Widget 重建
Widget build(BuildContext context) {
  return Column(
    children: [
      // 静态文本：使用 const 避免每次 build 都创建新对象
      const Text("静态标题"),

      // 动态内容：无法使用 const
      Text("用户名: ${user.name}"),
    ],
  );
}

3. 对象复用：缓存与池化

对于频繁创建和销毁的对象（如临时计算对象），可以通过缓存或对象池复用实例：

// 缓存复用示例（单例模式）
class DataParser {
  // 缓存解析器实例
  static final DataParser _instance = DataParser._();

  // 私有构造函数，防止外部创建
  DataParser._();

  // 通过工厂方法获取单例
  factory DataParser() => _instance;

  // 解析逻辑
  Map<String, dynamic> parse(String data) {
    // 解析实现...
  }
}

// 对象池示例（适用于频繁创建的轻量对象）
class ObjectPool<T> {
  final List<T> _pool = [];
  final T Function() _creator;

  ObjectPool(this._creator);

  // 获取对象（从池里取，没有则创建）
  T acquire() {
    if (_pool.isNotEmpty) {
      return _pool.removeLast();
    }
    return _creator();
  }

  // 释放对象（放回池里）
  void release(T obj) {
    _pool.add(obj);
  }
}

4. 性能测试：const vs 普通对象

import 'package:benchmark_harness/benchmark_harness.dart';

class NormalObject {
  final int value;
  NormalObject(this.value);
}

class ConstObject {
  final int value;
  const ConstObject(this.value);
}

class NormalBenchmark extends BenchmarkBase {
  const NormalBenchmark() : super('Normal object');

  @override
  void run() {
    for (int i = 0; i < 10000; i++) {
      NormalObject(i); // 每次创建新对象
    }
  }
}

class ConstBenchmark extends BenchmarkBase {
  const ConstBenchmark() : super('Const object');

  @override
  void run() {
    for (int i = 0; i < 10000; i++) {
      const ConstObject(1); // 复用同一实例
    }
  }
}

void main() {
  const ConstBenchmark().report();
  const NormalBenchmark().report();
}

测试结果（示例） ：

Const object(RunTime): 27.686003598987405 us.
Normal object(RunTime): 43.3430996202768 us.

const 对象创建几乎没有开销，比普通对象快约 36%，尤其在频繁创建相同对象的场景中优势显著。

---

四、其他性能优化技巧

1. 避免不必要的重建：final 关键字

使用 final 声明变量，不仅能确保不可变性，还能帮助编译器进行优化（如确定变量不会被修改，从而减少检查）：

// 推荐：使用 final 声明不会修改的变量
void process() {
  final list = [1, 2, 3]; // 引用不可变（但内容可变）
  final sum = list.fold(0, (a, b) => a + b); // 不可变变量
}

2. 选择高效的数据结构

• 包含检查 ：Set 的 contains 操作是 O (1)，而 List 的 contains 是 O (n)，大数据量下优先使用 Set。
• 键值查找 ：Map 的查找效率远高于线性搜索，频繁按键查询时使用 Map。

// 低效：List 包含检查（O(n)）
bool isInList(List<int> list, int value) => list.contains(value);

// 高效：Set 包含检查（O(1)）
bool isInSet(Set<int> set, int value) => set.contains(value);

3. 懒加载：延迟初始化

使用 late 关键字或 Future 延迟初始化耗时对象，避免启动时的性能开销：

class HeavyService {
  // 延迟初始化（第一次访问时才创建）
  late final Database _db = _initDatabase();

  Database _initDatabase() {
    // 模拟耗时的初始化
    return Database();
  }
}

4. 避免在高频函数中执行耗时操作

在 Flutter 的 build 方法或频繁调用的函数中，避免执行计算、网络请求等耗时操作，否则会导致 UI 卡顿：

// 不推荐：在 build 中执行计算
Widget build(BuildContext context) {
  final data = _calculateComplexData(); // 耗时计算
  return Text(data.toString());
}

// 推荐：提前计算并缓存结果
Widget build(BuildContext context) {
  return FutureBuilder(
    future: _cachedData, // 提前计算并缓存
    builder: (context, snapshot) {
      if (snapshot.hasData) {
        return Text(snapshot.data.toString());
      }
      return CircularProgressIndicator();
    },
  );
}

---

五、性能分析工具：找到优化点

优化的前提是找到性能瓶颈，Dart 提供了多种工具帮助分析性能：

1. dart devtools

Dart 开发工具集，包含性能分析器（Performance）、内存分析器（Memory）等：

# 启动开发工具
dart devtools

在浏览器中打开工具，可实时查看函数执行时间、内存分配等信息。

2. benchmark_harness 包

用于编写微基准测试，精确测量代码片段的执行时间（如前面的性能测试示例）。

3. Flutter 性能面板

在 Flutter 开发中，使用 DevTools 的性能面板可以查看 UI 渲染帧率、构建耗时等，帮助定位卡顿问题。