WangShuXian6
commented
3 years ago 简介
Dart是一 门通用编程语言，是有着类似 C 语言的语法的新语言，其目的是让绝大多数程序员快速上手。 下面是约定俗成的 “Hello World"示例，
main() { print('hello world'); }Dart是纯面向对象、基于类、使用可选类型、支持混入式继承及Actor模式的并发编程语言。
动机
Dart立志成为 一 个精心设计的开发平台，为当下的开发者要编写的各种应用提供支持。 它力图屏蔽底层平台的各种问题与实现的细节，让开发者能方便地使用这些新兴平台所提供的强大功能。
设计准则
万物皆对象
Dart是一门纯面向对象的编程语言，这意味着 Dart 程序在运行时所处理的值都是对象，甚至包括数字、布尔值等基本数据，无 一 例外。 Dart坚持对所有数据统一处理，这方便了所有与语言相关的人员：语言的设计者、实现者，以及最重要的使用者。 举个例子，集合类能够操作任意类型的数据，使用者无须关注自动转箱、拆箱的问题。 类似的底层细节与开发者要解决的实际问题是无关的，编程语言的 一 个关键任务是把开发者从各种可认知的负担中解放出来。 采用统 一 的对象模型的同时，简化了系统实现者的任务
面向接口编程， 而非面向实现
关注对象的行为而非它的内部实现，这是面向对象编程语言的核心原则
Dart却力图通过以下几种方式来维护这个原则
• Dart 的类型基于接口，而不是类。作为一项原则，任意类都隐含了一个接口，能够被其他类实现，不管其他类是否使用了同样的底层实现（部分core type 例外，比如数字、布尔值与字符串）。 • Dart 没有final 方法，允许重写几乎所有方法（同样，部分内置的操作符例外）。 • Dart 把对象进行了抽象封装，确保所有外部操作都通过存取方法来改变对象的状 态。 • Dart 的构造函数允许对对象进行缓存，或者从子类型创建实例，因此使用构造函数并不意味着绑定了一个具体的实现。
类型是为开发者服务的
静态类型信息可以为用户与计算机提供富有价值的文档。如果使用得当，则这些信息能使代码更易读，特别是涉及多个库时，也使自动化工具更容易协助开发者。 类型简化了各种分析任务，特别是可以帮助编译器提升程序的性能。 它还有助千检测编程错误。
Dart 是一门类型可选的语言，
它的具体定义是： • 类型在语法层面上来说是可选的； • 类型对运行时语义没有影响。
类型变为可选，照顾了那些不愿意与类型系统打交道的开发者。 因此而选择Dart 的开发者，完全可以把Dart 当成一门动态类型语言。 虽然类型可选，但只要代码中有类型注解，就意味着代码有了额外的文档，所有的编码人员都会从中受益。 类型注解同时让工具能更好地配合开发者的开发工作。 对于可能存在的类型不一致和遗漏， Dart 会给出警告，不会报错。这些警告的程度与性质都经过校准，不会铺天盖地地出现，确保真正对开发者有益。 同时， Dart 编译器不会拒绝一段缺少类型或类型不一致的程序。因此，使用类型不会限制开发者的工作流程。类型缺失或不完整的代码，仍然可被用来测试和实验。 静态的正确性与灵活性之间的平衡使得类型服务千开发者。
限制
Dart 必须在当下的浏览器上高效运行。 Dart 必须让当下的开发者能够快速上手， 这决定了它的语法必须是近似C 语言的，也决定了Dart 的语义选择不能偏离主流开发者的期望。
Dart 的语义已经受到了上述限制的影响时，我们应该注意为此所做的设计决策而引入的利弊权衡，包括字符串、数字的处理，以及返回语句等。
概述
Dart 的一个简单表达式：
3毋庸置疑，这个表达式的值是整数3 。
稍微复杂的表达式：
3 + 4 (3+4}*6 1 + 2 * 2 1234567890987654321 * 1234567890987654321它们的值分别是7 、42 、5 及 I 524 157 877 457 704 723 228 166 437 789 971 041 。
Dart 中的整数很像数学里的数字，它们没有32 位或64 位可代表的最大值的限制，其大小的唯一限制是可用内存。
Dart 不仅支持整数，也支持浮点数、字符串、布尔值等。许多内置类型都有简便的语法：
3.14159 //一个浮点数 'a string' "another string - both double quoted and single quoted forms are supported" 'Hello World' //你已经见过它 true false// 所有的布尔值都在这里 [] //一个空的列表 (0, 1.0, false, 'a', [2, 2.0, true, \b"]] //有5 个元素的列表，最后一个也是列表Dart 支持标准的单行注释，即在II之后的内容将被忽略，直到行末。 最后两行是用字面量表示的列表，第1 个列表为空，第2 个列表的长度是5, 且最后一个元素是另一个长度为4 的字面量列表（注：这里的列表相当千其他语言的数组，因为Dart 是用List 来表示数组的，所以还是翻译为列表）。
[1, 2, 3] [1]上面例子的值是2 。列表的第1 个元素的索引是0 ，第2 个是1 ，以此类推。 列表有length与isEmpty 两个属性（它还有更多的属性）。
[1, 2, 3].length; // 3某些Dart 的实现可能并不符合这一原则。在Dart 被编译为JavaScript 时，所有数字都变成了JavaScript的数字，而JavaScript 只有数字类型且没有整数类型，即要用浮点数来表示整数，并有大小限制。所以，大千2^53^ 的整数可能就不那么容易获得了。
[].length; // 0 [].isEmpty; // true ['a'].isEmpty; // false定义函数 Dart 函数main(）
main() { print ('Hello World'); }一个Dart 程序的执行总是开始千对main(）函数的调用。 每个函数都由函数头与函数体组成。 函数的头部定义了函数的名称与参数（我们的示例函数没有参数）。 main()方法的函数体中只有一条语句，即调用了接收一个参数的print(）函数。 这里传递的参数是一个字面量的字符串'Hello World' 。 程序运行的效果是打印出“Hello World" 。
另一个函数：
twice(x) => x * 2;声明了一个名为twice 的函数，并有一个名为x 的参数。该函数返回x 乘以2 的结果。可以这样写来执行它：
twice(2)以上函数调用的结果是4 。这个twice 函数有两部分，一部分是由函数名与形式参数组成的函数签名，另一部分就是跟在
＝＞后面的只包含了一个表达式的函数体。另一种更传统的书写方式是：twice(x) { return x * 2; }以上两个例子是完全相等的，但在第2 个例子中，函数体可以包含零个或多个语句。它只是调用了一个retum 语句，使函数计算出x*2 的结果并将其返回给调用者。
另一个例子如下：
max(x, y) { if (x > y) return x; else return y; }它将返回两个参数中更大的那一个。我们同样可以把它缩写成这样：
max(x, y) => (x > y) ? x : y;第1 种形式使用了if 语句，这在其他编程语言中是很常见的；第2 种形式使用了条件表达式，同样，这在类C 的编程语言中也是很常见的。使用表达式能让我们使用缩写方式来定义函数。
一个更加复杂的函数：
maxElement(a) { var currentMax = a.isEmpty ? throw 'Maximal element undefined for empty array' : a[0]; for (var i = 0; i < a.length; i++) { currentMax = max(a[i], currentMax); return currentMax; } }这个名叫maxElement 的函数，接收一个列表a 并返回其中的最大值。在这里，我们真正需要使用常规方式来定义函数，因为这里的计算有很多步骤，会产生一连串的语句
函数体的第1 行声明了一个名为currentMax 的变量，并对其进行初始化。Dart 程序中的每个变量都必须显式声明。变量currentMax 代表我们目前数组中的最大值。
在许多编程语言中，开发者可能会选择把currentMax 初始化为一个值，这个值代表可能的最小整数，它的典型名称是MIN_INT 。在数学上， “可能的最小整数”的说法是很荒谬的。但是，在数字大小有限制的编程语言里，这个说法是有意义的。前面介绍过， Dart的整数是没有大小限制的，所以我们直接把currentMax 初始化为列表的第1 个元素。如果列表为空，则我们不能那样做，那也意味着传入的参数a 是无效的，因为你无法获取一个空列表的最大值。因此，我们检测了a 是否为空。如果为空，我们就会抛出一个异常，否则我们就用列表的第1 个值来初始化currentMax 。 异常是使用throw 语句抛出的。throw 关键字后面跟着一个定义抛出内容的表达式。在Dart 中，任何类型值都可以被抛出，不要求它们是特定的Exception 类型。在这里，我们抛出了一个描述问题的字符串。在下一行的开头，循环语句for 遍历了整个列表1, 使用前面定义好的max 函数，把每个元素依次与currentMax 进行比较。如果当前元素大千currentMax, 则我们把它作为新的最大值赋给currentMax 。循环结束后，我们就可以断定currentMax 是列表中最大的元素并把它返回。
Dart 允许你在类外部定义函数（比如前面的twice 、max 与maxElement) 与变量。虽然如此， Dart 是一门纯面向对象语言。我们 前面看过的所有值，包括数字、字符串、布尔值、列表甚至函数本身都是Dart 中的对象。所有这些对象都是某个类的实例。像length 、isEmpty 这些操作，甚至［］索引操作符，都是对象的方法。
编写一个类。 Point 类，它代表了直角坐标系的点：
class Point { var x, y; Point(a, b) { x = a; y = b; } }Point 类有两个实例变量（或者字段） x 与y。要创建一个Point 类的实例，我们可以用new 表达式来调用它的构造函数：
var origin= new Point(0, 0); var aPoint = new Point(3, 4); var anotherPoint = new Point(3, 4);以上3 行创建了3 个新的不一样的Point 实例。特别是， aPoint 与anotherPoint 是两个不同的对象。每个对象都有唯一标识，它们通过这个标识来区分彼此。 每个Point 的实例都有各自的x 和y 变量的副本，可以通过点符号来访问它们：
origin.x // 0 origin.y // 0 aPoint.x // 3 aPoint.y // 4变量x 与y 的值是由构造函数的实际参数来设置的，而构造函数是由new 调用的。将构造函数的形式参数直接赋值给同名的字段，这种方式非常普遍，所以Dart 为此提供了一 种特殊的语法糖：
class Point { var x, y; Point(this.x, this.y); }新版的Point 与原版完全相同，但更简洁。我们再给它添加一些行为：
class Point { var x, y;
Point(this.x, this.y); scale(factor) => new Point(x factor, y factor); }
>这个版本多了一个scale 方法，它接收一个定义比例系数的参数factor, 并返回一个新的点。新的点的坐标是根据当前点的坐标按照factor 缩放而得来的。
```dart
aPoint.scale(2).x // 6
anotherPoint.scale(10).y // 40另一个有趣的操作是对点进行加法操作：
class Point { var x, y; Point(this.x, this.y); scale(factor) => new Point(x * factor, y * factor); operator +(p) => new Point(x + p.x, y + p.y); }现在我们可以写这样的表达式了：
var temp = (aPoint + anotherPoint).y; // 8点的
＋操作符的行为就像是一个实例方法，而事实上，它们就是一个有着怪异名称和调用语法的实例方法。Dart 也支持静态成员。我们可以给Point 添加一个计算两点间距离的静态方法：
import 'dart:math';
class A { static distance(pl, p2) { var dx = pl.x - p2.x; var dy = pl.y - p2.y; return sqrt(dx dx + dy dy); } }
>static 修饰符表明此方法不针对某个特定实例，它无法访问实例变量x 和y, 因为实例变量对千每个Point 实例都是不同的。这个方法使用了一个库函数sqrt()来计算平方根。
>你可能会问， sqrt()从何而来？要理解这一点，我们需要先解释Dart 的模块化理念。
>Dart 代码用库作为模块化的基本单元。每个库都定义了一个的命名空间，这个命名空间包含所有在库中声明的实体的名称，其他库的实体也能被导入进来。Dart 核心库中声明的实体，都会被隐含地导入到所有的Dart 库中。然而， sqrt(）并不在核心库中。它位于一个名为dart:math 的库中，如果你要使用它，就必须先显式地导入这个库。
>下面是一个导入的库的完整例子，它包含了Point 类：
```dart
library points;
import 'dart:math';
class Point {
var x, y;
Point(this.x, this.y);
scale(factor) => new Point(x * factor, y * factor);
operator +(p) => new Point(x + p.x, y + p.y);
static distance(pl, p2) {
var dx = pl.x - p2.x;
var dy = pl.y - p2.y;
return sqrt(dx * dx + dy * dy);
}
}我们声明了一个名为points 的库并同时导入了dart:math 库。 这个导入的库使得points库可以访问sqrt 函数。现在，任意其他库都可以导入points 库来使用我们的Point 类。 需要注意的一个关键细节是import 后面跟着的是一个字符串
'dart:math'。 一般情况下，导入指向的都是用字符串表示的统一资源标志符(UR1) 。编译器通过这些URI 指定的位置去寻找对应的库。 Dart 的内置标准库都使用'dart:c'这种方式的UR1 ，其中c代表某一特定库。
相关语言及其对Dart 的影响
Dart 的设计深受早期编程语言的影响，特别是Smalltalkw 、Java 和JavaScript。Dart 的语法贴近C 语言、Java 和JavaScript。 从某些角度看，特别是在坚待纯对象模型这点上，Dart 的语义贴近Smalltalk 。
不过， Dart 有很多至关重要的不同点。Dart 引入了自己的基于库的封装模型，这不同于上面提到的所有语言。 Smalltalk 支待对字段进行基千对象的封装，方法和类则是全局的。 Java 使用基于类的封装和包级别的访问控制， JavaScript 则完全依赖闭包的封装。 与Smalltalk 和Java 相似， Dart 基于类，支持单继承，但增加了基千混入的继承，这种实现方式首次出现千Smalltalk 的方言Strongtalk中。 Smalltalk 的类方法是实例方法，而Dart 的类方法更像Java 风格的静态方法，所以，它们不完全一样。 Dart 的构造函数在语法上与Java 非常相似，实际上却有很大不同。 Dart 的类型检查也非常像Strongtalk。 Dart 的并发机制接近最早的Actor 模式（尽管势在必行），同样，这与上面提及的语言都不一样。 Erlang 的成功是促使Dart 选用Actor 模式的关键因素，但不同的是， Dart 采用了非阻塞的并发模型。 Dart 还内置了对异步编程的支待，这方面受到了C＃的巨大影响。
Dart
Dart 开发语言概览
一个简单的 Dart 程序
重要概念
关键字
变量 Variables
默认值
final 和 const
使用关键字 const 修饰变量表示该变量为 编译时常量。
内置类型
num
int
整型字面量将会在必要的时候自动转换成浮点数字面量：
整型支持传统的位移操作
字符串和数字之间转换的方式：
数字字面量为编译时常量
字符串 String
${表达式}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!');
“raw” 字符串
// 代码中文解释 var s = r'在 raw 字符串中，转义字符串 \n 会直接输出 “\n” 而不是转义为换行。';
bool
应该总是显示地检查布尔值
// 检查是否小于等于零。 var hitPoints = 0; assert(hitPoints <= 0);
// 检查是否为 null。 var unicorn; assert(unicorn == null);
// 检查是否为 NaN。 var iMeantToDoThis = 0 / 0; assert(iMeantToDoThis.isNaN);
可以在 Dart 的集合类型的最后一个项目后添加逗号
list[1] = 1; assert(list[1] == 1);
扩展操作符
...和 空感知扩展操作符...?可以使用扩展操作符
...将一个 List 中的所有元素插入到另一个 List 中：如果扩展操作符右边可能为 null ，你可以使用 null-aware 扩展操作符
...?来避免产生异常：集合中的 if 和 集合中的 for 操作
Set
可以使用在
{}前加上类型参数的方式创建一个空的 Set，或者将{}赋值给一个 Set 类型的变量：使用
.length可以获取 Set 中元素的数量：可以在 Set 字面量前添加 const 关键字创建一个 Set 编译时常量：
从 Dart 2.3 开始，Set 可以像 List 一样支持使用扩展操作符
...和...?以及 Collection if 和 for 操作Map
var nobleGases = { 2: 'helium', 10: 'neon', 18: 'argon', };
向现有的 Map 中添加键值对与 JavaScript 的操作类似：
如果检索的 Key 不存在于 Map 中则会返回一个 null：
使用 .length 可以获取 Map 中键值对的数量：
在一个 Map 字面量前添加 const 关键字可以创建一个 Map 编译时常量：
Map 可以像 List 一样支持使用扩展操作符
...和...?以及集合的 if 和 for 操作。runes 与 grapheme clusters
Symbol
函数 Function
参数 Parameter
命名参数
可选的位置参数
默认参数值
设置可选参数默认值示例：
为位置参数设置默认值：
List 或 Map 同样也可以作为默认值
main()函数下面是一个简单 main() 函数：
使用命令行访问带参数的
main()函数示例：函数是一级对象
可以将函数作为参数传递给另一个函数
可以将函数赋值给一个变量
匿名函数
如果函数体内只有一行返回语句，你可以使用胖箭头缩写法。
词法作用域
void main() { var insideMain = true;
void myFunction() { var insideFunction = true;
} }
测试函数是否相等
class A { static void bar() {} // 定义静态方法 void baz() {} // 定义实例方法 }
void main() { Function 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;
// 这两个闭包引用了相同的实例对象，因此它们相等。 assert(y.baz == x);
// 这两个闭包引用了不同的实例对象，因此它们不相等。 assert(v.baz != w.baz); }
运算符 Operator
// 难以理解，但是与上面的代码效果一样。 if (n % i == 0 && d % i == 0) ...
var a, b;
a = 0; b = ++a; // 在 b 赋值前将 a 增加 1。 assert(a == b); // 1 == 1
a = 0; b = a++; // 在 b 赋值后将 a 增加 1。 assert(a != b); // 1 != 0
a = 0; b = --a; // 在 b 赋值前将 a 减少 1。 assert(a == b); // -1 == -1
a = 0; b = a--; // 在 b 赋值后将 a 减少 1。 assert(a != b); // -1 != 0
赋值运算符
逻辑运算符
按位和移位运算符
assert((value & bitmask) == 0x02); // 按位与 (AND) assert((value & ~bitmask) == 0x20); // 取反后按位与 (AND NOT) assert((value | bitmask) == 0x2f); // 按位或 (OR) assert((value ^ bitmask) == 0x2d); // 按位异或 (XOR) assert((value << 4) == 0x220); // 位左移 (Shift left) assert((value >> 4) == 0x02); // 位右移 (Shift right)
// Very long version uses if-else statement. String playerName(String? name) { if (name != null) { return name; } else { return 'Guest'; } }
级联运算符可以嵌套
在返回对象的函数中谨慎使用级联操作符。
其他运算符
流程控制语句
If 和 Else
For 循环
在 Dart 语言中，for 循环中的闭包会自动捕获循环的 索引值 以避免 JavaScript 中一些常见的陷阱。
如果要遍历的对象是一个可迭代对象（例如 List 或 Set），并且你不需要知道当前的遍历索引，则可以使用 for-in 方法进行 遍历：
While 和 Do-While
while 循环会在执行循环体前先判断条件：
do-while循环则会 先执行一遍循环体 再判断条件：Break 和 Continue
Switch 和 Case
不匹配任何 case 语句的情况下，会执行 default 子句中的代码：
忽略了 case 子句的 break 语句，会产生错误:
但是，Dart 支持空的 case 语句，允许其以
fall-through的形式执行。在非空 case 语句中想要实现
fall-through的形式，可以使用 continue 语句配合 label 的方式实现:断言 assert
assert 的第二个参数可以为其添加一个字符串消息。
异常 Exception
抛出异常
捕获异常
void main() { try { misbehave(); } catch (e) { print('main() finished handling ${e.runtimeType}.'); } }
类 class
使用类的成员
// 获取 y 值 assert(p.y == 2);
// 调用变量 p 的 distanceTo() 方法。 double distance = p.distanceTo(Point(4, 4));
使用构造函数 constructor
assert(identical(a, b)); // 它们是同一个实例 (They are the same instance!)
assert(!identical(a, b)); // 这两变量并不相同 (NOT the same instance!)
实例变量
void main() { var point = Point(); point.x = 4; // 使用 x 的 Setter 方法。 assert(point.x == 4); // 使用 x 的 Getter 方法。 assert(point.y == null); // 默认值为 null。 }
构造函数
Point(double x, double y) { // 还会有更好的方式来实现此逻辑，敬请期待。 this.x = x; this.y = y; } }
默认构造函数
构造函数不被继承
命名式构造函数
可以为一个类声明多个命名式构造函数来表达更明确的意图：
调用父类非默认构造函数
Person.fromJson(Map data) { print('in Person'); } }
class Employee extends Person { // Person does not have a default constructor; // you must call super.fromJson(data). Employee.fromJson(Map data) : super.fromJson(data) { print('in Employee'); } }
void main() { var employee = Employee.fromJson({}); print(employee); // Prints: // in Person // in Employee // Instance of 'Employee' }
初始化列表
class Point { final double x; final double y; final double distanceFromOrigin;
Point(double x, double y) : x = x, y = y, distanceFromOrigin = sqrt(x x + y y); }
void main() { var p = Point(2, 3); print(p.distanceFromOrigin); }
常量构造函数
final double x, y;
const ImmutablePoint(this.x, this.y); }
var logMap = {'name': 'UI'}; var loggerJson = Logger.fromJson(logMap);
操作符
为了表示重写操作符，使用 operator 标识来进行标记。
Vector(this.x, this.y);
Vector operator +(Vector v) => Vector(x + v.x, y + v.y); Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
// Operator == and hashCode not shown. // ··· }
void main() { final v = Vector(2, 3); final w = Vector(2, 2);
assert(v + w == Vector(4, 5)); assert(v - w == Vector(0, 1)); }
抽象方法
void doSomething(); // 定义一个抽象方法。 }
class EffectiveDoer extends Doer { void doSomething() { // 提供一个实现，所以在这里该方法不再是抽象的…… } }
隐式接口 implements
// 构造函数不在接口中。 Person(this._name);
// greet() 方法在接口中。 String greet(String who) => '你好，$who。我是$_name。'; }
// Person 接口的一个实现。 class Impostor implements Person { String get _name => '';
String greet(String who) => '你好$who。你知道我是谁吗？'; }
String greetBob(Person person) => person.greet('小芳');
void main() { print(greetBob(Person('小芸'))); print(greetBob(Impostor())); }
扩展一个类 extends
class SmartTelevision extends Television { void turnOn() { super.turnOn(); _bootNetworkInterface(); _initializeMemory(); _upgradeApps(); } // ··· }
covariant
class Mouse extends Animal { ... }
class Cat extends Animal { @override void chase(covariant Mouse x) { ... } }
只有下面其中一个条件成立时，你才能调用一个未实现的方法：
扩展方法
print('42'.padLeft(5)); // Use a String method. print('42'.parseInt()); // Use an extension method.
switch (aColor) { case Color.red: print('红如玫瑰！'); break; case Color.green: print('绿如草原！'); break; default: // 没有该语句会出现警告。 print(aColor); // 'Color.blue' }
实现一个 mixin
void entertainMe() { if (canPlayPiano) { print('Playing piano'); } else if (canConduct) { print('Waving hands'); } else { print('Humming to self'); } } }
类变量和方法 static
静态变量
void main() { assert(Queue.initialCapacity == 16); }
泛型 Generic
为什么使用泛型？
使用集合字面量
使用类型参数化的构造函数
泛型集合以及它们所包含的类型
限制参数化类型
<T extends SomeBaseClass>class Extender extends SomeBaseClass {...}
使用泛型方法
function<T>库和可见性
使用库 import
指定库前缀 as
// 使用 lib1 的 Element 类。 Element element1 = Element();
// 使用 lib2 的 Element 类。 lib2.Element element2 = lib2.Element();
延迟加载库 deferred as
实现库
异步支持
处理 Future
声明异步函数 async
处理 Stream
使用 await for 定义异步循环看起来是这样的：
使用 break 和 return 语句可以停止接收 Stream 数据，这样就跳出了循环并取消注册监听 Stream。
如果在实现异步 for 循环时遇到编译时错误，请检查确保 await for 处于异步函数中。
生成器 generator
可调用类 call
var wf = WannabeFunction(); var out = wf('你好', '，使用 Dart 的', '朋友');
void main() => print(out);
int sort(int a, int b) => a - b;
void main() { assert(sort is Compare); // True!
}
自定义元数据注解
class Todo { final String who; final String what;
const Todo(this.who, this.what); }
注释
单行注释
多行注释
Llama larry = Llama(); larry.feed(); larry.exercise(); larry.clean(); */ }
Dart 编程语言规范