参考链接#

List#

在其他语言中大部分的List其实都是以数组的形态存在，但是dart的List其实是列表的形态存在。申明方式基本与其他语言没有差别

1
var list = [1, 2, 3];
2
var list = ['Car', 'Boat', 'Plane'];
3

4
//编译时常量List
5
var constantList = const [1, 2, 3];
6
// constantList[1] = 1; // This line will cause an error.

Set#

Set和java的Set是差不多，都是无序集合，并且每个元素都是唯一的。因为Set和Map在dart中都是以{}表示，所以当你创建空集忘记添加Set申明时，默认会被识别为Map<dynamic, dynamic>

1
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
2
//空Set
3
var names = <String>{};
4
// Set<String> names = {}; // This works, too.
5

6
//因为Set和Map在dart中都是以{}表示，所以当你创建空集忘记添加Set申明时，默认会被识别为Map<dynamic, dynamic>
7
 var names = {}; // Creates a map, not a set.
8

9
 //添加元素
10
 var elements = <String>{};
11
elements.add('fluorine');
12
elements.addAll(halogens);
13
assert(elements.length == 5);
14

15
//编译时常量
16
final constantSet = const {
17
  'fluorine',
18
  'chlorine',
19
  'bromine',
20
  'iodine',
21
  'astatine',
22
};
23
// constantSet.add('helium'); // This line will cause an error.

Map#

与大多数语言一样，是键值对的集合

1
var gifts = {
2
  // Key:    Value
3
  'first': 'partridge',
4
  'second': 'turtledoves',
5
  'fifth': 'golden rings',
6
};

但是这里要注意，即使你没有申明里面元素的类型，但是你一旦申明了一个Map，编译器会自动按元素的类型，给创建一个带有泛型的Map，可以看下面，所以当你添加错误的类型时，会导致编译错误

1
  var nobleGases = {2: 'helium', 10: 'neon', 18: 'argon'};
2
  nobleGases[10] = 'test update'; //update existing element
3
  nobleGases[19] = 'neon'; //add new element
4
  //nobleGases['test'] = 'test';//这里添加了字符串作为key会编译错误，虽然申明没有具体申明类型，但是默认key就是只能是数字
5
  //nobleGases[20] = 100;//这里也会编译错误，因为value必须是字符串
6
  print(nobleGases);//{2: helium, 10: test update, 18: argon, 19: neon}
7
  print(nobleGases[2]);//helium

也可以这里申明一个map

1
var gifts = Map<String, String>();
2
gifts['first'] = 'partridge';
3
gifts['second'] = 'turtledoves';
4
gifts['fifth'] = 'golden rings';
5
print(gifts['first']);//partridge
6
var nobleGases = Map<int, String>();
7

8
assert(gifts['test'] == null);//没有找到会返回空，所以判断结果是true
9

10
assert(gifts.length == 2);
11

12
nobleGases[2] = 'helium';
13
nobleGases[10] = 'neon';
14
nobleGases[18] = 'argon';
15

16
//编译时常量
17
final constantMap = const {2: 'helium', 10: 'neon', 18: 'argon'};
18

19
// constantMap[2] = 'Helium'; // This line will cause an error.

集合中元素的类型可以有哪些#

官网中写了有很多种，跟其他语言差不多，比较有意思是表达式元素，只有在运行时才会被添加集合中。

null-aware elements 可按是否空值来添加元素#

absentValue作为第二个元素时，被加了表达式，如果为空就不会被加到items中。但是在第四个元素中，因为没有加表达式所以直接以空值作为元素

1
int? absentValue = null;
2
int? presentValue = 3;
3
var items = [
4
  1,
5
  ?absentValue,
6
  ?presentValue,
7
  absentValue,
8
  5,
9
]; // [1, 3, null, 5]
10

11

12
//map下一些特殊例子，总结就是在Map中，无论是key还是value加表达式，都会影响元素是否添加成功
13
String? presentKey = 'Apple';
14
String? absentKey = null;
15

16
int? presentValue = 3;
17
int? absentValue = null;
18

