内建类型

Dart 语言支持以下内建类型:

  • Number
  • String
  • Boolean
  • List (也被称为Array)
  • Map
  • Set
  • Rune (用于在字符串中表示 Unicode 字符)
  • Symbol

这些类型都可以被初始化为字面量。

因为在 Dart 所有的变量终究是一个对象（一个类的实例）， 所以变量可以使用 构造涵数 进行初始化。 一些内建类型拥有自己的构造函数。

Number

Dart 中的Number有两种类型：

  • int类型： 整数值不大于64位，具体取决于平台。
  • double类型： 64位(双精度)浮点数，依据IEEE 754标准。

以下是将字符串转换为数字的方法，反之亦然：

  1. // String -> int
  2. var one = int.parse('1');
  3. assert(one == 1);
  5. // String -> double
  6. var onePointOne = double.parse('1.1');
  7. assert(onePointOne == 1.1);
  9. // int -> String
  10. String oneAsString = 1.toString();
  11. assert(oneAsString == '1');
  13. // double -> String
  14. String piAsString = 3.14159.toStringAsFixed(2);
  15. assert(piAsString == '3.14');

String

Dart 字符串是一组 UTF-16 单元序列。 字符串通过单引号或者双引号创建。

  1. var s1 = 'hello';
  2. var s2 = "Dart";
  3. var s3 = 'It\'s easy to escape the string delimiter.';
  4. var s4 = "It's even easier to use the other delimiter.";

字符串可以通过 ${expression} 的方式内嵌表达式。 如果表达式是一个标识符，则 {} 可以省略。 在 Dart 中通过调用就对象的 toString() 方法来得到对象相应的字符串。

  1. var s = 'lynn';
  2. assert('my name is $s' == 'my name is' + 'lynn');

可以使用 + 运算符来把多个字符串连接为一个，也可以把多个字面量字符串写在一起来实现字符串连接：

  1. var s1 = 'Dart '
  2.     'hello';
  3. assert(s1 == 'Dart hello');
  5. var s2 = 'The + operator ' + 'works, as well.';
  6. assert(s2 == 'The + operator works, as well.');

使用连续三个单引号或者三个双引号实现多行字符串对象的创建：

  1. var s1 = '''
  2. You can create
  3. multi-line strings like this one.
  4. ''';
  6. var s2 = """This is also a
  7. multi-line string.""";

使用 r 前缀，可以创建 “原始 raw” 字符串：

  1. var s = r"In a raw string, even \n isn't special.";

一个编译时常量的字面量字符串中，如果存在插值表达式，表达式内容也是编译时常量， 那么该字符串依旧是编译时常量。 插入的常量值类型可以是 null，数值，字符串或布尔值。

  1. // const 类型数据
  2. const aConstNum = 0;
  3. const aConstBool = true;
  4. const aConstString = 'a constant string';
  6. // 非 const 类型数据
  7. var aNum = 0;
  8. var aBool = true;
  9. var aString = 'a string';
  10. const aConstList = [1, 2, 3];
  12. const validConstString = '$aConstNum $aConstBool $aConstString'; //const 类型数据
  13. // const invalidConstString = '$aNum $aBool $aString $aConstList'; //非 const 类型数据

Boolean

Dart 使用 bool 类型表示布尔值。 Dart 只有字面量 true and false 是布尔类型， 这两个对象都是编译时常量。

Dart 的类型安全意味着不能使用 if (nonbooleanValue) 或者 assert (nonbooleanValue)。 而是应该像下面这样，明确的进行值检查：

  1. // 检查空字符串。
  2. var fullName = '';
  3. assert(fullName.isEmpty);
  5. // 检查 0 值。
  6. var hitPoints = 0;
  7. assert(hitPoints <= 0);
  9. // 检查 null 值。
  10. var unicorn;
  11. assert(unicorn == null);
  13. // 检查 NaN 。
  14. var iMeantToDoThis = 0 / 0;
  15. assert(iMeantToDoThis.isNaN);

List

几乎每种编程语言中最常见的集合可能是 array 或有序的对象集合。 在 Dart 中的 Array 就是 List 对象， 通常称之为 List 。

Dart 中的 List 字面量非常像 JavaScript 中的 array 字面量。 下面是一个 Dart List 的示例：

  1. var list = [1, 2, 3]; // Dart 类型推断 list 的类型为 List<int> ， 如果尝试将非整数对象添加到此 List 中， 则分析器或运行时会引发错误。

