Dart语法学习-数据类型

一、Dart 语言对以下类型具有支持

Numbers (int, double)
Strings (String)
Booleans (bool)
Lists (List, also known as arrays)
Sets (Set)
Maps (Map)
Runes (Runes; often replaced by the characters API)
Symbols (Symbol)
The value null (Null)

Dart 要求以 main 函数作为执行的入口。

1.Numbers

Dart 应用程序通常针对多个平台。 例如，Flutter 应用程序可能针对 iOS、Android 和 Web。 代码可以相同，只要应用程序不依赖特定于平台的库或以平台相关的方式使用数字。

Dart 的数值类型 num，只有两种子类：即 64 位 int 和符合 IEEE 754 标准的 64 位 double。前者代表整数类型，而后者则是浮点数的抽象。

除了常见的基本运算符，比如 +、-、*、/，以及位运算符外，你还能使用继承自 num 的 abs()、round() 等方法，来实现求绝对值、取整的功能。

常见的运算符也是继承自 num。

Dart numbers 有两种形式:

int

不大于 64 位的整数值，具体取决于平台。 在本机平台上，值可以从 -2^63到 2^63 - 1。在 Web 上，整数值表示为 JavaScript 数字（没有小数部分的 64 位浮点值）并且可以从 -2^53 到 2^53 - 1。

double

64 位（双精度）浮点数，由 IEEE 754 标准指定。 int 和 double 都是 num 的子类型。 num 类型包括基本运算符，例如 +、-、/ 和 *，您还可以在其中找到 abs()、ceil() 和 floor() 以及其他方法。 （按位运算符，例如 >>，在 int 类中定义。）如果 num 及其子类型没有您要查找的内容，dart:math 库可能有。 整数是没有小数点的数字。 以下是定义整数文字的一些示例：

var x = 1;
var hex = 0xDEADBEEF;

 如果数字包含小数，则为双精度数。 以下是定义双字面量的一些示例：

var y = 1.1;
var exponents = 1.42e5;

您还可以将变量声明为 num。 如果这样做，变量可以同时具有整数和双精度值。

num x = 1; // x can have both int and double values
x += 2.5;

 必要时整数文字会自动转换为双精度数：

double z = 1; // Equivalent to double z = 1.0.

将字符串与数字相互转换的方法

void main() {
  var one = int.parse('1');
  print(one);
  var two = double.parse('2');
  print(two);
  var str = 1.toString();
  print(str);
  var str2 = 3.14159.toStringAsFixed(2);
  print(str2);
}

Log
1
2.0
1
3.14

int 类型指定传统的移位（<<、>>、>>>）、补码（~）、与（&）、或（|）和异或（^）运算符，这些运算符在位运算中对于操作和屏蔽标志很有用。

void main() {
  print((3 << 1) == 6);
  print((3 | 4) == 7);
  print((3 & 4) == 0);
}

Log
true
true
true

文字数字是编译时常量。 许多算术表达式也是编译时常量，只要它们的操作数是计算结果为数字的编译时常量。

const msPerSecond = 1000;
const secondsUntilRetry = 5;
const msUntilRetry = secondsUntilRetry * msPerSecond;

2.Strings

Dart 的 String 由 UTF-16 的字符串组成。和 JavaScript 一样，构造字符串字面量时既能使用单引号也能使用双引号，还能在字符串中嵌入变量或表达式：你可以使用 ${express} 把一个表达式的值放进字符串。而如果是一个标识符，你可以省略{}。

Dart 字符串（字符串对象）包含一系列 UTF-16 代码单元。 可以使用单引号或双引号来创建字符串：

var s1 = 'Single quotes work well for string literals.';
var s2 = "Double quotes work just as well.";
var s3 = 'It\'s easy to escape the string delimiter.';
var s4 = "It's even easier to use the other delimiter.";

 可以使用 ${expression} 将表达式的值放入字符串中。如果表达式是标识符(Strings)，则可以跳过 {}。 为了获取对象对应的字符串，Dart 调用对象的 toString() 方法。

var s = 'string interpolation';

assert('Dart has $s, which is very handy.' ==
    'Dart has string interpolation, '
        'which is very handy.');
assert('That deserves all caps. '
        '${s.toUpperCase()} is very handy!' ==
    'That deserves all caps. '
        'STRING INTERPOLATION is very handy!');

== 运算符测试两个对象是否等价。 如果两个字符串包含相同的代码单元序列，则它们是等价的。

可以使用相邻的字符串文字或 + 运算符连接字符串：

void main() {
  var s1 = 'String '
      'concatenation'
      " works even over line breaks.";
  print(s1 ==
      'String concatenation works even over '
          'line breaks.');

  var s2 = 'The + operator ' + 'works, as well.';
  print(s2 == 'The + operator works, as well.');
}

Log
true
true

 创建多行字符串的方法：使用带有单引号或双引号的三重引号：