19
var itemsA = {presentKey: absentValue}; // {Apple: null}
20
var itemsB = {presentKey: ?absentValue}; // key不为空，但是Value空时，map的内容是{}
21

22
var itemsC = {absentKey: presentValue}; // {null: 3}
23
var itemsD = {?absentKey: presentValue}; // 同样如果问号表达式在key上面，一样是空集{}
24

25
var itemsE = {absentKey: absentValue}; // 但是没有加表礞式，就不一样了，会添加空元素{null: null}
26
var itemsF = {?absentKey: ?absentValue}; // {}

Spread elements可展开元素#

...<变量>代表将这个变量展开，并将所有元素分别添加到新的集合中 ...?<变量>加了问号可判断变是否为空，空的话就不会展开集合了。

1
var a = [1, 2, null, 4];
2
var items = [0, ...a, 5]; // [0, 1, 2, null, 4, 5]
3

4
//加了问号可判断变是否为空，空的话就不会展开集合了。
5
List<int>? a = null;
6
var b = [1, null, 3];
7
var items = [0, ...?a, ...?b, 4]; // [0, 1, null, 3, 4]

if 元素#

语法也比较反直觉

1
//当Data 符合相应的数据类型时，对将值赋给对应的新变量，最后拼接的字符串成为新元素，如下
2
Object data = 123;
3
var typeInfo = [
4
  if (data case int i) 'Data is an integer: $i',
5
  if (data case String s) 'Data is a string: $s',
6
  if (data case bool b) 'Data is a boolean: $b',
7
  if (data case double d) 'Data is a double: $d',
8
]; // [Data is an integer: 123, Data is a double: 123]
9

10

11
//“length: var wordLength”的意思是将word.lenght赋值给wordLength
12
//检查word是否为String类型，并创建一个变量wordLength
13
var word = 'hello';
14
var items = [
15
  1,
16
  if (word case String(length: var wordLength)) wordLength,
17
  3,
18
]; // [1, 5, 3]
19

20

21
//之前讲过“_”是一个占位符、通配符，在这里表示忽略对应值的比较
22
//int qty这里表示如果是第二个元素是整型，则条件成立
23
var orderDetails = ['Apples', 12, ''];
24
var summary = [
25
  'Product: ${orderDetails[0]}',
26
  if (orderDetails case [_, int qty, _]) 'Quantity: $qty',
27
  if (orderDetails case [_, _, ''])
28
    'Delivery: Not Started'
29
  else
30
    'Delivery: In Progress',
31
]; // [Product: Apples, Quantity: 12, Delivery: Not Started]
32

33

34
//else if比较好理解
35
var a = 'apple';
36
var b = 'orange';
37
var c = 'mango';
38
var items = [
39
  0,
40
  if (a == 'apple') 1 else if (a case 'mango') 10,
41
  if (b case 'pear') 2 else if (b == 'mango') 20,
42
  if (c case 'apple') 3 else if (c case 'mango') 30,
43
  4,
44
]; // [0, 1, 30, 4]

for 元素#

比较好理解

1
var numbers = [2, 3, 4];
2
var items = [1, for (var n in numbers) n * n, 7]; // [1, 4, 9, 16, 7]
3
var items = [1, for (var x = 5; x > 2; x--) x, 7]; // [1, 5, 4, 3, 7]
4
var items = [1, for (var x = 2; x < 4; x++) x, 7]; // [1, 2, 3, 7]

控制流元素#

1
//只有偶数存在number中时，才作为元素
2
var numbers = [1, 2, 3, 4, 5, 6, 7];
3
var items = [
4
  0,
5
  for (var n in numbers)
6
    if (n.isEven) n,
7
  8,
8
]; // [0, 2, 4, 6, 8]
9

10

11
//只有符合条件时，才去展开集合，其实集合里面也嵌入了表达式
12

13
var nestItems = true;
14
var ys = [1, 2, 3, 4];
15
var items = [
16
  if (nestItems) ...[
17
    for (var x = 0; x < 3; x++)
18
      for (var y in ys)
19
        if (x < y) x + y * 10,
20
  ],
21
]; // [10, 20, 30, 40, 21, 31, 41, 32, 42]