【Dart语言第4篇】List属性和方法

一、定义

1、静态

List list = [1, 2, 3]

2、动态

List list = new List();

dart 数据类型，当list数组类型的时候，用List去声明是最保险的，尽量不要使用var，因为var的方式，需要看后面的值，才能推测出来变量类型。

void main() {
  List list23 = [
    {
      'city_name': '河北',
      'country_list': [
        {
          "counry_name": '廊坊',
          "title": '1',
        },
        {
          "counry_name": '燕郊',
          "title": '1',
        }
      ],
    },
    {
      'city_name': '山西',
      'country_list': [
        {
          "counry_name": '长治',
          "title": '1',
        },
        {
          "counry_name": '侯马',
          "title": '1',
        }
      ],
    },
  ];

  for (var i = 0; i < list23.length; i++) {
    print(list23[i]['country_list'].length); // 重点在这句话
  }
}

而当我们把List声明修改成var声明的时候，直接会导致 list23[i]['country_list'].length 编译报错，不可用。

二、属性

常用属性

1、length 长度

获取数组的长度：

List<String> list = ["周一", "周二", "周三"];
print(list.length); // 3

2、reversed 翻转

反转数组：

List<String> list = ["周一", "周二", "周三"];
print(list.reversed); // (周三, 周二, 周一)

这里值得注意的是，数组反转后返回的并不是一个数组，该属性也不会改变原数组。反转过后的数组，要用toList方法，才能成为一个新的数组(toList)。

3、isEmpty 是否为空

判断数组是否为空，除了用 l.length == 0 这种方式外，还可以用isEmpty，这也是官方推荐的写法：

List<String> list = ["周一", "周二", "周三"];
print(list.isEmpty); // false

4、isNotEmpty 是否不为空

判断数组是否不为空，除了用 l.length != 0 这种方式外，也可以用 isNotEmpty，这也是官方推荐写法：

List<String> list = ["周一", "周二", "周三"];
print(list.isNotEmpty); // true

其他属性：

1、hashCode

该属性返回一个整数，表示数组的哈希码。

 List<String> list = ["周一", "周二"];
print(list.hashCode); // 485949920

2、runtimeType

返回运行时的数据类型

List<String> list = ["周一", "周二"];
print(list.runtimeType); // List<String>

List list = ["周一", "周二"];
print(list.runtimeType); // List<dynamic>

3、first 取数组第一个元素

获取数组的第一个元素，除了用 list[0]，还可以用 first:

List<String> list = ["周一", "周二", "周三"];
print(list.first); // 周一

4、iterator

获得当前List的迭代器

 List list = ["周一", "周二"];
print(list.iterator); // Instance of 'ListIterator<dynamic>'

5、last

获取数组的最后一个元素除了用 list[list.length-1] 这种方式外，也可以用 last:

List<String> list = ["周一", "周二", "周三"];
print(list.last); // 周三

6、single

检查列表是否只有一个元素并返回它。

List<String> list = ["周一"];
print(list.single); // 周一

如果List中包含多个元素，则此属性将引发exception 。 以下示例说明了相同的情况 -

List<String> list = ["周一", "周二", "周三"];
print(list.single); // Unhandled exception: Bad state: Too many elements

三、方法

先来看一波给数组添加元素的方法：

1、add()

给list结尾除添加一个元素

List list = ["周一", "周二"];
list.add('周三');
print(list); // [周一, 周二, 周三]

需要注意的是，你不能向一个固定长度的数组用 add() 方法添加元素，否则会抛出异常，如下代码所示：

List<String> arr = List(1);
arr.add("Allen Su");

异常如下:

2、addAll()

在List结尾处添加obj, obj为一个可迭代的对象，简单说就是合并两个数组。

void main() {
  List<String> list = ["周一", "周二"];
  List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
  list.addAll(list2);
  print(list); // [周一, 周二, 周三, 周四, 周五, 周六, 周天]
}

