Flutter列表工具插件ms_list_utils的使用

概述

一些用于操作列表的帮助函数。

MS_List_Utils的功能

向映射中添加有用的函数：

• addAround 返回在列表周围生成新项的新列表。
• addBetween 返回在列表之间生成新项的新列表。
• containsAll 返回包含所有指定元素的新列表。
• containsAny 返回包含任意指定元素的新列表。
• containsAtLeast 返回包含至少指定数量元素的新列表。
• containsHits 返回包含命中次数的新列表。
• diff 返回在listA中但不在listB中的元素。
• firstOrNull 返回数组中的第一个元素，如果为空则返回null。
• firstWhereOrAdd 如果不存在满足测试的第一个元素，则添加一个新元素并返回它。
• flat 返回扁平化后的列表。
• intersection 返回两个列表之间的公共元素。
• isFirst 如果元素是列表中的第一个，则返回true。
• isLast 如果元素是列表中的最后一个，则返回true。
• joinLast 使用一个分隔符连接列表的所有元素，并为最后一次迭代使用不同的分隔符。
• lastOrNull 返回数组中的最后一个元素，如果为空则返回null。
• lastWhereOrAdd 如果不存在满足测试的最后一个元素，则添加一个新元素并返回它。
• toMap 返回由生成器生成键的映射。
• toStream 创建一个包含列表项的流。

使用方法

只需导入库并使用扩展方法，调用函数即可开始工作：

// 不要忘记导入
import 'package:ms_list_utils/ms_list_utils.dart';

List list = ['😁','😒','😊'];
final newList = addAround(list, (index, previous, next) => '冰淇淋');
print(newList); // ['冰淇淋', '😁', '冰淇淋', '😒', '冰淇淋', '😊', '冰淇淋']

// 或者使用扩展方法
final newList = list.addAround((index, previous, next) => '冰淇淋');
print(newList); // ['冰淇淋', '😁', '冰淇淋', '😒', '冰淇淋', '😊', '冰淇淋']

addAround

addAround 函数返回在列表周围生成新项的新列表。

  test('tests the function add_around.dart', () {
    final initialValue = [1, 2, 3, 4];
    final result = addAround(initialValue,
        (int index, int? previousValue, int? nextValue) {
      return 5;
    });
    expect(result, [5, 1, 5, 2, 5, 3, 5, 4, 5]);
    expect(initialValue.addAround((index, previous, next) => 5),
        [5, 1, 5, 2, 5, 3, 5, 4, 5]);
  });

addBetween

addBetween 函数返回在列表之间生成新项的新列表。

  test('add values between in list', () {
    final initialValue = <int>[1, 2, 3];
    final result = addBetween<int>(
        initialValue, (int index, previousValue, nextValue) => 5);
    expect(result, [1, 5, 2, 5, 3]);
    expect(
        initialValue.addBetween((index, previous, next) => 5), [1, 5, 2, 5, 3]);
  });

diff

diff 函数返回在listA中但不在listB中的元素。

  test('differences between two lists', () {
    final listA = [1, 2, 3, 4, 5];
    final listB = [2, 4, 6];
    expect(diff(listA, listB), orderedEquals([1, 3, 5]));
    expect(diff(listB, listA), orderedEquals([6]));
    expect(listB - listA, orderedEquals([6]));
    expect(listB.diff(listA), orderedEquals([6]));
  });

firstWhereOrAdd

firstWhereOrAdd 函数返回满足测试的第一个元素，如果不存在则添加一个新元素并返回它。

  test('tests the function first_where_or_add.dart', () {
    final list = [1, 2, 3];
    expect(firstWhereOrAdd(list, (value) => value == 4, () => 4), 4);
    expect(list, [1, 2, 3, 4]);
    final listE = [1, 2, 3];
    expect(listE.firstWhereOrAdd((value) => value == 4, () => 4), 4);
    expect(listE, [1, 2, 3, 4]);
  });

flat

flat 函数返回一个扁平化的列表。

  test('flat dynamic', () {
    final multiList = [
      1,
      2,
      3,
      [
        "4",
        "5",
        [
          6,
          7,
          [true, true, false]
        ]
      ]
    ];
    final result = flat(multiList);
    expect(result, [1, 2, 3, "4", "5", 6, 7, true, true, false]);
    expect(multiList.flat(), [1, 2, 3, "4", "5", 6, 7, true, true, false]);
  });

intersection

intersection 函数返回两个列表之间的公共元素。

  test('intersection between two lists', () {
    final listA = [1, 2, 3, 4, 5];
    final listB = [2, 4, 6];
    expect(intersection(listA, listB), orderedEquals([2, 4]));
    expect(listA.intersection(listB), orderedEquals([2, 4]));
  });

isFirst

