如何避免Getter或函数重复计算？Dart类性能优化疑问

先看你定义的OrderInfo类：

class OrderInfo {
  final String orderId;
  final String status;
  final DateTime orderDateTime;
  final DateTime? deliverDateTime;
  final String? restaurantTitle;

  OrderInfo({
    required this.orderId,
    required this.status,
    required this.orderDateTime,
    required this.deliverDateTime,
    required this.restaurantTitle,
  });
  
  // 每次调用都会重复执行复杂计算的getter
  Something get something {
    // 大量复杂计算代码
    return something; // 注意：原代码这里会触发递归调用，属于错误写法
  };
}

因为类中所有字段都是final，something的计算结果不会随实例变化，确实没必要每次调用getter都重复计算。下面解答你的问题：

你尝试的late字段写法是否正确？ #

你的思路是对的，但原代码存在递归错误（return something会再次触发变量初始化逻辑），修正后是完全可行的：

class OrderInfo {
  // 其他final字段...
  
  late final Something something = () {
    // 复杂计算逻辑，可直接依赖类中其他final字段
    return computedResult; // 这里返回实际计算结果，而非something变量
  }();
}

这种延迟初始化方式会在第一次访问something时执行计算，之后直接返回缓存值，完全符合你的需求。

其他可行的优化方法 #

1. 构造函数初始化（推荐，若属性一定会被用到）

既然所有依赖字段都是final，可以在实例创建时就完成计算，直接把something声明为final字段，在构造函数初始化列表中赋值：

class OrderInfo {
  final String orderId;
  final String status;
  final DateTime orderDateTime;
  final DateTime? deliverDateTime;
  final String? restaurantTitle;
  final Something something;

  OrderInfo({
    required this.orderId,
    required this.status,
    required this.orderDateTime,
    required this.deliverDateTime,
    required this.restaurantTitle,
  }) : something = _calculateSomething(
          orderId,
          status,
          orderDateTime,
          deliverDateTime,
          restaurantTitle,
        );

  // 把计算逻辑抽成静态方法，代码更清晰可维护
  static Something _calculateSomething(
    String orderId,
    String status,
    DateTime orderDateTime,
    DateTime? deliverDateTime,
    String? restaurantTitle,
  ) {
    // 复杂计算逻辑
    return Something(...);
  }
}

• 优点：实例创建时一次性完成计算，线程安全（Dart构造函数执行是原子操作），没有延迟初始化的额外开销。

2. 手动缓存的Getter

如果想保留Getter的写法，也可以用私有变量手动缓存计算结果：

class OrderInfo {
  // 其他final字段...
  
  Something? _cachedSomething;

  Something get something {
    return _cachedSomething ??= _calculateSomething();
  }

  Something _calculateSomething() {
    // 复杂计算逻辑
    return Something(...);
  }
}

• 效果和late final类似，但手动控制缓存逻辑，适合需要更灵活处理的场景（不过在这个类中因为字段都是final，清空缓存没有实际意义）。

选择建议 #

• 如果确定something一定会被访问，优先用构造函数初始化，逻辑更直接，性能最优。
• 如果something可能不会被用到，用late final或手动缓存的Getter，实现懒加载，避免不必要的计算。

内容的提问来源于stack exchange，提问作者SoulCRYSIS