需要注意的是，你不能向一个固定长度的数组用 addAll() 方法添加元素，否则会抛出异常。

3、insert()

在指定索引处添加一个值

List list = ["周一", "周二"];
list.insert(2, '周四');
print(list); // [周一, 周二, 周四]

4、insertAll()

在指定索引处插入一个数组，使用 insertAll 方法。insertAll 方法无返回值，第一个参数为在哪个索引位置处添加数据，第二个参数为要添加的数据，参数类型为 Iterable，如下代码:

 List<String> list = ["周一", "周二"];
List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
list.insertAll(2, list2);
print(list); // [周一, 周二, 周三, 周四, 周五, 周六, 周天]

注意：无论是使用 insert 方法还是 insertAll 方法，有两点需要注意：

• 被添加的数组必须非固定长度，即该数组是可变的。
• 第一个参数必须为非负，且不大于添加数据前数组的长度。

---

删除数组元素的方法：

5、remove()

删除指定元素：该方法的返回值为 bool，参数类型为 object。

List<String> list = ["周一", "周二"];
list.remove("周一");
print(list); // [周二]

删除后数组的长度减 1 ，即原数组会发生改变。

删除元素时，如果数组中有多个符合条件的值：

这个时候会删除数组中第一个符合条件的元素，如下代码:

List<String> list = ["周一", "周一", "周二"];
list.remove("周一");
print(list); // [周一, 周二]

删除元素时，如果被删除的元素不在数组中：

这个时候也不会抛出异常，返回 false ，原数组不改变，如下代码：

List<String> list = ["周一", "周一", "周二"];
print(list.remove("周四") ? "移除成功" : "移除失败"); // 移除失败
print(list); // [周一, 周一, 周二]

使用 remove 方法从数组中移除数据时，被移除的数组不能为固定长度的数组，否则会抛出异常。

6、removeAt()

删除指定索引位置处的元素。用 removeAt() 方法，该方法返回被删除的对象，参数为 int 类型，代表索引值。

List<String> list = ["周一", "周一", "周二"];
print(list.removeAt(0)); // 周一
print(list); // [周一, 周二]

移除元素后，原数组长度减 1 ，即该方法会改变原数组。

使用 removeAt() 方法有两点需要注意，否则会抛出异常：

• 参数的范围必须在 [ 0 , List.length - 1 ] 之间。
• 被移除的数字不能是固定长度的数组。

7、removeLast()

删除数组的最后一个元素，该方法无参数，返回被删除的对象。被删除的数组元素少了一个，即该方法会让原数组改变。效果和 list.removeAt(list.length - 1) 是一样的，只不过 dart 为我们提供了更简单方便的用法。

List<String> list = ['周三', '周四', '周五', '周六', '周天'];
print(list.removeLast()); // 周天
print(list); // [周三, 周四, 周五, 周六]

在使用 removeLast() 方法时，有两点需要注意，否则会抛出异常。

• 不能是固定长度的数组。
• 不能为空数组。

8、clear()

清空数组，该方法无参数无返回值。

List<String> list = ["周一", "周一", "周二"];
list.clear();
print(list); // []

9、removeWhere()

dart 根据条件删除数组中的元素，用 removeWhere() 方法，源码定义如下:

语法： void removeWhere(bool test(E element));

该方法无返回值，参数的返回值为 bool 类型:

List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
// 删除数组中等于周六的元素
list2.removeWhere((e) => e == '周六'); 
print(list2); // [周三, 周四, 周五, 周天]

// 删除数组元素中包含周的元素
list2.removeWhere((e) => e.contains('周'));
print(list2); // []

使用 removeWhere 方法时，被移除元素的数组不能为固定长度的数组，否则会抛出异常。

10、removeRange()

语法： void removeRange(int start, int end);

删除数组中指定索引范围的元素，该方法无返回值，第一个参数 start 为开始删除元素的索引，第二个参数 end 为结束删除元素的索引，取值范围为 [start, end)，也就是含头不含尾。

