Dart 编程语言.md · acodingant/markdownDocument

# Dart 编程语言

学习更多 Dart 核心库, 参考 [Dart 库概览](https://www.dartcn.com/guides/libraries/library-tour). 想了解更多有关语言功能的详细信息, 参考 [Dart 编程语言规范](https://www.dartcn.com/guides/language/spec).

[toc]

## 一个简单的 Dart 程序

下面的代码用到了很多 Dart 的基本功能：

```dart
// 定义一个函数
printInteger(int aNum) {
    print('the num is $aNum.'); // 打印控制台
}
// 程序入口
main() {
    var num = 42; // 声明
    printInteger(num); // 调用函数
}
```

以下是此程序使用的代码，这些代码适用于所有（或几乎所有）的 Dart  应用：

```dart
// 代码注释
```

单行注释。 Dart 同样支持多行注释和文档注释。 有关更多信息，参考 [注释](https://www.dartcn.com/guides/language/language-tour#comments).

```dart
int
```

数据类型。一些其他 [内置类型](https://www.dartcn.com/guides/language/language-tour#built-in-types) 包括 `String` , `List` , 和 `bool` 。

```dart
42
```

字面量。字面量是一种编译型常量。

```dart
print()
```

便利输出方式。

```dart
'...' (or "...")
```

字符串常量。

`$variableName` (或 `${expression}`)

字符串插值： 包括字符串文字内部的变量或表达式的字符串。  有关更多信息，参考 [Strings](https://www.dartcn.com/guides/language/language-tour#strings).

```
main()
```

程序开始执行函数，该函数是特定的、*必须的*、顶级函数。 有关更多信息，参考 [The main() function](https://www.dartcn.com/guides/language/language-tour#the-main-function).

```
var
```

定义变量，通过这种方式定义变量不需要指定变量类型。

**提示：** 代码遵循 Dart 风格指南中的约定。 [Dart 风格指南](https://www.dartcn.com/guides/language/effective-dart/style).

## 重要的概念

在学习 Dart 语言时, 应该基于以下事实和概念：

- 任何保存在变量中的都是一个 *对象* ， 并且所有的对象都是对应一个 *类* 的实例。 无论是数字，函数和 `null` 都是对象。所有对象继承自 [Object](https://api.dartlang.org/stable/dart-core/Object-class.html) 类。
- 尽管 Dart 是强类型的，但是 Dart 可以推断类型，所以类型注释是可选的。  在上面的代码中， `number` 被推断为 `int` 类型。  如果要明确说明不需要任何类型， [需要使用特殊类型 `dynamic`](https://www.dartcn.com/guides/language/effective-dart/design#do-annotate-with-object-instead-of-dynamic-to-indicate-any-object-is-allowed) 。
- Dart 支持泛型，如 `List ` （整数列表）或 `List ` （任何类型的对象列表）。
- Dart 支持顶级函数（例如 `main（）` ）， 同样函数绑定在类或对象上（分别是 *静态函数* 和 *实例函数* ）。 以及支持函数内创建函数 （ *嵌套* 或 *局部函数* ） 。
- 类似地， Dart 支持顶级 *变量* ， 同样变量绑定在类或对象上（静态变量和实例变量）。  实例变量有时称为字段或属性。
- 与 Java 不同，Dart 没有关键字 “public” ， “protected” 和 “private” 。  如果标识符以下划线（_）开头，则它相对于库是私有的。  有关更多信息，参考 [库和可见性](https://www.dartcn.com/guides/language/language-tour#库和可见性)。
- *标识符* 以字母或下划线（_）开头，后跟任意字母和数字组合。
- Dart 语法中包含 *表达式（ expressions ）*（有运行时值）和 *语句（ statements ）*（没有运行时值）。 例如，[条件表达式](https://www.dartcn.com/guides/language/language-tour#conditional-expressions) `condition ? expr1 : expr2` 的值可能是 `expr1` 或 `expr2` 。 将其与 [if-else 语句](https://www.dartcn.com/guides/language/language-tour#if-和-else) 相比较，if-else 语句没有值。 一条语句通常包含一个或多个表达式，相反表达式不能直接包含语句。
- Dart 工具提示两种类型问题：*警告_和_错误*。  警告只是表明代码可能无法正常工作，但不会阻止程序的执行。  错误可能是编译时错误或者运行时错误。  编译时错误会阻止代码的执行; 运行时错误会导致代码在执行过程中引发 [异常]（#exception）。

## 变量

创建一个变量并进行初始化:

```dart
var name = 'Bob';
```

变量仅存储对象引用，这里的变量是 `name` 存储了一个 `String` 类型的对象引用。 “Bob” 是这个 `String` 类型对象的值。

`name` 变量的类型被推断为 `String` 。 但是也可以通过指定类型的方式，来改变变量类型。  如果对象不限定为单个类型，可以指定为 `对象类型` 或 `动态类型`， 参考 [设计指南](https://www.dartcn.com/guides/language/effective-dart/design#do-annotate-with-object-instead-of-dynamic-to-indicate-any-object-is-allowed)。

```dart
dynamic name = 'Bob';
```

另一种方式是显式声明可以推断出的类型：

```dart
String name = 'Bob';
```

**提示：** 本页局部变量遵守 [风格建议指南](https://www.dartcn.com/guides/language/effective-dart/design#types) 使用 `var`。 没有使用指定类型的方式。

### 默认值

未初始化的变量默认值是 `null`。即使变量是数字 类型默认值也是 null，因为在 Dart 中一切都是对象，数字类型 也不例外。

```dart
int lineCount;
assert(lineCount == null);
```

**提示：** 在生产环境代码中 `assert()` 函数会被忽略，不会被调用。 在开发过程中, `assert(*condition*)` 会在非 `true` 的条件下抛出异常.有关更多信息，参考 [Assert](https://www.dartcn.com/guides/language/language-tour#assert).

### Final 和 Const

使用过程中从来不会被修改的变量， 可以使用 `final` 或 `const`, 而不是 `var` 或者其他类型， Final 变量的值只能被设置一次； Const 变量在编译时就已经固定 (Const 变量 是隐式 Final 的类型.) 最高级 final 变量或类变量在第一次使用时被初始化。

**提示：** 实例变量可以是 `final` 类型但不能是 `const` 类型。 必须在构造函数体执行之前初始化 final 实例变量 ——  在变量声明中，参数构造函数中或构造函数的[初始化列表](https://www.dartcn.com/guides/language/language-tour#initializer-list)中进行初始化。

创建和设置一个 Final 变量：

```dart
final name = 'Bob'; // Without a type annotation
final String nickname = 'Bobby';
```

final 不能被修改:

```dart
name = 'Alice'; // Error: 一个 final 变量只能被设置一次。
```

如果需要在**编译时**就固定变量的值，可以使用 `const` 类型变量。 如果 Const 变量是类级别的，需要标记为 `static const`。 在这些地方可以使用在编译时就已经固定不变的值，字面量的数字和字符串， 固定的变量，或者是用于计算的固定数字：

```dart
const bar = 1000000; // 压力单位 (dynes/cm2)
const double atm = 1.01325 * bar; // 标准气压
```

Const 关键字不仅可以用于声明常量变量。  还可以用来创建常量值，以及声明创建常量值的构造函数。 任何变量都可以拥有常量值。

```dart
var foo = const [];
final bar = const [];
const baz = []; // Equivalent to `const []`
```

非 Final ， 非 const 的变量是可以被修改的，即使这些变量 曾经引用过 const 值。

```dart
foo = [1, 2, 3]; // 曾经引用过 const [] 常量值。
```

Const 变量的值不可以修改：

```dart
baz = [42]; // Error: 常量变量不能赋值修改。
```

## 内建类型

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

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

这些类型都可以被初始化为字面量。 例如, `'this is a string'` 是一个字符串的字面量， `true` 是一个布尔的字面量。

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

### Number

Dart 语言的 [Number](https://www.dartcn.com/guides/language/language-tour#number) 有两种类型:

- [int](https://api.dartlang.org/stable/dart-core/int-class.html)

整数值不大于64位， 具体取决于平台。 在 Dart VM 上， 值的范围从 -263 到 263 - 1. Dart 被编译为 JavaScript 时，使用 [JavaScript numbers,](https://stackoverflow.com/questions/2802957/number-of-bits-in-javascript-numbers/2803010#2803010) 值的范围从 -253 到 253 - 1.

- [double](https://api.dartlang.org/stable/dart-core/double-class.html)

64位（双精度）浮点数，依据 IEEE 754 标准。

`int` 和 `double` 都是 [`num`.](https://api.dartlang.org/stable/dart-core/num-class.html) 的亚类型。 num 类型包括基本运算 +， -， /， 和 *， 以及 `abs()`，` ceil()`， 和 `floor()`， 等函数方法。 （按位运算符，例如»，定义在 int 类中。） 如果 num 及其亚类型找不到你想要的方法， 尝试查找使用 [dart:math](https://api.dartlang.org/stable/dart-math) 库。

整数类型不包含小数点。 下面是定义整数类型字面量的例子:

```dart
var x = 1;
var hex = 0xDEADBEEF;
```

如果一个数字包含小数点，那么就是小数类型。  下面是定义小数类型字面量的例子:

```dart
var y = 1.1;
var exponents = 1.42e5;
```

从 Dart 2.1 开始，必要的时候 int 字面量会自动转换成 double 类型。

```dart
double z = 1; // 相当于 double z = 1.0
```

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

```dart
// String -> int
var one = int.parse('1');
assert(one == 1);

// String -> double
var onePointOne = double.parse('1.1');
assert(onePointOne == 1.1);

// int -> String
String oneAsString = 1.toString();
assert(oneAsString == '1');

// double -> String
String piAsString = 3.14159.toStringAsFixed(2);
assert(piAsString == '3.14');
```

int 特有的传统按位运算操作，移位（<<， >>），按位与（&）以及 按位或（|）。 例如：

```dart
assert((3 << 1) == 6); // 0011 << 1 == 0110
assert((3 >> 1) == 1); // 0011 >> 1 == 0001
assert((3 | 4) == 7); // 0011 | 0100 == 0111
```

数字类型字面量是编译时常量。 在算术表达式中，只要参与计算的因子是编译时常量，  那么算术表达式的结果也是编译时常量。

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

### String

Dart [字符串](https://www.dartcn.com/guides/language/language-tour#string)是一组 UTF-16 单元序列。 字符串通过单引号或者双引号创建。

字符串可以通过 `${`*`expression`*`}` 的方式内嵌表达式。 如果表达式是一个标识符，则 {} 可以省略。 在 Dart 中通过调用就对象的 `toString()` 方法来得到对象相应的字符串。可以使用 `+` 运算符来把多个字符串连接为一个，也可以把多个字面量字符串写在一起来实现字符串连接：

```dart
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!');
```

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

```dart
var s1 = '''
You can create
multi-line strings like this one.
''';

var s2 = """This is also a
multi-line string.""";
```

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

参考 [Runes](https://www.dartcn.com/guides/language/language-tour#runes) 来了解如何在字符串中表达 Unicode  字符。

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

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

```dart
// const 类型数据
const aConstNum = 0;
const aConstBool = true;
const aConstString = 'a constant string';

// 非 const 类型数据
var aNum = 0;
var aBool = true;
var aString = 'a string';
const aConstList = [1, 2, 3];

const validConstString = '$aConstNum $aConstBool $aConstString'; //const 类型数据
// const invalidConstString = '$aNum $aBool $aString $aConstList'; //非 const 类型数据
```

更多关于 string 的使用, 参考 [字符串和正则表达式](https://www.dartcn.com/guides/libraries/library-tour#strings-and-regular-expressions).

### Boolean

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

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

```dart
// 检查空字符串。
var fullName = '';
assert(fullName.isEmpty);

// 检查 0 值。
var hitPoints = 0;
assert(hitPoints <= 0);

// 检查 null 值。
var unicorn;
assert(unicorn == null);

// 检查 NaN 。
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);
```

### List

几乎每种编程语言中最常见的集合可能是 *array* 或有序的对象集合。 在 Dart 中的 *Array* 就是 [List](https://api.dartlang.org/stable/dart-core/List-class.html) 对象， 通常称之为 *List* 。

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

```dart
var list = [1, 2, 3];
```

**提示：**  Dart 推断 `list` 的类型为 `List` 。   如果尝试将非整数对象添加到此 List 中，  则分析器或运行时会引发错误。   有关更多信息，请阅读  [类型推断。](https://www.dartcn.com/guides/language/sound-dart#type-inference)

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

```dart
var list = [1, 2, 3];
assert(list.length == 3);
assert(list[1] == 2);

list[1] = 1;
assert(list[1] == 1);
```

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

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

List 类型包含了很多 List 的操作函数。  更多信息参考 [泛型](https://www.dartcn.com/guides/language/language-tour#generics) 和 [集合](https://www.dartcn.com/guides/libraries/library-tour#collections).

### Set

在 Dart 中 Set 是一个元素唯一且无需的集合。 Dart 为 Set 提供了 Set 字面量和 [Set](https://api.dartlang.org/stable/dart-core/Set-class.html) 类型。

下面是通过字面量创建 Set 的一个简单示例：

```dart
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
```

**Note:**  Dart 推断 `halogens` 类型为 `Set` 。如果尝试为它添加一个  错误类型的值，分析器或执行时会抛出错误。更多内容，参阅  [类型推断](https://www.dartcn.com/guides/language/sound-dart#type-inference)。

要创建一个空集，使用前面带有类型参数的 `{}` ，或者将 `{}` 赋值给 `Set` 类型的变量：

```dart
var names = <String>{};
// Set<String> names = {}; // 这样也是可以的。
// var names = {}; // 这样会创建一个 Map ，而不是 Set 。
```

**是 Set 还是 Map ？**  Map 字面量语法同 Set 字面量语法非常相似。  因为先有的 Map 字母量语法，所以 `{}` 默认是 `Map` 类型。  如果忘记在 `{}` 上注释类型或赋值到一个未声明类型的变量上，  那么 Dart 会创建一个类型为 `Map` 的对象。

使用 `add()` 或 `addAll()` 为已有的 Set 添加元素：

```dart
var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);
```

使用 `.length` 来获取 Set 中元素的个数：

```dart
var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);
assert(elements.length == 5);
```

在 Set 字面量前增加 `const` ，来创建一个编译时 Set 常量：

```dart
final constantSet = const {
  'fluorine',
  'chlorine',
  'bromine',
  'iodine',
  'astatine',
};
// constantSet.add('helium'); // Uncommenting this causes an error.
```

更多关于 Set 的内容，参阅 [Generic](https://www.dartcn.com/guides/language/language-tour#generics) 及 [Set](https://www.dartcn.com/guides/libraries/library-tour#sets)。

### Map

通常来说， Map 是用来关联 keys 和 values 的对象。 keys 和 values 可以是任何类型的对象。在一个 Map 对象中一个 *key* 只能出现一次。 但是 *value* 可以出现多次。 Dart 中 Map 通过 Map 字面量 和 [Map](https://api.dartlang.org/stable/dart-core/Map-class.html) 类型来实现。

下面是使用 Map 字面量的两个简单例子：

```dart
var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};

var nobleGases = {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};
```

**提示：**  Dart 会将 `gifts` 的类型推断为 `Map`，  `nobleGases` 的类型推断为 `Map` 。   如果尝试在上面的 map 中添加错误类型，那么分析器或者运行时会引发错误。   有关更多信息，请阅读[类型推断。](https://www.dartcn.com/guides/language/sound-dart#type-inference)。

以上 Map 对象也可以使用 Map 构造函数创建：

```dart
var gifts = Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

var nobleGases = Map();
nobleGases[2] = 'helium';
nobleGases[10] = 'neon';
nobleGases[18] = 'argon';
```

**提示:** 这里为什么只有 `Map()` ，而不是使用 `new Map()`。 因为在 Dart 2 中，`new` 关键字是可选的。 有关更多信息，参考 [构造函数的使用](https://www.dartcn.com/guides/language/language-tour#使用构造函数)。

类似 JavaScript ，添加 key-value 对到已有的 Map 中：

```dart
var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds'; // Add a key-value pair
```

类似 JavaScript ，从一个 Map 中获取一个 value：

```dart
var gifts = {'first': 'partridge'};
assert(gifts['first'] == 'partridge');
```

如果 Map 中不包含所要查找的 key，那么 Map 返回 null：

```dart
var gifts = {'first': 'partridge'};
assert(gifts['fifth'] == null);
```

### Rune

在 Dart 中，[ Rune](https://www.dartcn.com/guides/language/language-tour#rune) 用来表示字符串中的 UTF-32 编码字符。

Unicode 定义了一个全球的书写系统编码， 系统中使用的所有字母，数字和符号都对应唯一的数值编码。 由于 Dart 字符串是一系列 UTF-16 编码单元， 因此要在字符串中表示32位 Unicode 值需要特殊语法支持。

表示 Unicode 编码的常用方法是， `\uXXXX`, 这里 XXXX 是一个4位的16进制数。 例如，心形符号 (♥) 是 `\u2665`。 对于特殊的非 4 个数值的情况， 把编码值放到大括号中即可。 例如，emoji 的笑脸   (�) 是 `\u{1f600}`。

### Symbol

一个 Symbol 对象表示 Dart 程序中声明的运算符或者标识符。  你也许永远都不需要使用 Symbol ，但要按名称引用标识符的 API 时， Symbol 就非常有用了。 因为代码压缩后会改变标识符的名称，但不会改变标识符的符号。 通过字面量 Symbol ，也就是标识符前面添加一个 `#` 号，来获取标识符的 Symbol 。

```nocode
#radix
#bar
```

Symbol 字面量是编译时常量。

## 函数

Dart 是一门真正面向对象的语言， 甚至其中的函数也是对象，并且有它的类型  [Function](https://api.dartlang.org/stable/dart-core/Function-class.html) 。 这也意味着函数可以被赋值给变量或者作为参数传递给其他函数。 也可以把 Dart 类的实例当做方法来调用。 有关更多信息，参考 [Callable classes](https://www.dartcn.com/guides/language/language-tour#callable-classes).

已下是函数实现的示例：

```dart
bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}
```

虽然在 Effective Dart 中推荐 [公共API中声明类型](https://www.dartcn.com/guides/language/effective-dart/design#prefer-type-annotating-public-fields-and-top-level-variables-if-the-type-isnt-obvious), 但是省略了类型声明，函数依旧是可以正常使用的：

```dart
isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}
```

如果函数中只有一句表达式，可以使用简写语法：

```dart
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;
```

`=> *expr*` 语法是 `{ return *expr*; }` 的简写。 `=>` 符号 有时也被称为 *箭头* 语法。

**提示：** 在箭头 (=>) 和分号 (;) 之间只能使用一个 *表达式* ，不能是 *语句* 。 例如：不能使用 [if 语句](https://www.dartcn.com/guides/language/language-tour#if-和-else) ，但是可以是用  [条件表达式](https://www.dartcn.com/guides/language/language-tour#conditional-expressions).

### 可选参数

[可选参数](https://www.dartcn.com/guides/language/language-tour#%E5%8F%AF%E9%80%89%E5%8F%82%E6%95%B0)可以是命名参数或者位置参数，但一个参数只能选择其中一种方式修饰。

#### 命名可选参数

调用函数时，可以使用指定命名参数 `*paramName*: *value*`。 例如：

```dart
enableFlags(bold: true, hidden: false);
```

定义函数是，使用 `{*param1*, *param2*, …}` 来指定命名参数：

```dart
/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool bold, bool hidden}) {...}
```

#### 位置可选参数

将参数放到 `[]` 中来标记参数是可选的：

```dart
String say(String from, String msg, [String device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}
```

下面是不使用可选参数调用上面方法 的示例：

```dart
assert(say('Bob', 'Howdy') == 'Bob says Howdy');
```

#### 默认参数值

在定义方法的时候，可以使用 `=` 来定义可选参数的默认值。 默认值只能是编译时常量。  如果没有提供默认值，则默认值为 null。

下面是设置可选参数默认值示例：

```dart
/// 设置 [bold] 和 [hidden] 标志 ...
void enableFlags({bool bold = false, bool hidden = false}) {...}

// bold 值为 true; hidden 值为 false.
enableFlags(bold: true);
```

**不推荐：** 旧版本代码中可能使用的是冒号 (`:`) 而不是 `=`  来设置参数默认值。 原因是起初命名参数只支持 `:` 。 这种支持可能会被弃用。 建议 **[使用 `=` 指定默认值。](https://www.dartcn.com/tools/pub/pubspec#sdk-constraints)**

### main() 函数

任何应用都必须有一个顶级 `main()` 函数，作为应用服务的入口。 `main()` 函数返回值为空，参数为一个可选的 `List` 。

下面是 web 应用的 `main()` 函数：

```dart
void main() {
  querySelector('#sample_text_id')
    ..text = 'Click me!'
    ..onClick.listen(reverseText);
}
```

**提示：**以上代码中的 `..` 语法为 [级联调用](https://www.dartcn.com/guides/language/language-tour#cascade-notation-) （cascade）。  使用级联调用， 可以简化在一个对象上执行的多个操作。

下面是一个命令行应用的 `main()` 方法，并且使用了输入参数：

```dart
// 这样运行应用： dart args.dart 1 test
void main(List<String> arguments) {
  print(arguments);

assert(arguments.length == 2);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[1] == 'test');
}
```

使用 [args library](https://pub.dartlang.org/packages/args) 可以定义和解析命令行参数。

### 函数是一等对象

一个函数可以作为另一个函数的参数。 例如：

```dart
void printElement(int element) {
  print(element);
}

var list = [1, 2, 3];

// 将 printElement 函数作为参数传递。
list.forEach(printElement);
```

同样可以将一个函数赋值给一个变量，例如：

```dart
var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
assert(loudify('hello') == '!!! HELLO !!!');
```

示例中使用了匿名函数。 下一章节会有更多介绍。

### 匿名函数

多数函数是有名字的， 比如 `main()` 和 `printElement()`。 也可以创建没有名字的函数，这种函数被称为 *匿名函数*， 有时候也被称为 *lambda* 或者 *closure* 。 匿名函数可以赋值到一个变量中， 举个例子，在一个集合中可以添加或者删除一个匿名函数。

匿名函数和命名函数看起来类似—  在括号之间可以定义一些参数或可选参数，参数使用逗号分割。

后面大括号中的代码为函数体：

```dart
 ([[Type] param1[, …]]) {
     codeBlock;  
 };  
```

下面例子中定义了一个包含一个无类型参数 `item` 的匿名函数。 list 中的每个元素都会调用这个函数，打印元素位置和值的字符串。

```dart
var list = ['apples', 'bananas', 'oranges'];
list.forEach((item) {
  print('${list.indexOf(item)}: $item');
});
```

### 词法闭包

*闭包* 即一个函数对象，即使函数对象的调用在它原始作用域之外， 依然能够访问在它词法作用域内的变量。

函数可以封闭定义到它作用域内的变量。 接下来的示例中， `makeAdder()` 捕获了变量 `addBy`。  无论在什么时候执行返回函数，函数都会使用捕获的 `addBy` 变量。

```dart
/// 返回一个函数，返回的函数参数与 [addBy] 相加。
Function makeAdder(num addBy) {
  return (num i) => addBy + i;
}

void main() {
  // 创建一个加 2 的函数。
  var add2 = makeAdder(2);

// 创建一个加 4 的函数。
  var add4 = makeAdder(4);

assert(add2(3) == 5);
  assert(add4(3) == 7);
}
```

### 测试函数是否相等

下面是顶级函数，静态方法和示例方法相等性的测试示例：

```dart
void foo() {} // 顶级函数

class A {
  static void bar() {} // 静态方法
  void baz() {} // 示例方法
}

void main() {
  var x;

// 比较顶级函数。
  x = foo;
  assert(foo == x);

// 比较静态方法。
  x = A.bar;
  assert(A.bar == x);

// 比较实例方法。
  var v = A(); // A的1号实例
  var w = A(); // A的2号实例
  var y = w;
  x = w.baz;

// 两个闭包引用的同一实例（2号）,
  // 所以它们相等。
  assert(y.baz == x);

// 两个闭包引用的非同一个实例，
  // 所以它们不相等。
  assert(v.baz != w.baz);
}
```

### 返回值

所有函数都会返回一个值。 如果没有明确指定返回值， 函数体会被隐式的添加 `return null;` 语句。

```dart
foo() {}

assert(foo() == null);
```

## 运算符

下表是 Dart 定义的[运算符](https://www.dartcn.com/guides/language/language-tour#%E7%AE%97%E6%9C%AF%E8%BF%90%E7%AE%97%E7%AC%A6)。 多数运算符可以被重载，详情参考 [重写运算符](https://www.dartcn.com/guides/language/language-tour#重写运算符)。

| Description              | Operator                                                    |
| ------------------------ | ----------------------------------------------------------- |
| unary postfix            | `*expr*++`   `*expr*--`   `()`   `[]`   `.`   `?.`          |
| unary prefix             | `-*expr*`   `!*expr*`   `~*expr*`   `++*expr*`   `--*expr*` |
| multiplicative           | `*`   `/`   `%`    `~/`                                     |
| additive                 | `+`   `-`                                                   |
| shift                    | `<<`   `>>`   `>>>`                                         |
| bitwise AND              | `&`                                                         |
| bitwise XOR              | `^`                                                         |
| bitwise OR               | `|`                                                         |
| relational and type test | `>=`   `>`   `<=`   `<`   `as`   `is`   `is!`               |
| equality                 | `==`   `!=`                                                 |
| logical AND              | `&&`                                                        |
| logical OR               | `||`                                                        |
| if null                  | `??`                                                        |
| conditional              | `expr1 ? expr2 : expr3`                                     |
| cascade                  | `..`                                                        |
| assignment               | `=`   `*=`   `/=`   `+=`   `-=`   `&=`   `^=`   *etc.*      |

在 [运算符表](https://www.dartcn.com/guides/language/language-tour#operators) 中， 每一行的运算符优先级，由上到下依次排列，第一行优先级最高，最后一行优先级最低。 例如 `%` 运算符优先级高于 `==` ， 而 `==` 高于 `&&`。

**提示：**  上述表格中描述的运算符优先级近似于Dart 解析器实际行为。  更准确的描述，请参阅 [Dart language specification](https://www.dartcn.com/guides/language/spec) 中的语法。

### 算术运算符

Dart 支持常用的运算运算符，如下表所示：

| Operator | Meaning                                                      |
| -------- | ------------------------------------------------------------ |
| `+`      | Add-加                                                       |
| `–`      | Subtract-减                                                  |
| `-expr`  | Unary minus, also known as negation (reverse the sign of the expression)-负号 |
| `*`      | Multiply-乘                                                  |
| `/`      | Divide-除                                                    |
| `~/`     | Divide, returning an integer result-除，返回一个整数结果     |
| `%`      | Get the remainder of an integer division (modulo)-得到整数除法的余数(模数) |

Dart 还支持前缀和后缀，自增和自减运算符。

| Operator | Meaning                                         |
| -------- | ----------------------------------------------- |
| `++var`  | `var = var + 1` (expression value is `var + 1`) |
| `var++`  | `var = var + 1` (expression value is `var`)     |
| `--var`  | `var = var – 1` (expression value is `var – 1`) |
| `var--`  | `var = var – 1` (expression value is `var`)     |

### 关系运算符

下表列出了关系运算符及含义：

| Operator | Meaning                     |
| -------- | --------------------------- |
| `==`     | Equal; see discussion below |
| `!=`     | Not equal                   |
| `>`      | Greater than                |
| `<`      | Less than                   |
| `>=`     | Greater than or equal to    |
| `<=`     | Less than or equal to       |

### 类型判定运算符

`as`， `is`， 和 `is!` 运算符用于在运行时处理类型检查：

| Operator | Meaning                                                      |
| -------- | ------------------------------------------------------------ |
| `as`     | Typecast (也被用于[指定库前缀](https://www.dartcn.com/guides/language/language-tour#指定库前缀)) |
| `is`     | True if the object has the specified type                    |
| `is!`    | False if the object has the specified type                   |

例如， `obj is Object` 总是 true。 但是只有 `obj` 实现了 `T` 的接口时， `obj is T` 才是 true。

使用 `as` 运算符将对象强制转换为特定类型。  通常，可以认为是 `is` 类型判定后，被判定对象调用函数的一种缩写形式。 请考虑以下代码：

```dart
if (emp is Person) {
  // Type check
  emp.firstName = 'Bob';
}
```

使用 `as` 运算符进行缩写：

```dart
(emp as Person).firstName = 'Bob';
```

**提示：** 以上代码并不是等价的。 如果 `emp` 为 null 或者不是 Person 对象， 那么第一个 `is` 的示例，后面将不回执行； 第二个 `as` 的示例会抛出异常。

### 赋值运算符

使用 `=` 为变量赋值。 使用 `??=` 运算符时，只有当被赋值的变量为 null 时才会赋值给它。

```dart
// 将值赋值给变量a
a = value;
// 如果b为空时，将变量赋值给b，否则，b的值保持不变。
b ??= value;
```

### 逻辑运算符

逻辑操作符可以反转或组合布尔表达式。

| Operator  | Meaning                                                      |
| --------- | ------------------------------------------------------------ |
| `!*expr*` | inverts the following expression (changes false to true, and vice versa) |
| `||`      | logical OR                                                   |
| `&&`      | logical AND                                                  |

下面是关于逻辑表达式的示例：

```dart
if (!done && (col == 0 || col == 3)) {
  // ...Do something...
}
```

### 按位和移位运算符

在 Dart 中，可以单独操作数字的某一位。 通常情况下整数类型使用按位和移位运算符来操作。

| Operator  | Meaning                                               |
| --------- | ----------------------------------------------------- |
| `&`       | AND                                                   |
| `|`       | OR                                                    |
| `^`       | XOR                                                   |
| `~*expr*` | Unary bitwise complement (0s become 1s; 1s become 0s) |
| `<<`      | Shift left                                            |
| `>>`      | Shift right                                           |

### 条件表达式

Dart有两个运算符，有时可以替换 [if-else](https://www.dartcn.com/guides/language/language-tour#if-和-else) 表达式， 让表达式更简洁：

- `*condition* ? *expr1* : *expr2*`

如果条件为 true, 执行 *expr1* (并返回它的值)： 否则, 执行并返回 *expr2* 的值。

- `*expr1* ?? *expr2*`

如果 *expr1* 是 non-null， 返回 *expr1* 的值； 否则, 执行并返回 *expr2* 的值。

如果赋值是根据布尔值， 考虑使用 `?:`。

```dart
var visibility = isPublic ? 'public' : 'private';
```

如果赋值是基于判定是否为 null， 考虑使用 `??`。

```dart
String playerName(String name) => name ?? 'Guest';
```

### 级联运算符 (..)

级联运算符 (`..`) 可以实现对同一个对像进行一系列的操作。 除了调用函数， 还可以访问同一对象上的字段属性。 这通常可以节省创建临时变量的步骤， 同时编写出更流畅的代码。

考虑一下代码：

```dart
querySelector('#confirm') // 获取对象。
  ..text = 'Confirm' // 调用成员变量。
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'));
```

第一句调用函数 `querySelector()` ， 返回获取到的对象。 获取的对象依次执行级联运算符后面的代码， 代码执行后的返回值会被忽略。

上面的代码等价于：

```dart
var button = querySelector('#confirm');
button.text = 'Confirm';
button.classes.add('important');
button.onClick.listen((e) => window.alert('Confirmed!'));
```

### 其他运算符

大多数剩余的运算符，已在示例中使用过：

| Operator | Name                      | Meaning                                                      |
| -------- | ------------------------- | ------------------------------------------------------------ |
| `()`     | Function application      | Represents a function call                                   |
| `[]`     | List access               | Refers to the value at the specified index in the list       |
| `.`      | Member access             | Refers to a property of an expression; example: `foo.bar` selects property `bar` from expression `foo` |
| `?.`     | Conditional member access | Like `.`, but the leftmost operand can be null; example: `foo?.bar` selects property `bar` from expression `foo` unless `foo` is null (in which case the value of `foo?.bar` is null) |

更多关于 `.`, `?.` 和  `..` 运算符介绍，参考 [Classes](https://www.dartcn.com/guides/language/language-tour#classes).

## 控制流程语句

你可以通过下面任意一种方式来控制 Dart 程序流程：

- `if` and `else`
- `for` loops
- `while` and `do`-`while` loops
- `break` and `continue`
- `switch` and `case`
- `assert`

使用 `try-catch` 和 `throw` 也可以改变程序流程，  详见 [Exceptions](https://www.dartcn.com/guides/language/language-tour#exceptions)。

### assert

如果 `assert` 语句中的布尔条件为 false ， 那么正常的程序执行流程会被中断。 在本章中包含部分 assert 的使用， 下面是一些示例：

```dart
// 确认变量值不为空。
assert(text != null);

// 确认变量值小于100。
assert(number < 100);

// 确认 URL 是否是 https 类型。
assert(urlString.startsWith('https'));
```

**提示：** assert 语句只在开发环境中有效， 在生产环境是无效的； Flutter 中的 assert 只在 [debug 模式](https://flutter.io/debugging/#debug-mode-assertions) 中有效。 开发用的工具，例如 [dartdevc](https://webdev.dartlang.org/tools/dartdevc) 默认是开启 assert 功能。 其他的一些工具， 例如 [dart](https://www.dartcn.com/server/tools/dart-vm) 和 [dart2js,](https://webdev.dartlang.org/tools/dart2js) 支持通过命令行开启 assert ： `--enable-asserts`。

assert 的第二个参数可以为其添加一个字符串消息。

```dart
assert(urlString.startsWith('https'),
    'URL ($urlString) should start with "https".');
```

assert 的第一个参数可以是解析为布尔值的任何表达式。 如果表达式结果为 true ， 则断言成功，并继续执行。 如果表达式结果为 false ， 则断言失败，并抛出异常 ([AssertionError](https://api.dartlang.org/stable/dart-core/AssertionError-class.html)) 。

## 异常

Dart 代码可以抛出和捕获[异常](https://www.dartcn.com/guides/language/language-tour#%E5%BC%82%E5%B8%B8)。  异常表示一些未知的错误情况。 如果异常没有被捕获， 则异常会抛出， 导致抛出异常的代码终止执行。

和 Java 有所不同， Dart 中的所有异常是非检查异常。 方法不会声明它们抛出的异常， 也不要求捕获任何异常。

Dart 提供了 [Exception](https://api.dartlang.org/stable/dart-core/Exception-class.html) 和 [Error](https://api.dartlang.org/stable/dart-core/Error-class.html) 类型， 以及一些子类型。  当然也可以定义自己的异常类型。 但是，此外 Dart 程序可以抛出任何非 null 对象， 不仅限 Exception 和 Error 对象。

### throw

下面是关于抛出或者 *引发* 异常的示例：

```dart
throw FormatException('Expected at least 1 section');
```

也可以抛出任意的对象：

```dart
throw 'Out of llamas!';
```

**提示：** 高质量的生产环境代码通常会实现 [Error](https://api.dartlang.org/stable/dart-core/Error-class.html) 或 [Exception](https://api.dartlang.org/stable/dart-core/Exception-class.html) 类型的异常抛出。

因为抛出异常是一个表达式， 所以可以在 => 语句中使用，也可以在其他使用表达式的地方抛出异常：

```dart
void distanceTo(Point other) => throw UnimplementedError();
```

### catch

捕获异常可以避免异常继续传递（除非重新抛出（ rethrow ）异常）。  可以通过捕获异常的机会来处理该异常：

```dart
try {
  breedMoreLlamas();
} on OutOfLlamasException {
  buyMoreLlamas();
}
```

通过指定多个 catch 语句，可以处理可能抛出多种类型异常的代码。 与抛出异常类型匹配的第一个 catch 语句处理异常。  如果 catch 语句未指定类型， 则该语句可以处理任何类型的抛出对象：

```dart
try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // 一个特殊的异常
  buyMoreLlamas();
} on Exception catch (e) {
  // 其他任何异常
  print('Unknown exception: $e');
} catch (e) {
  // 没有指定的类型，处理所有异常
  print('Something really unknown: $e');
}
```

如上述代码所示，捕获语句中可以同时使用 `on` 和 `catch` ，也可以单独分开使用。 使用 `on` 来指定异常类型， 使用 `catch` 来 捕获异常对象。

`catch()` 函数可以指定1到2个参数， 第一个参数为抛出的异常对象，  第二个为堆栈信息 ( 一个 [StackTrace](https://api.dartlang.org/stable/dart-core/StackTrace-class.html) 对象 )。

```dart
try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}
```

如果仅需要部分处理异常， 那么可以使用关键字 `rethrow` 将异常重新抛出。

```dart
void misbehave() {
  try {
    dynamic foo = true;
    print(foo++); // Runtime error
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }
}

void main() {
  try {
    misbehave();
  } catch (e) {
    print('main() finished handling ${e.runtimeType}.');
  }
}
```

### finally

不管是否抛出异常， `finally` 中的代码都会被执行。 如果 `catch` 没有匹配到异常， 异常会在 `finally` 执行完成后，再次被抛出：

```dart
try {
  breedMoreLlamas();
} finally {
  // Always clean up, even if an exception is thrown.
  cleanLlamaStalls();
}
```

任何匹配的 `catch` 执行完成后，再执行 `finally` ：

```dart
try {
  breedMoreLlamas();
} catch (e) {
  print('Error: $e'); // Handle the exception first.
} finally {
  cleanLlamaStalls(); // Then clean up.
}
```

更多详情，请参考 [Exceptions](https://www.dartcn.com/guides/libraries/library-tour#exceptions) 章节。

**记录打点：[20191226](https://www.dartcn.com/guides/language/language-tour#%E7%B1%BB)**

## [类](https://www.dartcn.com/guides/language/language-tour#类)

Dart 是一种基于类和 mixin 继承机制的面向对象的语言。 每个对象都是一个类的实例，所有的类都继承于 [Object.](https://api.dartlang.org/stable/dart-core/Object-class.html) 。 基于 * Mixin 继承* 意味着每个类（除 Object 外） 都只有一个超类， 一个类中的代码可以在其他多个继承类中重复使用。

### 使用类的成员变量

对象的由函数和数据（即方法和实例变量）组成。 方法的调用要通过对象来完成： 调用的方法可以访问其对象的其他函数和数据。

使用 (`.`) 来引用实例对象的变量和方法：

```dart
var p = Point(2, 2);

// 为实例的变量 y 设置值。
p.y = 3;

// 获取变量 y 的值。
assert(p.y == 3);

// 调用 p 的 distanceTo() 方法。
num distance = p.distanceTo(Point(4, 4));
```

使用 `?.` 来代替 `.` ， 可以避免因为左边对象可能为 null ， 导致的异常：

```dart
// 如果 p 为 non-null，设置它变量 y 的值为 4。
p?.y = 4;
```

### 使用构造函数

通过 *构造函数* 创建对象。 构造函数的名字可以是 `*ClassName*` 或者 `*ClassName*.*identifier*`。例如， 以下代码使用 `Point` 和 `Point.fromJson()` 构造函数创建 `Point` 对象：

```dart
var p1 = Point(2, 2);
var p2 = Point.fromJson({'x': 1, 'y': 2});
```

以下代码具有相同的效果， 但是构造函数前面的的 `new` 关键字是可选的：

```dart
var p1 = new Point(2, 2);
var p2 = new Point.fromJson({'x': 1, 'y': 2});
```

一些类提供了[常量构造函数](https://www.dartcn.com/guides/language/language-tour#常量构造函数)。 使用常量构造函数，在构造函数名之前加 `const` 关键字，来创建编译时常量时：

```dart
var p = const ImmutablePoint(2, 2);
```

构造两个相同的编译时常量会产生一个唯一的， 标准的实例：

```dart
var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b)); // 它们是同一个实例。
```

### 获取对象的类型

使用对象的 `runtimeType` 属性， 可以在运行时获取对象的类型， `runtimeType` 属性回返回一个 [Type](https://api.dartlang.org/stable/dart-core/Type-class.html) 对象。

```dart
print('The type of a is ${a.runtimeType}');
```

### 实例变量

下面是声明实例变量的示例：

```dart
class Point {
  num x; // 声明示例变量 x，初始值为 null 。
  num y; // 声明示例变量 y，初始值为 null 。
  num z = 0; // 声明示例变量 z，初始值为 0 。
}
```

未初始化实例变量的默认人值为 “null” 。

所有实例变量都生成隐式 *getter* 方法。 非 final 的实例变量同样会生成隐式 *setter* 方法。 有关更多信息，参考 [Getters 和 setters](https://www.dartcn.com/guides/language/language-tour#getters-和-setters).

```dart
class Point {
  num x;
  num y;
}

void main() {
  var point = Point();
  point.x = 4; // Use the setter method for x.
  assert(point.x == 4); // Use the getter method for x.
  assert(point.y == null); // Values default to null.
}
```

如果在声明时进行了示例变量的初始化， 那么初始化值会在示例创建时赋值给变量， 该赋值过程在构造函数及其初始化列表执行之前。

### 构造函数

通过创建一个与其类同名的函数来声明构造函数 （另外，还可以附加一个额外的可选标识符，如 [命名构造函数](https://www.dartcn.com/guides/language/language-tour#named-constructors) 中所述）。 下面通过最常见的构造函数形式， 即生成构造函数， 创建一个类的实例：

```dart
class Point {
  num x, y;

Point(num x, num y) {
    // 还有更好的方式来实现下面代码，敬请关注。
    this.x = x;
    this.y = y;
  }
}
```

使用 `this` 关键字引用当前实例。

**提示：** 近当存在命名冲突时，使用 `this` 关键字。 否则，按照 Dart 风格应该省略 `this` 。

通常模式下，会将构造函数传入的参数的值赋值给对应的实例变量， Dart 自身的语法糖精简了这些代码：

```dart
class Point {
  num x, y;

// 在构造函数体执行前，
  // 语法糖已经设置了变量 x 和 y。
  Point(this.x, this.y);
}
```

#### 默认构造函数

在没有声明构造函数的情况下， Dart 会提供一个默认的构造函数。 默认构造函数没有参数并会调用父类的无参构造函数。

#### 构造函数不被继承

子类不会继承父类的构造函数。 子类不声明构造函数，那么它就只有默认构造函数 (匿名，没有参数) 。

#### 命名构造函数

使用命名构造函数可为一个类实现多个构造函数， 也可以使用命名构造函数来更清晰的表明函数意图：

```dart
class Point {
  num x, y;

Point(this.x, this.y);

// 命名构造函数
  Point.origin() {
    x = 0;
    y = 0;
  }
}
```

切记，构造函数不能够被继承， 这意味着父类的命名构造函数不会被子类继承。 如果希望使用父类中定义的命名构造函数创建子类， 就必须在子类中实现该构造函数。

#### 调用父类非默认构造函数

默认情况下，子类的构造函数会自动调用父类的默认构造函数（匿名，无参数）。 父类的构造函数在子类构造函数体开始执行的位置被调用。

**警告：** 调用父类构造函数的参数无法访问 this 。  例如，参数可以为静态函数但是不能是实例函数。

#### 初始化列表

除了调用超类构造函数之外， 还可以在构造函数体执行之前初始化实例变量。 各参数的初始化用逗号分隔。

```dart
// 在构造函数体执行之前，
// 通过初始列表设置实例变量。
Point.fromJson(Map<String, num> json)
    : x = json['x'],
      y = json['y'] {
  print('In Point.fromJson(): ($x, $y)');
}
```

**警告：** 初始化程序的右侧无法访问 `this` 。

#### 重定向构造函数

有时构造函数的唯一目的是重定向到同一个类中的另一个构造函数。  重定向构造函数的函数体为空， 构造函数的调用在冒号 (:) 之后。

```dart
class Point {
  num x, y;

// 类的主构造函数。
  Point(this.x, this.y);

// 指向主构造函数
  Point.alongXAxis(num x) : this(x, 0);
}
```

#### 常量构造函数

如果该类生成的对象是固定不变的， 那么就可以把这些对象定义为编译时常量。 为此，需要定义一个 `const` 构造函数， 并且声明所有实例变量为 `final`。

```dart
class ImmutablePoint {
  static final ImmutablePoint origin =
      const ImmutablePoint(0, 0);

final num x, y;

const ImmutablePoint(this.x, this.y);
}
```

### 方法

方法是为对象提供行为的函数。

#### 实例方法

对象的实例方法可以访问 `this` 和实例变量。 以下示例中的 `distanceTo()` 方法就是实例方法：

```dart
import 'dart:math';

class Point {
  num x, y;

Point(this.x, this.y);

num distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }
}
```

#### Getter 和 Setter

Getter 和 Setter 是用于对象属性读和写的特殊方法。  回想之前的例子，每个实例变量都有一个隐式 Getter ，通常情况下还会有一个 Setter 。 使用 `get` 和 `set` 关键字实现 Getter 和 Setter ，能够为实例创建额外的属性。

```dart
class Rectangle {
  num left, top, width, height;

Rectangle(this.left, this.top, this.width, this.height);

// 定义两个计算属性： right 和 bottom。
  num get right => left + width;
  set right(num value) => left = value - width;
  num get bottom => top + height;
  set bottom(num value) => top = value - height;
}

void main() {
  var rect = Rectangle(3, 4, 20, 15);
  assert(rect.left == 3);
  rect.right = 12;
  assert(rect.left == -8);
}
```

**提示：** 类似 (++) 之类操作符不管是否定义了 getter 方法，都能够正确的执行。  为了避免一些问题，操作符只调用一次 getter 方法， 然后把值保存到一个临时的变量中。

#### 抽象方法

实例方法， getter， 和 setter 方法可以是抽象的，  只定义接口不进行实现，而是留给其他类去实现。  抽象方法只存在于 [抽象类](https://www.dartcn.com/guides/language/language-tour#抽象类) 中。

定义一个抽象函数，使用分号 (;) 来代替函数体：

```dart
abstract class Doer {
  // 定义实例变量和方法 ...

void doSomething(); // 定义一个抽象方法。
}

class EffectiveDoer extends Doer {
  void doSomething() {
    // 提供方法实现，所以这里的方法就不是抽象方法了...
  }
}
```

### 抽象类

使用 `abstract` 修饰符来定义 *抽象类* — 抽象类不能实例化。 抽象类通常用来定义接口，以及部分实现。 如果希望抽象类能够被实例化，那么可以通过定义一个 [工厂构造函数](https://www.dartcn.com/guides/language/language-tour#工厂构造函数) 来实现。

抽象类通常具有 [抽象方法](https://www.dartcn.com/guides/language/language-tour#abstract-methods)。 下面是一个声明具有抽象方法的抽象类示例：

```dart
// 这个类被定义为抽象类，
// 所以不能被实例化。
abstract class AbstractContainer {
  // 定义构造行数，字段，方法...

void updateChildren(); // 抽象方法。
}
```

### 扩展类（继承）

使用 `extends` 关键字来创建子类，  使用 `super` 关键字来引用父类：

```dart
class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
  // ···
}

class SmartTelevision extends Television {
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
  // ···
}
```

#### 重写类成员

子类可以重写实例方法，getter 和 setter。 可以使用 `@override` 注解指出想要重写的成员：

```dart
class SmartTelevision extends Television {
  @override
  void turnOn() {...}
  // ···
}
```

#### 重写运算符

下标的运算符可以被重写。 例如，想要实现两个向量对象相加，可以重写 `+` 方法。

**提示：** 你可能会被提示 `!=` 运算符为非可重载运算符。  因为 `e1 != e2` 表达式仅仅是 `!(e1 == e2)` 的语法糖。

### 枚举类型

枚举类型也称为 *enumerations* 或 *enums* ， 是一种特殊的类，用于表示数量固定的常量值。

#### 使用枚举

使用 `enum` 关键字定义一个枚举类型：

```dart
enum Color { red, green, blue }
```

枚举中的每个值都有一个 `index` getter 方法， 该方法返回值所在枚举类型定义中的位置（从 0 开始）。 例如，第一个枚举值的索引是 0 ， 第二个枚举值的索引是 1。

```dart
assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);
```

使用枚举的 `values` 常量， 获取所有枚举值列表（ list ）。

```dart
List<Color> colors = Color.values;
assert(colors[2] == Color.blue);
```

枚举类型具有以下限制：

- 枚举不能被子类化，混合或实现。
- 枚举不能被显式实例化。

有关更多信息，参考 [Dart language specification](https://www.dartcn.com/guides/language/spec) 。

### 为类添加功能： Mixin

Mixin 是复用类代码的一种途径， 复用的类可以在不同层级，之间可以不存在继承关系。

通过 `with` 后面跟一个或多个混入的名称，来 *使用* Mixin ， 下面的示例演示了两个使用 Mixin 的类：

```dart
class Musician extends Performer with Musical {
  // ···
}

class Maestro extends Person
    with Musical, Aggressive, Demented {
  Maestro(String maestroName) {
    name = maestroName;
    canConduct = true;
  }
}
```

通过创建一个继承自 Object 且没有构造函数的类，来 *实现* 一个 Mixin 。 如果 Mixin 不希望作为常规类被使用，使用关键字 `mixin` 替换 `class` 。 例如：

```dart
mixin Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;

void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}
```

指定只有某些类型可以使用的 Mixin -  比如， Mixin 可以调用 Mixin 自身没有定义的方法 -  使用 `on` 来指定可以使用 Mixin 的父类类型：

```dart
mixin MusicalPerformer on Musician {
  // ···
}
```

### 类变量和方法

使用 `static` 关键字实现类范围的变量和方法。

#### 静态变量

静态变量（类变量）对于类级别的状态是非常有用的：

```dart
class Queue {
  static const initialCapacity = 16;
  // ···
}

void main() {
  assert(Queue.initialCapacity == 16);
}
```

静态变量只到它们被使用的时候才会初始化。

**提示：** 代码准守[风格推荐指南](https://www.dartcn.com/guides/language/effective-dart/style#identifiers) 中的命名规则， 使用 `lowerCamelCase` 来命名常量。

#### 静态方法

静态方法（类方法）不能在实例上使用，因此它们不能访问 `this` 。 例如：

```dart
import 'dart:math';

class Point {
  num x, y;
  Point(this.x, this.y);

static num distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

void main() {
  var a = Point(2, 2);
  var b = Point(4, 4);
  var distance = Point.distanceBetween(a, b);
  assert(2.8 < distance && distance < 2.9);
  print(distance);
}
```

**提示：** 对于常见或广泛使用的工具和函数， 应该考虑使用顶级函数而不是静态方法。

静态函数可以当做编译时常量使用。 例如，可以将静态方法作为参数传递给常量构造函数。

## [泛型]([https://www.dartcn.com/guides/language/language-tour#%E6%B3%9B%E5%9E%8B](https://www.dartcn.com/guides/language/language-tour#泛型))

在 API 文档中你会发现基础数组类型 [List](https://api.dartlang.org/stable/dart-core/List-class.html) 的实际类型是 `List` 。 <…> 符号将 List 标记为 *泛型* (或 *参数化*) 类型。 这种类型具有形式化的参数。 通常情况下，使用一个字母来代表类型参数， 例如 E, T, S, K, 和 V 等

###  为什么使用泛型

在类型安全上通常需要泛型支持， 它的好处不仅仅是保证代码的正常运行：

- 正确指定泛型类型可以提高代码质量。
- 使用泛型可以减少重复的代码。

如果想让 List 仅仅支持字符串类型， 可以将其声明为 `List` （读作“字符串类型的 list ”）。 那么，当一个非字符串被赋值给了这个 list 时，开发工具就能够检测到这样的做法可能存在错误。 例如：

```dart
var names = List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
names.add(42); // 错误
```

另外一个使用泛型的原因是减少重复的代码。 泛型可以在多种类型之间定义同一个实现， 同时还可以继续使用检查模式和静态分析工具提供的代码分析功能。 例如，假设你创建了一个用于缓存对象的接口：

```dart
abstract class ObjectCache {
  Object getByKey(String key);
  void setByKey(String key, Object value);
}
```

```dart
abstract class StringCache {
  String getByKey(String key);
  void setByKey(String key, String value);
}
```

泛型可以省去创建所有这些接口的麻烦。 通过创建一个带有泛型参数的接口，来代替上述接口：

```dart
abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}
```

### 使用泛型类型的构造函数

在调用构造函数的时，在类名字后面使用尖括号（`<...>`）来指定泛型类型。 例如：

```dart
var nameSet = Set<String>.from(names);
```

##  库和可见性

`import` 和 `library` 指令可以用来创建一个模块化的，可共享的代码库。

### 使用库

通过 `import` 指定一个库命名空间中的内如如何在另一个库中使用。

它们可以像这样导入：

```dart
import 'dart:html';
```

`import` 参数只需要一个指向库的 URI。 对于内置库，URI 拥有自己特殊的`dart:` 方案。 对于其他的库，使用系统文件路径或者 `package:` 方案 。 `package:` 方案指定由包管理器（如 pub 工具）提供的库。例如：

```dart
import 'package:test/test.dart';
```

**提示：** *URI* 代表统一资源标识符。 *URL*（统一资源定位符）是一种常见的URI。

#### 指定库前缀

如果导入两个存在冲突标识符的库， 则可以为这两个库，或者其中一个指定前缀。 例如，如果 library1 和 library2 都有一个 Element 类， 那么可以通过下面的方式处理：

```dart
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// 使用 lib1 中的 Element。
Element element1 = Element();

// 使用 lib2 中的 Element。
lib2.Element element2 = lib2.Element();
```

#### 导入库的一部分

如果你只使用库的一部分功能，则可以选择需要导入的 内容。例如：

```dart
// Import only foo.
// 仅导入foo
import 'package:lib1/lib1.dart' show foo;

// Import all names EXCEPT foo.
// 导入除foo以外的所有
import 'package:lib2/lib2.dart' hide foo;
```

#### 延迟加载库

*Deferred loading* (也称之为 *lazy loading*) 可以让应用在需要的时候再加载库。 下面是一些使用延迟加载库的场景：

- 减少 APP 的启动时间。
- 执行 A/B 测试，例如 尝试各种算法的 不同实现。
- 加载很少使用的功能，例如可选的屏幕和对话框。

要延迟加载一个库，需要先使用 `deferred as` 来导入：

```dart
import 'package:greetings/hello.dart' deferred as hello;
```

当需要使用的时候，使用库标识符调用 `loadLibrary()` 函数来加载库：

```dart
Future greet() async {
  await hello.loadLibrary();
  hello.printGreeting();
}
```

在前面的代码，使用 `await` 关键字暂停代码执行一直到库加载完成。

##  生成器

当您需要延迟生成( lazily produce )一系列值时， 可以考虑使用_生成器函数_。 Dart 内置支持两种生成器函数：

- **Synchronous** 生成器： 返回一个 **[Iterable](https://api.dartlang.org/stable/dart-core/Iterable-class.html)** 对象。
- **Asynchronous** 生成器： 返回一个 **[Stream](https://api.dartlang.org/stable/dart-async/Stream-class.html)** 对象。

##  注释

Dart 支持单行注释、多行注释和文档注释。

### 单行注释

单行注释以 `//` 开始。 所有在 `//` 和改行结尾之间的内容被编译器忽略。

```dart
void main() {
  // TODO: refactor into an AbstractLlamaGreetingFactory?
  print('Welcome to my Llama farm!');
}
```

### 多行注释

多行注释以 `/*` 开始， 以 `*/` 结尾。 所有在 `/*` 和 `*/` 之间的内容被编译器忽略 （不会忽略文档注释）。 多行注释可以嵌套。

```dart
void main() {
  /*
   * This is a lot of work. Consider raising chickens.

Llama larry = Llama();
  larry.feed();
  larry.exercise();
  larry.clean();
   */
}
```

###  文档注释

文档注释可以是多行注释，也可以是单行注释， 文档注释以 `///` 或者 `/**` 开始。 在连续行上使用 `///` 与多行文档注释具有相同的效果。

在文档注释中，除非用中括号括起来，否则Dart 编译器会忽略所有文本。 使用中括号可以引用类、 方法、 字段、 顶级变量、 函数、 和参数。 括号中的符号会在已记录的程序元素的词法域中进行解析。

下面是一个引用其他类和成员的文档注释：

```dart
/// A domesticated South American camelid (Lama glama).
///
/// 自从西班牙时代以来，
/// 安第斯文化就将骆驼当做肉食类和运输类动物。
class Llama {
  String name;

/// 喂养骆驼 [Food].
  ///
  /// 典型的美洲驼每周吃一捆干草。
  void feed(Food food) {
    // ...
  }

/// 使用 [activity] 训练骆驼
  /// [timeLimit] 分钟。
  void exercise(Activity activity, int timeLimit) {
    // ...
  }
}
```

## [打点记录20200402](https://www.dartcn.com/guides/language/language-tour#使用库)

acodingant/markdownDocument

简介

发行版

贡献者

近期动态

acodingant/markdownDocument .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

acodingant/markdownDocument