List 的下标索引从 0 开始，第一个元素的索引是 0。 list.length - 1 是最后一个元素的索引。 访问 List 的长度和元素与 JavaScript 中的用法一样：

  1. var list = [1, 2, 3];
  2. assert(list.length == 3);
  3. assert(list[1] == 2);
  5. list[1] = 1;
  6. assert(list[1] == 1);

在 List 字面量之前添加 const 关键字，可以定义 List 类型的编译时常量：

  1. var constantList = const [1, 2, 3];
  2. // constantList[1] = 1; // 取消注释会引起错误。

扩展操作符(…)

  1. // 扩展操作符(...)
  2. var list = [1, 2, 3];
  3. var list2 = [0, ...list];
  4. assert(list2.length == 4);

空感知扩展操作符(…?)

  1. var list;
  2. var list2 = [0, ...?list];
  3. assert(list2.length == 1);

集合中的 if 操作

  1. var nav = [
  2.   'Home',
  3.   'Furniture',
  4.   'Plants',
  5.   if (promoActive) 'Outlet'
  6. ];

集合中的 for 操作

  1. var listOfInts = [1, 2, 3];
  2. var listOfStrings = [
  3.   '#0',
  4.   for (var i in listOfInts) '#$i'
  5. ];
  6. assert(listOfStrings[1] == '#1');

Sets

Set 字面量来创建一个 Set 集合的方法：

  1. var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

还可以这样创建：

  1. var names = <String>{}; // 类型+{}的形式创建Set。
  2. // Set<String> names = {}; // 声明类型变量的形式创建 Set (This works, too).

Set 的方法：

  1. var elements = <String>{};
  2. elements.add('fluorine'); // 添加一个
  3. elements.addAll(halogens); // 添加全部

使用 .length 可以获取 Set 中元素的数量。

可以在 Set 字面量前添加 const 关键字创建一个 Set 编译时常量：

  1. final constantSet = const {
  2.   'fluorine',
  3.   'chlorine',
  4.   'bromine',
  5.   'iodine',
  6.   'astatine',
  7. };
  8. // constantSet.add('helium'); // This line will cause an error.

从 Dart 2.3 开始，Set 可以像 List 一样支持使用扩展操作符（... 和 ...?）以及 Collection If 和 Collection For 操作。

Maps

Map 是用来关联 keys 和 values 的对象。

keys 和 values 可以是任何类型的对象。

在一个 Map 对象中一个 key 只能出现一次，但是 value 可以出现多次。

Map 是一个键值对相关的对象。

其中键和值都可以是任何类型的对象。

每个 键 只能出现一次但是 值 可以重复出现多次。

Dart 中 Map 提供了 Map 字面量以及 Map 类型两种形式的 Map。

  1. var gifts = {
  2.   // 键:    值
  3.   'first': 'partridge',
  4.   'second': 'turtledoves',
  5.   'fifth': 'golden rings'
  6. };
  8. var nobleGases = {
  9.   2: 'helium',
  10.   10: 'neon',
  11.   18: 'argon',
  12. };

你也可以使用 Map 的构造器创建 Map：

  1. var gifts = Map();
  2. gifts['first'] = 'partridge';
  3. gifts['second'] = 'turtledoves';
  4. gifts['fifth'] = 'golden rings';
  6. var nobleGases = Map();
  7. nobleGases[2] = 'helium';
  8. nobleGases[10] = 'neon';
  9. nobleGases[18] = 'argon';

向现有的 Map 中添加键值对与 JavaScript 的操作类似：

  1. var gifts = {'first': 'partridge'};
  2. gifts['fourth'] = 'calling birds'; // 添加键值对 (Add a key-value pair)

从一个 Map 中获取一个值的操作也与 JavaScript 类似。

  1. var gifts = {'first': 'partridge'};
  2. assert(gifts['first'] == 'partridge');

如果检索的 Key 不存在于 Map 中则会返回一个 null：

  1. var gifts = {'first': 'partridge'};
  2. assert(gifts['fifth'] == null);

使用 .length 可以获取 Map 中键值对的数量：

  1. var gifts = {'first': 'partridge'};
  2. gifts['fourth'] = 'calling birds';
  3. assert(gifts.length == 2);

在一个 Map 字面量前添加 const 关键字可以创建一个 Map 编译时常量：

  1. final constantMap = const {
  2.   2: 'helium',
  3.   10: 'neon',
  4.   18: 'argon',
  5. };
  7. // constantMap[2] = 'Helium'; // This line will cause an error.

Map 可以像 List 一样支持使用扩展操作符（... 和 ...?）以及集合的 if 和 for 操作。