List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
list2.removeRange(1, 3); 
print(list2); // ['周三', '周六', '周天'];

使用 removeRange 方法有两点需要注意，否则会抛出异常:

• start 和 end 必须是有效的，取值范围为 0 <= start <= end <= length。
• 被操作的数组不能是固定长度的数组。

---

11、fillRange()

用相同的值替换指定索引范围的所有元素，取值范围 [start, end)，也就是含头不含尾。

List<String> list = ["周一", "周一", "周二"];
list.fillRange(1, 3, '周末');
print(list); //  ["周一", "周末", "周末"]

索引的范围不能超过数组的长度。

12、replaceRange()

用某个数组替换指定索引范围的所有元素，含头不含尾。

List<String> list = ["周一", "周一", "周二"];
list.replaceRange(1, 3, ['周末', 'hah', 'sss']);
print(list); // [周一, 周末, hah, sss]

List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
list2.replaceRange(1, 3, ['周末', 'hah', 'sss']);
print(list2); // [周三, 周末, hah, sss, 周六, 周天]

13、setRange()

范围替换目标数组中的值，含头不含尾。

void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0])

参数说明：

• start 和 end 表示需要修改的元素索引范围。
• 第三个参数是个数组，用此数组的部分元素替换目标数组中的索引范围的元素，如果此数组中的元素个数不够需要替换的元素个数，会报错。
• 如果第三个参数中数组的长度大于需要替换的元素个数，可以设置第四个参数skipCount，表示跳过 iterable 中的前面几个元素，默认为 0。

// 例1：skipCount默认为0
List<String> list = ["周1", "周2", "周3"];
List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
List targetArr = ['周末', 'hah', 'sss'];
// 下面表示用targetArr中第一个和第二个元素替换list和list2中下标1-3（不包含end）的元素
list.setRange(1, 3, targetArr);
print(list); // [周1, 周末, hah]
list2.setRange(1, 3, ['周末', 'hah', 'sss'], 1);
print(list2); // [周三, 周末, hah, 周六, 周天]

// 例2：设置第四个参数skipCount
list.setRange(0, 2, list2, 2);
// 将 list 中 下标0和1 的元素替换成list2中跳过2个的元素，即下标为2和3的元素（周五和周六）
print(list); // [周五, 周六, 周3]

start 和 end 提供的范围必须有效。如果 0 ≤ start ≤ end ≤ length ，则从 start 到 end 的范围是有效的。空范围(带有 end == start )是有效的。

跳过 skipCount 对象后，iterable 必须有足够的对象来填充从 start 到 end 的范围。

如果 iterable 是此列表，则即使两个范围重叠，该操作也会正确地将最初在 skipCount 到 skipCount + (end - start) 范围内的元素复制到范围 start 到 end 。

List<String> list = ["周1", "周2", "周3"];
list.setRange(0, 2, list);
print(list); // ["周1", "周2", "周3"]

14、setAll()

从指定索引位置开始，使用第二个数组中的元素依次替换掉第一个数组中的元素。

语法： void setAll(int index, Iterable<E> iterable)

用 iterable 的对象覆盖元素。

iterable 的元素被写入此列表，从位置 index 开始。此操作不会增加列表的长度。

index 必须为非负且不大于 length 。

List<String> list = ["周1", "周2", "周3"];
List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
list2.setAll(1, list);
print(list2); // [周三, 周1, 周2, 周3, 周天]

注意: index + list.length <= list2.length ,否则会报错。即 iterable的长度 + index 不能大于要修改的数组的长度。如下：

List<String> list = ["周1", "周2", "周3"];
List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
// list长度 3 < (index 1 + list2.length = 5) = 6
list.setAll(1, list2); // RangeError: Invalid value: Not in inclusive range
// index 3 + list.length 3 = 6 > list2.length = 5
list2.setAll(3, list); // RangeError: Invalid value: Not in inclusive range