void main() {
  var s1 = '''
You can create
multi-line strings like this one.
''';
  print(s1);

  var s2 = """This is also a
multi-line string.""";
  print(s2);
}

Log
This is also a
multi-line string.

 可以通过在其前面加上 r 来创建“raw”字符串

void main() {
  var s = r'In a raw string, not even \n gets special treatment.';
  print(s);
}

Log
In a raw string, not even \n gets special treatment.

 文字字符串是编译时常量，只要任何内插表达式是计算为 null 或数字、字符串或布尔值的编译时常量。

// These work in a const string.
const aConstNum = 0;
const aConstBool = true;
const aConstString = 'a constant string';

// These do NOT work in a const string.
var aNum = 0;
var aBool = true;
var aString = 'a string';
const aConstList = [1, 2, 3];

const validConstString = '$aConstNum $aConstBool $aConstString';
// const invalidConstString = '$aNum $aBool $aString $aConstList';

 

 

Booleans

为了表示布尔值，Dart 有一个名为 bool 的类型。 只有两个对象具有 bool 类型：布尔文字 true 和 false，它们都是编译时常量。

为了表示布尔值，Dart 使用了一种名为 bool 的类型。在 Dart 里，只有两个对象具有 bool 类型：true 和 false，它们都是编译时常量。

Dart 的类型安全意味着你不能使用像 if (nonbooleanValue) 或 assert (nonbooleanValue) 这样的代码。 相反，显式检查值，如下所示：

void main() {
  // Check for an empty string.
  var fullName = '';
  print(fullName.isEmpty);

// Check for zero.
  var hitPoints = 0;
  print(hitPoints <= 0);

// Check for null.
  var unicorn;
  print(unicorn == null);

// Check for NaN.
  var iMeantToDoThis = 0 / 0;
  print(iMeantToDoThis.isNaN);
}
Log:
true
true
true
true

在 Dart 中的对应实现是 List 和 Map，统称为集合类型。

容器里的元素也需要有类型，比如上述代码中 arr2 的类型是 List<int>，map2 的类型则为 Map<String, String>。Dart 会自动根据上下文进行类型推断，所以你后续往容器内添加的元素也必须遵照这一类型。

如果编译器自动推断的类型不符合预期，我们当然可以在声明时显式地把类型标记出来，不仅可以让代码提示更友好一些，更重要的是可以让静态分析器帮忙检查字面量中的错误，解除类型不匹配带来的安全隐患或是 Bug。

Lists

Dart 列表文字由逗号分隔的表达式或值列表表示，括在方括号 ([]) 中。

void main() {
  var list = [1,2,3];
  print(list);
}

Log:
[1, 2, 3]

注意：Dart 推断列表的类型为 List<int>。 如果您尝试将非整数对象添加到此列表，分析器或运行时会引发错误。

在 Dart 集合文字的最后一项之后添加一个逗号。 这个尾随逗号不会影响集合，但它可以帮助防止复制粘贴错误。

var list = [
  'Car',
  'Boat',
  'Plane',
];

列表使用从零开始的索引，其中 0 是第一个值的索引，list.length - 1 是最后一个值的索引。 您可以使用 .length 属性获取列表的长度，并使用下标运算符 ([]) 访问列表的值：

void main() {
  var list = [1, 2, 3];
  print(list.length == 3);
  print(list[1] == 2);

  list[1] = 1;
  print(list[1] == 1);
}

Log
true
true
true

 要创建一个作为编译时常量的列表，请在列表字面量之前添加 const：

void main() {
  var constantList = const [1, 2, 3];
  print(constantList);
}
[1, 2, 3]

Dart 支持扩展运算符 (...) 和 null 感知扩展运算符 (...?)，它们提供了一种将多个值插入集合的简洁方法。

例如，可以使用扩展运算符 (...) 将一个列表的所有值插入到另一个列表中：

void main() {
  var list = [1, 2, 3];
  var list2 = [0, ...list];
  print(list2.length == 4);
  print(list2);
}
Log:
true
[0, 1, 2, 3]

如果展开运算符右侧的表达式可能为空，则可以通过使用可识别空值的展开运算符（...？）来避免异常：

void main() {
  var list = null;
  var list2 = [0, ...?list];
  print(list2.length == 1);
  print(list2);
}

Log
true
[0]

Dart 还提供了 collection if 和 collection for，您可以使用它们来使用条件 (if) 和重复 (for) 构建集合。

下面是一个使用 collection if 来创建包含三个或四个项目的列表的示例：

void main() {
  var promoActive = true;
  var nav = ['Home', 'Furniture', 'Plants', if (promoActive) 'Outlet'];
  print(nav);
}

Log
[Home, Furniture, Plants, Outlet]

这是一个在将列表项添加到另一个列表之前使用 collection for 操作列表项的示例：