isFirst 函数返回如果元素是列表中的第一个，则返回true。

  test('tests the function is_first.dart', () {
    final list = [1, 2, 3];
    expect(isFirst(list, 3), isFalse);
    expect(isFirst(list, 1), isTrue);
    expect(isFirstIndex(list, 3), isFalse);
    expect(isFirstIndex(list, 0), isTrue);
    expect(list.isFirst(3), isFalse);
    expect(list.isFirst(1), isTrue);
    expect(list.isFirstIndex(3), isFalse);
    expect(list.isFirstIndex(0), isTrue);
  });

isLast

isLast 函数返回如果元素是列表中的最后一个，则返回true。

  test('tests the function is_last.dart', () {
    final list = [1, 2, 3];
    expect(isLast(list, 1), isFalse);
    expect(isLast(list, 3), isTrue);
    expect(isLastIndex(list, 1), isFalse);
    expect(isLastIndex(list, 2), isTrue);
    expect(list.isLast(1), isFalse);
    expect(list.isLast(3), isTrue);
    expect(list.isLastIndex(1), isFalse);
    expect(list.isLastIndex(2), isTrue);
  });

joinLast

joinLast 函数使用一个分隔符连接列表的所有元素，并为最后一次迭代使用不同的分隔符。

  test('tests the function join.dart', () {
    final list = [1, 2, 3];
    expect(join(list, ', ', ' and '), '1, 2 and 3');
    expect(join(list), '123');
    expect(list.joinLast(', ', ' and '), '1, 2 and 3');
    expect(list.joinLast(), '123');
  });

lastOrNull

lastOrNull 函数返回列表中的最后一个元素，如果列表为空则返回null。

  test('tests the function last_or_null.dart', () {
    final emptyList = [];
    final list = [1, 2, 3];
    expect(lastOrNull(emptyList), null);
    expect(lastOrNull(list), 3);
    expect(emptyList.lastOrNull, null);
    expect(list.lastOrNull, 3);
  });

lastWhereOrAdd

lastWhereOrAdd 函数返回满足测试的最后一个元素，如果不存在则添加一个新元素并返回它。

  test('tests the function last_where_or_add.dart', () {
    final list = [1, 2, 3];
    expect(lastWhereOrAdd(list, (value) => value == 4, () => 4), 4);
    expect(list, [1, 2, 3, 4]);
    final listE = [1, 2, 3];
    expect(listE.lastWhereOrAdd((value) => value == 4, () => 4), 4);
    expect(listE, [1, 2, 3, 4]);
  });

toMap

toMap 函数返回由生成器生成键的映射。

    final list = [1, 2, 3];
    expect(toMap<String, int>(list, (value) => value.toString()),
        {'1': 1, '2': 2, '3': 3});
    expect(list.toMap((value) => "$value"), {'1': 1, '2': 2, '3': 3});
  });

toStream

toStream 函数创建一个包含列表项的流。

  test('tests the function to_stream.dart', () async {
    await expectLater([1, 2, 3].toStream(), emitsInOrder([1, 2, 3]));
    await expectLater([1, 2, 3].toStream(const Duration(milliseconds: 85)),
        emitsInOrder([1, 2, 3]));
    await expectLater(toStream([1, 2, 3]), emitsInOrder([1, 2, 3]));
  });

示例代码

// 忽略打印警告

import 'package:ms_list_utils/ms_list_utils.dart';

void main() {
  final multiList = [
    'foo',
    'bar',
    ['pão de queijo', 'queijo com goiabada', 'frango caipira com quiabo']
  ];

  final flatList = multiList.flat();
  print(
      flatList); // ['foo', 'bar', 'pão de queijo', 'queijo com goiabada', 'frango caipira com quiabo']

  print(flatList.next(0)); // "bar"
  print(flatList.previous(0)); // null
  print(flatList.isLast("foo")); // false
  print(flatList.isFirst('foo')); // true
  print(flatList.sublist(2).joinLast(', ', ' 和 ')); // pão de queijo, queijo com goiabada 和 frango caipira com quiabo
  print(flatList.toMap((value) => flatList.indexOf(value))); // {0: foo, 1: bar, 2: pão de queijo, 3: queijo com goiabada, 4: frango caipira com quiabo}

  final emptyList = <String>[];

  print(emptyList.firstOrNull); // null
  print(emptyList.lastOrNull); // null

  final foo = emptyList.firstWhereOrAdd((element) => element == "foo", () => "foo");
  print(foo); // foo

  emptyList.firstWhereOrAdd((element) => element == "foo", () => "foo");
  final fooTheReturn = emptyList.firstWhereOrAdd((element) => element == "foo", () => "foo");
  print(fooTheReturn); // foo
  print(emptyList); // ["foo"]

  final bar = emptyList.firstWhereOrAdd((element) => element == "bar", () => "bar");

  print(bar); // bar
  print(emptyList); // ["foo", "bar"]
  print(emptyList.firstOrNull); // null
  print(emptyList.lastOrNull); // null
}