---

15、elementAt()

查找指定索引位置的元素。

语法： E elementAt(int index)

该方法返回指定索引位置的元素，参数为要查找元素的下标。

List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
print(list2.elementAt(2)); // 周五

16、contains()

判断数组中是否含有指定的元素。该方法的返回值为 bool 类型。

List<String> list = ["周1", "周2", "周3"];
print(list.contains('周1')); // true
print(list.contains('周')); // false

17、indexOf()

获取指定元素在数组中的索引。

语法： int indexOf(E element, [int start = 0]);

返回值为 int ，第一个参数为要查找的元素，第二个参数为从哪个索引开始查找，是可选参数，默认为 0。

List<String> list2 = ['周三', '周四', '周五', '周六', '周天'];
int Fri = list2.indexOf('周五'); 
int Sun = list2.indexOf('周天', 2); 
print(Fri); // 2 
print(Sun); // 4

18、lastIndexOf()

获取元素最后一次出现在数组中的索引。

语法： int lastIndexOf(E element, [int start]);

和 indexOf 方法一样，只不过是可以认为从后向前倒序查找。

List<String> list2 = ['周三', '周四', '周五', '周三', '周六', '周天'];
int Wed = list2.lastIndexOf('周三');
print(Wed); // 3

注意： 为了方便理解，可以认为 lastIndexOf 是从后往前查找，但不要误以为索引也是从后往前从0开始了。

19、indexWhere()

返回数组中第一个满足条件的元素的索引。

语法： int lastIndexWhere(bool test(E element), [int? start])

返回值为 int ，第一个参数为要查找的条件，返回 bool，如果存在满足条件的元素返回 true，反之返回 false 。第二个参数为从哪个索引开始查找，是可选参数，默认为 0。

List<String> list2 = ['周三', '周四', '周五', '周三', '周六', '周天'];
int a = list2.indexWhere((e) => e == "周三");
int b = list2.indexWhere((e) => e == "周三", 2);
int c = list2.indexWhere((e) => e == "周日");
print(a); // 0
print(b); // 3
print(c); // -1

20、lastIndexWhere()

返回数组中最后一个满足条件的元素的索引。

int lastIndexWhere(bool test(E element), [int? start]);

和 indexWhere()方法一样，只不过可以理解为是从后向前倒序查找。

List<String> list2 = ['周三', '周四', '周五', '周三', '周六', '周天'];
print(list2.lastIndexWhere((element) => element == "周三")); // 3

21、where()

根据指定的条件，筛选每个元素，符合条件的元素组成一个新的数组。

Iterable<E> where(bool test(E element)) => WhereIterable<E>(this, test);

返回值为 Iterable，参数返回值为 bool 类型，符合条件的为 true ，将元素添加到一个新的 Iterable 中。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> li1 = arr.where((e) => e > 10); 
// 注意li1是Iterable 类型的
print(li1); // (12, 13, 88)
List<int> li2 = arr.where((e) => e > 10).toList();
print(li2); // [12, 13, 88]

注意上面例子中 li1 是 Iterable 类型的，虽然 List 继承于 Iterable ，但是如果想要得到一个数组，需要用 toList() 转化成数组。

22、firstWhere()

返回第一个满足条件的元素：

E firstWhere(bool test(E element), {E orElse()}) 

返回值为泛型。参数 test 为指定的条件，返回值为 bool ，第二个 orElse 为可选参数，是当数组中没有满足指定条件的元素设置的自定义值。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
print(arr.firstWhere((e) => e > 10)); // 12
print(arr.firstWhere((e) => e > 10, orElse: () => 999)); // 12
print(arr.firstWhere((e) => e > 100, orElse: () => 999)); // 999

23、lastWhere()

返回最后一个满足条件的元素。

E lastWhere(bool test(E element), {E orElse()})