void main() {
  var listOfInts = [1, 2, 3];
  var listOfStrings = ['#0', for (var i in listOfInts) '#$i'];
  print(listOfStrings[1] == '#1');
  print(listOfStrings);
}
Log
true
[#0, #1, #2, #3]

Sets

Dart 中的Set是唯一项的无序集合。 Dart 对Set的支持由{}和 Set 类型提供。

这是一个简单的 Dart Set，使用{}创建：

void main() {
  var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
  print(halogens);
}

Log
{fluorine, chlorine, bromine, iodine, astatine}

注意：Dart 推断 halogens 的类型为 Set<String>。 如果您尝试将错误类型的值添加到集合中，分析器或运行时会引发错误。

要创建一个空集，请在 {} 前面加上一个类型参数，或将 {} 分配给 Set 类型的变量：

void main() {
  var names = <String>{};
  print(names.length);
  Set<String> names2 = {}; // This works, too.
  print(names2.length);
  var names3 = {}; // Creates a map, not a set.
  print(names3 is Set);
  print(names3 is Map);
}

Log
0
0
false
true

 注意：Set还是map?  {} 默认为 Map 类型。 如果忘记了 {} 上的类型注释或它分配给的变量，那么 Dart 会创建一个 Map<dynamic, dynamic> 类型的对象。

使用 add() 或 addAll() 方法将项目添加到现有集合：

void main() {
  var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
  var elements = <String>{};
  elements.add("1");
  elements.addAll(halogens);
  print(elements);
}
Log
{1, fluorine, chlorine, bromine, iodine, astatine}

 使用 .length 获取集合中的项目数：

void main() {
  var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
  var elements = <String>{};
  elements.add('fluorine');
  elements.addAll(halogens);
  print(elements.length == 5);
}

Log
true

 要创建一个作为编译时常量的Set，请在Set字面量之前添加 const：

void main() {
  final constantSet = const {
    'fluorine',
    'chlorine',
    'bromine',
    'iodine',
    'astatine',
  };
//此处代码会报错。
  constantSet.add("66");
}

 Set支持扩展运算符（...和...？）和集合 if 和 for，就像List一样。

Maps

通常，Map是关联键和值的对象。 键和值都可以是任何类型的对象。 每个键只出现一次，但您可以多次使用相同的值。 Dart 对地图的支持由地图字面量和 Map 类型提供。

这里有几个简单的 Dart 地图，使用地图字面量创建：

void main() {
  var gifts = {
    // Key:    Value
    'first': 'partridge',
    'second': 'turtledoves',
    'fifth': 'golden rings'
  };
  print(gifts);
  var nobleGases = {
    2: 'helium',
    10: 'neon',
    18: 'argon',
  };
  print(nobleGases);
}

Log
{first: partridge, second: turtledoves, fifth: golden rings}
{2: helium, 10: neon, 18: argon}

 注意：Dart 推断 gifts 具有 Map<String, String> 类型，而 nobleGases 具有 Map<int, String> 类型。 如果您尝试向任一映射添加错误类型的值，则分析器或运行时会引发错误。

使用 Map 构造函数创建相同的对象：

void main() {
  var gifts = Map<String, String>();
  gifts['first'] = 'partridge';
  gifts['second'] = 'turtledoves';
  gifts['fifth'] = 'golden rings';
  print(gifts);

  var nobleGases = Map<int, String>();
  nobleGases[2] = 'helium';
  nobleGases[10] = 'neon';
  nobleGases[18] = 'argon';
  print(nobleGases);
}

Log
{first: partridge, second: turtledoves, fifth: golden rings}
{2: helium, 10: neon, 18: argon}

 注意：在C# 或 Java 等语言，是 new Map() 而不仅仅是 Map()。 在 Dart 中，new 关键字是可选的。

使用下标赋值运算符 ([]=) 将新的键值对添加到现有映射：

void main() {
  var gifts = {'first': 'partridge'};
  gifts['fourth'] = 'calling birds'; // Add a key-value pair
  print(gifts);
}

Log
{first: partridge, fourth: calling birds}

 使用下标运算符 ([]) 从映射中检索值：

void main() {
  var gifts = {'first': 'partridge'};
  print(gifts['first'] == 'partridge');
}
Log:
true

 寻找一个不在Map中的键，你会得到 null 作为回报：

void main() {
  var gifts = {'first': 'partridge'};
  print(gifts['fifth'] == null);
}
Log
true

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

void main() {
  var gifts = {'first': 'partridge'};
  gifts['fourth'] = 'calling birds';
  print(gifts.length == 2);
}
Log
true

 创建作为编译时常量的映射，请在Map字面量之前添加 const：

void main() {
  final constantMap = const {
    2: 'helium',
    10: 'neon',
    18: 'argon',
  };

//此处会报错
 constantMap[2] = 'Helium'; // This line will cause an error.
}

 

参考文档：Numbers in Dart | Dart

Language tour | Dart