本文由玉刚说写作平台提供写作赞助
赞助金额：200元
原作者：水晶虾饺
版权声明：本文版权归微信公众号玉刚说所有，未经许可，不得以任何形式转载
本篇文章假定读者有一定的编程经验。通过快速浏览 Dart 的一些基础特性，让读者具备使用它进行开发的基本能力。
变量
基本类型
1
2
3
4
5
6
7
8
9
10
11
| bool done = true;
int num = 2;
double x = 3.14;
final bool visible = false;
final int amount = 100;
final double y = 2.7;
const bool debug = true;
const int sum = 42;
const double z = 1.2;
|
跟常用的其他语言不同，Dart 没有 byte、char 和 float，int、double 都是 64 位。final 跟 Java 里的 final 一样，表示一个运行时常量（在程序运行的时候赋值，赋值后值不再改变）。const 表示一个编译时常量，在程序编译的时候它的值就确定了。
如果你觉得每次写变量类型太麻烦，你应该会喜欢 Dart 的类型推断功能：
1
2
3
4
5
6
7
8
9
10
11
| var done = true;
var num = 2;
var x = 3.14;
final visible = false;
final amount = 100;
final y = 2.7;
const debug = true;
const sum = 42;
const z = 1.2;
|
Dart 里所有的东西都是对象，包括 int、函数。
String
1
2
3
4
5
| var str = ' foo';
var str2 = str.toUpperCase();
var str3 = str.trim();
assert(str == str2);
assert(!identical(str, str2));
|
Dart 里的 String 跟 Java 中的一样，是不可变对象；不同的是，检测两个 String 的内容是否一样事，我们使用 == 进行比较；如果要测试两个对象是否是同一个对象（indentity test），使用 identical 函数。
List、Map 和 Set
List
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
var list = List<int>();
list.add(1);
list.add(2);
var list2 = [1, 2];
var list3 = <int>[];
list3.add(1);
list3.add(2);
var list4 = const[1, 2];
list4.add(3);
list4 = [4, 5];
const list5 = [1, 2];
list5.add(3);
var list6 = [1, 3, 5, 7];
for (var e in list6) {
print(e);
}
|
在 Dart 2 里，创建对象时可以省略 new 关键字，也推荐省略 new。
Set
1
2
3
4
| var set = Set<String>();
set.add('foo');
set.add('bar');
assert(set.contains('foo'));
|
我们只能通过 Set 的构造函数创建实例。
Map
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| var map = Map<String, int>();
map['foo'] = 1;
map['bar'] = 3;
map['foo'] = 4;
if (map['foobar'] == null) {
print('map does not contain foobar');
}
var map2 = const {
'foo': 2,
'bar': 4,
};
var map3 = <String, String>{};
|
dynamic 和 Object
前面我们说过，Dart 里所有东西都是对象。所有这些对象的父类就是 Object。
1
2
3
4
5
6
| Object o = 'string';
o = 42;
o.toString();
dynamic obj = 'string';
obj['foo'] = 4;
|
Object 和 dynamic 都使得我们可以接收任意类型的参数，但两者的区别非常的大。
使用 Object 时，我们只是在说接受任意类型，我们需要的是一个 Object。类型系统会保证其类型安全。
使用 dynamic 则是告诉编译器，我们知道自己在做什么，不用做类型检测。当我们调用一个不存在的方法时，会执行 noSuchMethod() 方法，默认情况下（在 Object 里实现）它会抛出 NoSuchMethodError。
为了在运行时检测进行类型检测，Dart 提供了一个关键字 is：
1
2
3
4
5
6
7
8
9
10
| dynamic obj = <String, int>{};
if (obj is Map<String, int>) {
obj['foo'] = 42;
}
var map = obj as Map<String, int>;
|
语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| var success = true;
if (success) {
print('done');
} else {
print('fail');
}
for (var i = 0; i < 5; ++i) {
print(i);
}
var sum = 0;
var j = 1;
do {
sum += j;
++j;
} while (j < 5);
while (sum-- > 0) {
print(sum);
}
var type = 1;
switch (type) {
case 0:
break;
case 1:
break;
case 2:
break;
default:
break;
}
|
常见的 if/else，do while，while 和 switch 在 Dart 里面都支持。switch 也支持 String 和 enum。
函数
最普通的函数看起来跟 Java 里的一样：
1
2
3
| int foo(int x) {
return 0;
}
|
Dart 也支持可选参数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| void main() {
print(foo(2));
print(foo(1, 2));
}
int foo(int x, [int y]) {
if (y != null) {
return x + y;
}
return x;
}
|
默认参数也是支持的：
1
2
3
| int foo(int x, [int y = 0]) {
return x + y;
}
|
还能用具名参数（named parameters）：
1
2
3
4
5
6
7
8
9
10
11
| void main() {
print(foo(x: 1, y: 2));
print(foo(y: 3, x: 4));
print(foo());
}
int foo({int x, int y}) {
return x + y;
}
|
具名参数也可以有默认参数：
1
2
3
4
5
6
7
8
| void main() {
print(foo(x: 1, y: 2));
print(foo());
}
int foo({int x = 0, int y = 0}) {
return x + y;
}
|
如果想告诉用户某个具名参数是必须的，可以使用注解 @required：
1
2
3
| int foo({@required int x, @required int y}) {
return x + y;
}
|
@required 是 meta 包里提供的 API，更多的信息读者可以查看 https://pub.dartlang.org/packages/meta。
函数还可以在函数的内部定义：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
typedef Adder = int Function(int, int);
Adder makeAdder(int extra) {
int adder(int x, int y) {
return x + y + extra;
}
return adder;
}
void main() {
var adder = makeAdder(2);
print(adder(1, 2));
}
|
像上面这样简单的函数，我们还可以使用 lambda：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| typedef Adder = int Function(int, int);
Adder makeAdder(int extra) {
return (int x, int y) {
return x + y + extra;
};
}
void main() {
var adder = makeAdder(2);
print(adder(1, 2));
}
|
Dart 里面不仅变量支持类型推断，lambda 的参数也支持自动推断。上面的代码还可以进一步简化为：
1
2
3
4
5
6
7
8
9
10
11
| typedef Adder = int Function(int, int);
Adder makeAdder(int extra) {
return (x, y) => x + y + extra;
}
void main() {
var adder = makeAdder(2);
print(adder(1, 2));
}
|
美中不足的是，Dart 不支持函数的重载。
异常
抛出异常：
1
| throw Exception('put your error message here');
|
捕获异常：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| try {
} on FormatException catch (e) {
} on Exception {
} catch (e) {
} finally {
}
|
跟 Java 不同的是，Dart 可以抛出任意类型的对象：
类
定义一个类：
1
2
3
4
5
6
7
8
9
10
11
12
| class Point2D {
static const someConst = 2;
int x;
final int y;
Point2D(int x, int y) {
this.x = x;
this.y = y;
}
}
|
由于这种初始化方式很常见，Dart 提供了更简洁的方式：
1
2
3
4
5
6
| class point2d {
int x;
int y;
point2d(this.x, this.y);
}
|
此外，还可以使用初始化列表（initializer list）对对象进行初始化：
1
2
3
4
5
6
7
8
9
10
| class Point2D {
int x;
int y;
Point2D(int x, int y) : x = x, y = y {
}
}
|
initializer list 会在构造函数的函数体运行前执行。
Dart 具有垃圾收集功能，对象的使用跟 Java 里几乎是一样的：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| main() {
var point = Point2D(1, 2);
point.x = 4;
print(point);
}
class Point2D {
int x;
int y;
Point2D(this.x, this.y);
@override
String toString() {
return "Point2D{x=$x, y=$y}";
}
}
|
Dart 使用 package 的概念来管理源码和可见性。它没有 public、private 之类的访问权限控制符，默认情况下，所有的符号都是公开的。如果我们不想某个变量对包的外部可见，可以使用下划线开头来给变量命名。
1
2
3
4
5
6
7
| class _Foo {
}
class Bar {
int _x;
}
|
下面我们使用 Dart 的访问控制，实现一个带偏移量的 Point：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| class OffsetPoint {
int _x;
int _y;
int offset;
OffsetPoint(int x, int y, int offset)
: _x = x, _y = y, offset = offset {}
int get x => _x + offset;
int get y {
return _y + offset;
}
void set x (int x) => _x = x;
void set y (int y) => _y = y;
@override
String toString() {
return "OffsetPoint{x=$x, y=$y}";
}
}
main() {
var point = OffsetPoint(1, 2, 10);
print(point.x)
print(point);
point.x = 4;
print(point);
}
|
在 Dart 里继承对象也很简单：
1
2
3
4
5
6
7
8
9
10
11
12
| class Point2D {
int x;
int y;
Point2D(this.x, this.y);
}
class Point3D extends Point2D {
int z;
Point3D(int x, int y, int z): z = z, super(x, y) {
}
}
|
但是对象构造时它跟 Java、C++ 都不太一样：
- 先执行子类 initializer list，但只初始化自己的成员变量
- 初始化父类的成员变量
- 执行父类构造函数的函数体
- 执行之类构造函数的函数体
基于这个初始化顺序，推荐是把 super() 放在 initializer list 的最后。此外，在 initializer list 里不能访问 this（也就是说，只能调用静态方法）。
虽然 Dart 是单继承的，但它也提供了一定程度的多重继承支持：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| abstract class Bark {
void bark() {
print('woof');
}
}
class Point3D extends Point2D with Bark {
int z;
Point3D(int x, int y, int z): z = z, super(x, y) {
}
}
class Foo extends Bark {}
void main() {
var p = Point3D(1, 2, 3);
p.bark();
}
|
Dart 把支持多重继承的类叫做 mixin。更详细的介绍，读者可以参考https://www.dartlang.org/articles/language/mixins。
泛型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Pair<S, T> {
S first;
T second;
Pair(this.first, this.second);
}
void main() {
var p = Pair('hello', 2);
print(p is Pair<String, int>);
print(p is! Pair<int, int>);
print(p is Pair);
}
|
跟 Java 不同，Dart 的泛型参数类型在运行时是保留的。
Future
Dart 是单线程的，主线程由一个事件循环来执行（类似 Android 的主线程）。对于异步代码，我们通过 Future 来获取结果：
1
2
3
4
5
6
7
8
9
|
import 'dart:io';
void foo() {
var file = File('path-to-your-file');
file.exists()
.then((exists) => print('file ${exists ? 'exists' : 'not exists'}'))
.catchError((e) => print(e));
}
|
Dart 2 提供了 async 函数，用来简化这种编程范式。下面这段代码的效果跟上面是一样的：
1
2
3
4
5
6
7
8
9
| void foo() async {
var file = File('path-to-your-file');
try {
var exists = await file.exists();
print('file ${exists ? 'exists' : 'not exists'}');
} catch (e) {
print(e);
}
}
|
但是要注意，上面两段代码并不是完全一样的：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| import 'dart:io';
void main() {
foo();
bar();
}
void bar() {
var file = File('path-to-your-file');
file.exists()
.then((exists) => print('bar: file ${exists ? 'exists' : 'not exists'}'))
.catchError((e) => print(e));
print('bar: after file.exists() returned');
}
void foo() async {
var file = File('path-to-your-file');
try {
var exists = await file.exists();
print('bar: file ${exists ? 'exists' : 'not exists'}');
print('bar: after file.exists() returned');
} catch (e) {
print(e);
}
}
|
这里的关键在于，bar 函数里面，file.exists()... 执行完后，会马上执行下面的语句；而 foo 则会等待结果，然后才继续执行。关于 Future 的更多的细节，强烈建议读者阅读https://webdev.dartlang.org/articles/performance/event-loop。
最后需要说明的是，Dart 的生成器、Stream 在这里我们并没有介绍，读者可以参考 https://www.dartlang.org/guides/language/language-tour。此外，Dart 官网还有许多资源等待读者去发掘。