同firstWhere():

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
print(arr.lastWhere((e) => e > 10)); // 88
print(arr.lastWhere((e) => e > 10, orElse: () => 999)); // 88
print(arr.lastWhere((e) => e > 100, orElse: () => 999)); // 999

24、singleWhere()

返回唯一满足指定条件的元素：

E lastWhere(bool test(E element), {E orElse()})

返回值为泛型，参数 test 为指定的条件，返回值为 bool，第二个参数 orElse 为可选参数，是当数组中没有满足指定条件的元素设置的自定义值。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
print(arr.singleWhere((e) => e > 70)); // 88
print(arr.singleWhere((e) => e > 10)); // 报错：Bad state: Too many elements
print(arr.singleWhere(
  (e) => e > 10,
  orElse: () => 110,
)); // 报错
 print(arr.singleWhere((e) => e > 100, orElse: () => 110)); // 110

25、retainWhere()

保留满足条件的元素，会改变了原数组，无返回值。

void retainWhere(bool test(E element));

例子：

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
arr.retainWhere((e) => e > 10); 
print(arr); // [12, 13, 88]

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
arr.retainWhere((e) => e > 90); 
print(arr); // []

26、any()

判断数组中是否有满足条件的元素，返回值bool，参数的返回值也为 bool。

bool any(bool test(E element))

any 方法迭代判断数组中的每一个元素，只要有一个元素符合指定的条件则返回 true，反之，只要有一个元素不符合指定的条件则返回 false 。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
bool a = arr.any((e) => e > 90); 
print(a); // false
print(arr.any((e) => e > 10)); // true

27、every()

Dart 判断数组中是否每个元素都满足指定的条件用 every() 方法，源代码定义如下:

bool every(bool test(E element))

方法的返回值为 bool，参数的返回值也是 bool 。

every 方法迭代判断数组中的每一个元素，如果每个元素都符合指定的条件则返回 true，反之，只要有一个元素不符合指定的条件则返回 false 。和 js 中 every() 方法相似。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
bool a = arr.every(e => e > 0);
print(a); // true

28、take()

从索引0的位置处，取指定数量的元素：

Iterable<E> take(int count) {
  return TakeIterable<E>(this, count);
}

返回值为 Iterable，参数为从索引 0 位置处，取多少个元素。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> a = arr.take(3);
print(a); // (5, 8, 7)

如果获取的长度超过了数组的长度，也不会报错，会返回数组中的所有元素。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> a = arr.take(100);
print(a); // (5, 8, 7, 12, 1, 13, 2, 88)

29、takeWhile()

从索引0开始查询满足条件的元素，直到出现第一个不符合条件的元素停止，返回前面符合条件的所有元素：

Iterable<E> takeWhile(bool test(E value)) {
  return TakeWhileIterable<E>(this, test);
}

返回值为 Iterable ， 参数 test 为指定条件，满足返回 true，反之返回 false。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> a = arr.takeWhile((e) => e > 1);
print(a); // (5, 8, 7, 12)

30、skip()

跳过指定个数的元素，返回后面的元素。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> a = arr.skip(3);
print(a); // (12, 1, 13, 2, 88)

31、skipWhile()

根据指定条件，找到第一个不符合条件的元素，然后将该元素及后面的所有元素返回:

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> a = arr.skipWhile((e) => e < 10);
print(a); // (12, 1, 13, 2, 88)

32、sublist()

从指定的索引处截取数组。含头不含尾。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
List<int> a = arr.sublist(3);
print(a); // [12, 1, 13, 2, 88]

List<int> b = arr.sublist(2, 5);
print(b); // [7, 12, 1]

33、getRange()

截取指定索引范围内的元素:含头不含尾。

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable<int> a = arr.getRange(2, 5);
print(a); // (7, 12, 1)

34、whereType()

从混合类型的数组中，筛选出指定类型的元素:

list blendArr = ["a", 1, 8, true, "20", {'a': 1}];
Iterable<String> str = blendArr.whereType();
print(str); // (a, 20)

