Flutter高效对象比较插件fast_equatable的使用

概述

这是一个简单的Dart包，提供了快速且安全的对象相等性比较功能，作为mixin实现。这为现有的代码提供了良好的兼容性。

它还提供了可选的哈希缓存功能，以显著提高例如Map和Set的速度。

默认情况下，使用的是广泛传播的詹金斯散列函数，但你也可以实现并提供自己的哈希引擎，以满足你的需求。

任何类型的对象都可以放入hashParameters。默认支持简单类型和标准集合，如List、Iterable、Map和Set。当你使用自定义类时，请确保也使用FastEquatable mixin，或者至少重写hashCode和operator ==方法。

示例

class FastEquatableCached with FastEquatable {
  final String value1;
  final List<String>? value2;

  FastEquatableCached(this.value1, this.value2);

  [@override](/user/override)
  // 这是一个不可变对象，所以我们想要缓存哈希值
  bool get cacheHash => true;

  [@override](/user/override)
  List<Object?> get hashParameters => [value1, value2];
}

性能测试

在example文件夹中，你可以找到一个性能测试代码，展示了由此带来的速度提升。

equatable for 1000000 elements(RunTime): 8583044.5 us.
fast_equatable (uncached) for 1000000 elements(RunTime): 8493327.5 us.
fast_equatable (cached) for 1000000 elements(RunTime): 3329455.5 us.

完整示例代码

import 'dart:math';

import 'package:benchmark_harness/benchmark_harness.dart';
import 'package:equatable/equatable.dart';
import 'package:fast_equatable/fast_equatable.dart';

// 使用FastEquatable mixin的带缓存的类
class FastEquatableCached with FastEquatable {
  final String value1;
  final List<String>? value2;

  FastEquatableCached(this.value1, this.value2);

  [@override](/user/override)
  // 这是一个不可变对象，所以我们想要缓存哈希值
  bool get cacheHash => true;

  [@override](/user/override)
  List<Object?> get hashParameters => [value1, value2];
}

// 使用FastEquatable mixin的不带缓存的类
class FastEquatableUncached with FastEquatable {
  final String value1;
  final List<String>? value2;

  FastEquatableUncached(this.value1, this.value2);

  [@override](/user/override)
  // 不需要缓存哈希值
  bool get cacheHash => false;

  [@override](/user/override)
  List<Object?> get hashParameters => [value1, value2];
}

// 使用Equatable库的类
class TestClassEquatable extends Equatable {
  final String value1;
  final List<String>? value2;

  const TestClassEquatable(this.value1, this.value2);

  [@override](/user/override)
  List<Object?> get props => [value1, value2];
}

// 基准测试基类
abstract class BenchmarkBase extends BenchmarkBase {
  final List<String> _randsValA;
  final List<String> _randsValB;

  late final List<TestClassEquatable> objects;

  BenchmarkBase(this._randsValA, this._randsValB)
      : assert(_randsValA.length == _randsValB.length),
        super('基准测试');

  [@override](/user/override)
  void setup() {
    objects = List.generate(_randsValA.length,
        (i) => TestClassEquatable(_randsValA[i], [_randsValB[i]]));
  }

  [@override](/user/override)
  void run() {
    final set = <TestClassEquatable>{};

    for (final obj in objects) {
      set.add(obj);
    }
  }
}

// 使用Equatable库的基准测试类
class EquatableBenchmark extends BenchmarkBase {
  EquatableBenchmark(super._randsValA, super._randsValB)
      : super('equatable for ${_randsValA.length} elements');

  [@override](/user/override)
  void run() {
    final set = <TestClassEquatable>{};

    for (final obj in objects) {
      set.add(obj);
    }
  }
}

// 使用FastEquatable不带缓存的基准测试类
class FastEquatableUncachedBenchmark extends BenchmarkBase {
  FastEquatableUncachedBenchmark(super._randsValA, super._randsValB)
      : super('fast_equatable (uncached) for ${_randsValA.length} elements');

  [@override](/user/override)
  void run() {
    final set = <FastEquatableUncached>{};

    for (final obj in objects) {
      set.add(obj);
    }
  }
}

// 使用FastEquatable带缓存的基准测试类
class FastEquatableCachedBenchmark extends BenchmarkBase {
  FastEquatableCachedBenchmark(super._randsValA, super._randsValB)
      : super('fast_equatable (cached) for ${_randsValA.length} elements');

  [@override](/user/override)
  void run() {
    final set = <FastEquatableCached>{};

    for (final obj in objects) {
      set.add(obj);
    }
  }
}

void main(List<String> args) {
  const int nAcc = 1000000;

  final rand = Random();
  final randsVal1 = List.generate(nAcc, (_) => rand.nextInt(nAcc).toString());
  final randsVal2 = List.generate(nAcc, (_) => rand.nextInt(nAcc).toString());

  EquatableBenchmark(randsVal1, randsVal2).report();
  FastEquatableUncachedBenchmark(randsVal1, randsVal2).report();
  FastEquatableCachedBenchmark(randsVal1, randsVal2).report();
}