Flutter插件gg_value的特性与使用

Flutter插件gg_value的特性与使用

GgValue 是一个用于 Dart 的简单值表示方式。它不仅表示内存中的值，还提供了诸如高效的观察、字符串转换等功能。

Flutter插件gg_value特性

• GgValue 提供了一个 stream，可以获取值的更新。
• 具有防垃圾邮件机制，防止多次连续更新。
• 可以设置自定义的 transform 函数来保持值在所需的范围内。
• 可以设置自定义的 isOk 函数来防止错误的值被赋值。
• 可以设置自定义的 compare 函数，确保只有当值变化时才会发送更新。
• 可以设置自定义的 stringify 函数来将值转换为字符串。
• 可以设置自定义的 parse 函数来将字符串转换为值。
• 提供了 syncWith 和 unsync 函数来同步多个值。

使用示例

import 'dart:convert';

import 'package:gg_value/gg_value.dart';

void main() async {
  // 创建一个等待一小段时间的方法
  Future<void> flush() => Future.delayed(const Duration(microseconds: 1));

  // 同步设置值
  var v = GgValue<int>(seed: 5, spam: false);
  print('Sync: ${v.value}'); // 输出: Sync: 5

  // 当 spam 设置为 false 时，stream 只会传递最后的更改
  v.spam = false;
  v.stream.listen((val) => print('Async: $val'));
  v.value = 1;
  v.value = 2;
  v.value = 3;
  await flush(); // 输出: Async: 3

  // 当 spam 设置为 true 时，stream 会传递每次更改
  v.spam = true;
  v.value = 7;
  v.value = 8;
  v.value = 9;
  await flush(); // 输出: Async: 7, Async: 8, Async: 9

  // 转换分配的值
  int ensureMaxFive(int v) => v > 5 ? 5 : v;
  var v2 = GgValue<int>(seed: 0, transform: ensureMaxFive);
  v2.value = 4;
  print('Transformed: ${v2.value}'); // 输出: Transformed: 4
  v2.value = 10;
  print('Transformed: ${v2.value}'); // 输出: Transformed: 5

  // 验证输入值是否有效
  bool allowOnlyEven(int val) => val % 2 == 0;
  var evenOnly = GgValue<int>(seed: 0, isOk: allowOnlyEven);

  evenOnly.value = 4;
  print('isOk: ${evenOnly.value}'); // 输出: isOk: 4

  evenOnly.value = 5;
  print('isOk: ${evenOnly.value}'); // 输出: isOk: 4

  // 只在值发生变化时才传递更新
  bool haveSameFirstLetters(String a, String b) =>
      a.substring(0, 1) == b.substring(0, 1);

  var v3 = GgValue<String>(
    seed: 'Karl',
    compare: haveSameFirstLetters,
    spam: true,
  );

  final receivedUpdates = [];
  v3.stream.listen((val) => receivedUpdates.add(val));

  v3.value = 'Anna';
  v3.value = 'Arno';
  v3.value = 'Berta';
  v3.value = 'Bernd';
  await flush();

  print(receivedUpdates.join(', ')); // 输出: Anna, Berta

  // 设置和获取字符串值
  var v4 = GgValue(seed: 0);
  v4.stringValue = '4';
  print(v4.value); // 输出: 4
  print(v4.stringValue); // 输出: 4

  // 指定自定义解析和字符串转换函数
  int parseEm(String em) => int.parse(em.replaceAll('em', ''));
  String toEmString(int val) => '${val}em';
  var v5 = GgValue(seed: 0, parse: parseEm, stringify: toEmString);
  v5.stringValue = '5em';
  print(v5.value); // 输出: 5
  print(v5.stringValue); // 输出: 5em

  // 使用 jsonDecodedValue 获取或分配可以写入 JSON 的值表示形式
  final val6 = GgValue(seed: 6);
  final object = jsonDecode('{"a": 7}');
  val6.jsonDecodedValue = object['a'];
  print(val6.value); // 输出: 7

  // 最后调用 dispose 关闭所有流并确保不再发出未完成的更新
  final val7 = GgValue(seed: 6, spam: false);
  val7.stream.listen((value) => print(value));
  val7.value++;
  val7.dispose();
  await flush(); // 输出: 无输出，因为值已被处置

  // 使用 syncWith 和 unsync 同步多个值
  final valA = GgValue(seed: 'A');
  final valB = GgValue(seed: 'B');
  final valC = GgValue(seed: 'C');

  valA.syncWith(valB);
  print(valA.value); // 输出: A
  print(valB.value); // 输出: A
  valB.syncWith(valC);
  print(valC.value); // 输出: A

  valB.value = 'B';
  print(valA.value); // 输出: B
  print(valB.value); // 输出: B
  print(valC.value); // 输出: B

  valC.unsync();
  valC.value = 'C';
  print(valA.value); // 输出: B
  print(valB.value); // 输出: B
  print(valC.value); // 输出: C

  // 处理列表及其更改
  final listValue = GgListValue(seed: [0, 1, 2, 3]);
  late GgChange<List<int>> lastChange;
  listValue.changeStream.listen((event) => lastChange = event);

  listValue.add(4);
  await flush();
  print('type: ${lastChange.type}'); // 输出: type: GgChangeType.insert
  print('index: ${lastChange.index}'); // 输出: index: 4
  print('oldValue: ${lastChange.oldValue}'); // 输出: oldValue: [0, 1, 2, 3]
  print('newValue: ${lastChange.newValue}'); // 输出: newValue: [0, 1, 2, 3, 4]

  listValue.remove(4);
  await flush();
  print('type: ${lastChange.type}'); // 输出: type: GgChangeType.remove
  print('index: ${lastChange.index}'); // 输出: index: 4
  print('oldValue: ${lastChange.oldValue}'); // 输出: oldValue: [0, 1, 2, 3, 4]
  print('newValue: ${lastChange.newValue}'); // 输出: newValue: [0, 1, 2, 3]

  listValue.insertAfter(3, 4);
  await flush();
  print('type: ${lastChange.type}'); // 输出: type: GgChangeType.insert
  print('index: ${lastChange.index}'); // 输出: index: 4
  print('oldValue: ${lastChange.oldValue}'); // 输出: oldValue: [0, 1, 2, 3]
  print('newValue: ${lastChange.newValue}'); // 输出: newValue: [0, 1, 2, 3, 4]

  listValue.insertBefore(0, -1);
  await flush();
  print('type: ${lastChange.type}'); // 输出: type: GgChangeType.insert
  print('index: ${lastChange.index}'); // 输出: index: 4
  print('oldValue: ${lastChange.oldValue}'); // 输出: oldValue: [0, 1, 2, 3, 4]
  print('newValue: ${lastChange.newValue}'); // 输出: newValue: [-1, 0, 1, 2, 3, 4]

  listValue.removeAt(0);
  await flush();
  print('type: ${lastChange.type}'); // 输出: type: GgChangeType.remove
  print('index: ${lastChange.index}'); // 输出: index: 4
  print('oldValue: ${lastChange.oldValue}'); // 输出: oldValue: [-1, 0, 1, 2, 3, 4]
  print('newValue: ${lastChange.newValue}'); // 输出: newValue: [0, 1, 2, 3, 4]

  listValue.move(fromIndex: 0, toIndex: 5);
  await flush();
  print('type: ${lastChange.type}'); // 输出: type: GgChangeType.move
  print('index: ${lastChange.index}'); // 输出: index: 4
  print('oldIndex: ${lastChange.oldIndex}'); // 输出: oldValue: [0, 1, 2, 3, 4]
  print('oldValue: ${lastChange.oldValue}'); // 输出: newValue: [1, 2, 3, 4, 0]
}