Iterable<bool> boolean = blendArr.whereType();
print(boolean); // (true)

Iterable<int> number = blendArr.whereType();
print(number); // (1, 8)

Iterable<Map> obj = blendArr.whereType();
print(obj); // ({a: 1})

---

35、forEach()

遍历数组中的元素：

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
arr.forEach((e) => print(e)); // 5, 8, 7, 12, 1, 13, 2, 88

36、map()

遍历数组中的所有元素，可以对元素进行处理，并返回新的 Iterable:

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Iterable a = arr.map((e) => e > 10);
print(a); // (false, false, false, true, false, true, false, true)

Iterable b = arr.map((e) => e % 2 == 0 ? '偶数' : '奇数');
print(b); // (奇数, 偶数, 奇数, 偶数, 奇数, 奇数, 偶数, 偶数)

37、toSet()

将List转化为Set，得到一个去重后的元素：

List<int> arr1 = [1, 3, 5, 2, 3, 1];
print(arr1.toSet()); // {1, 3, 5, 2}

38、asMap()

将 List 转换为 Map， key为原数组的索引，value 为原数组的元素：

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
Map map = arr.asMap();
print(map); // {0: 5, 1: 8, 2: 7, 3: 12, 4: 1, 5: 13, 6: 2, 7: 88}

39、sort()

数组排序(原数组发生改变):

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
arr.sort();
print(arr); // [1, 2, 5, 7, 8, 12, 13, 88]

40、join()

用指定的字符链接数组中的每一个元素，返回String：

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
print(arr.join()); // 58712113288
print(arr.join('/')); // 5/8/7/12/1/13/2/88
print(arr.join('-')); // 5-8-7-12-1-13-2-88

41、cast()

将一个数组的类型映射给未指定数据类型的数组：

List<int> arr = [5, 8, 7, 12, 1, 13, 2, 88];
var newArr = arr.cast();
newArr.add(2);
print(arr); // [5, 8, 7, 12, 1, 13, 2, 88, 2]
newArr.add('add');
// 提示无法将 String 类型的数添加到 int 类型的数组中
print(arr); // Unhandled exception:type 'String' is not a subtype of type 'int' in type cast

42、reduce()

用指定的函数方式对数组的元素进行连续操作，并将结果返回：

List<int> arr = [1, 2, 3, 4];
var total = arr.reduce((a, b) => a + b);
print(total);

43、fold()

根据一个现有的数组和一个初始参数值，指定参数条件操作现有数组的所有元素，并返回处理的结果：

List<int> arr = [1, 2, 3, 4];
int total = arr.fold(5, (a, b) => (a + b));
print(total); // 15

44、expand()

根据现有数组，指定一个处理方式，返回 Iterable:

List<int> arr = [1, 2, 3, 4];
print(arr.expand((e) => [e + 1])) // (2, 3, 4, 5)
print(arr.expand((e) => [e + 1, e + 2])); // (2, 3, 3, 4, 4, 5, 5, 6)

45、toList()

可遍历对象可以通过调用toList将其转换成为List。

List<int> arr = [1, 2, 3, 4];
print(arr.expand((e) => [e + 1]).toList()); // [2, 3, 4, 5]

46、shuffle()

随机排列指定数组，会修改原数组：

List<int> arr = [1, 2, 3, 4];
arr.shuffle();
print(arr); // [3, 1, 2, 4]

47、followedBy()

将自身和参数内list合成一个List，返回 Iterable:

List<int> arr = [1, 2, 3, 4];
List<int> arr = [5, 6, 7];
var ot = arr.followedBy(arr2);
print(ot); // (1, 2, 3, 4, 5, 6, 7)

48、toString()

将数组转化为字符串数组：

 List<int> arr = [1, 2, 3, 4];
print(arr.toString()); // [1, 2, 3, 4]

终于写完了，属实不易。希望可以帮到你，记得点个关注，给个赞👍。