Dart - 快速入门（二）

运算符

类型测试操作符

as ， is ， is! 运算符在运行时检查类型时非常方便。

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

}

也可以使用as运算符缩短代码的长度

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

注意：如果emp为空或者不是Person，则第一个例子什么都不做; 第二个例子将会引发异常。

负值操作符

可以使用=运算符来分配值。 要仅在赋值变量为空时分配，可以使用??=运算符。

// 附值给a ;
a = value;
// 如果b为null，则赋值给b; 否则，b保持不变
b ??= value;

如下为常见赋值符：

操作符	等价表达式
a op= b	a = a op b
a+=b	a=a+b

逻辑运算符

可以使用逻辑运算符表示布尔表达式。

操作符	含义
!expr	逻辑非
||	逻辑或
&&	逻辑与

如下例子：

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

条件表达式

Dart有两个运算符，可以简化if-else表达式：

1、condition ? expr1 : expr2  ：如果条件为真，则为expr1表达式的值; 否则，并返回expr2的值。

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

 

2、expr1 ?? expr2  ：如果expr1非空，则返回其值; 否则，返回expr2的值。

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

级联操作符..

级联(..)允许对同一对象执行一系列操作。 除了函数调用，还可以访问同一对象上的字段。 这通常可以节省创建临时变量的步骤：

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

控制语句

可以使用以下任意一种方式控制Dart代码的执行流程：

1、if 和 else

2、for 循环

3、while 和 do-while 循环

4、break 和 continue

5、switch 和 case

6、assert

还可以使用try-catch和throw来控制异常。

if -else

Dart支持if语句和可选的else语句：

if (isRaining()) {
 you.bringRainCoat();
} else if (isSnowing()) {
 you.wearJacket();
} else {
 car.putTopDown();
}

与JavaScript不同，条件必须使用布尔值，而不能使用其他值。

for循环

可以使用标准的for循环进行迭代。 例如：

var message = StringBuffer('Dart is fun');
for (var i = 0; i < 5; i++) {
 message.write('!');
}

如果要迭代的对象是Iterable，则可以使用forEach()方法:

candidates.forEach((candidate) => candidate.interview());

List和Set之类的可迭代类也支持for-in形式的迭代：

var collection = [0, 1, 2];
for (var x in collection) {
 print(x); // 0 1 2
}

While 和 do-while 循环

while循环会先判断循环之前的条件：

while (!isDone()) {
 doSomething();
}

do-while循环会先执行一遍循环的代码：

do {
 printLine();
} while (!atEndOfPage());

 

Break 和 continue

使用break停止循环：

while (true) {
 if (shutDownRequested()) break;
 processIncomingRequests();
}

使用continue跳转到下一个循环：

for (int i = 0; i < candidates.length; i++) {
 var candidate = candidates[i];
 if (candidate.yearsExperience < 5) {
 continue;
 }
 candidate.interview();
}

Switch 和 case

Dart中的switch语句使用==比较整数，字符串或编译时常量:

var command = 'OPEN';
switch (command) {
 case 'CLOSED':
 executeClosed();
 break;
 case 'PENDING':
 executePending();
 break;
 case 'APPROVED':
 executeApproved();
 break;
 case 'DENIED':
 executeDenied();
 break;
 case 'OPEN':
 executeOpen();
 break;
 default:
 executeUnknown();
}

还可以使用continue：

var command = 'CLOSED';
switch (command) {
case 'CLOSED':
executeClosed();
continue nowClosed;
// 继续执行nowClosed.

nowClosed:
case 'NOW_CLOSED':
executeNowClosed();
break;
}

Assert

在开发过程中，可以使用断言语句— assert(condition，optionalMessage); —如果布尔条件为假，则中断正常执行。

//确保变量具有非空值
assert(text != null);

// 确保该值小于 100
assert(number < 100);

// 确保是一个https URL
assert(urlString.startsWith('https'));

Exceptions

Dart代码可以引发并捕获异常。它指示发生了意外情况。 如果未捕获到异常，则引发异常的isolate将被暂停，并且通常isolate会及其程序终止。

与Java相比，Dart的所有异常都是未经检查的异常。 方法不声明它们可能引发哪些异常，并且不需要捕获任何异常。

Dart提供了Exception和Error类型，以及许多预定义的子类型。 当然，也可以定义自己的异常。 但是，Dart程序可以将任何非null对象作为异常抛出。

throw

这是引发异常的示例：

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

还可以抛出任意对象：

throw 'Out of llamas!';

因为抛出的异常是一个表达式，所以可以在=>语句以及允许表达式的其他任何地方抛出异常：

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

catch

捕获异常会阻止该异常的传递。 捕获异常使你有机会处理它：

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

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

try {
 breedMoreLlamas();
} on OutOfLlamasException {
 // 特定类型异常
 buyMoreLlamas();
} on Exception catch (e) {
 // 其他的Exception
 print('Unknown exception: $e');
} catch (e) {
 // 除了上面的，处理其他所有异常
 print('Something really unknown: $e');
}

可以指定一个或两个参数来catch。 第一个是引发的异常，第二个是堆栈跟踪（StackTrace对象）：

<span style="font-family: Consolas, Monaco, monospace;">try {</span>
 // ···
} on Exception catch (e) {
 print('Exception details:\n $e');
} catch (e, s) {
 print('Exception details:\n $e');
 print('Stack trace:\n $s');
}

要部分处理异常，同时允许其传递，使用rethrow关键字：

void misbehave() {
try {
dynamic foo = true;
print(foo++); // Runtime error
} catch (e) {
print('misbehave() partially handled ${e.runtimeType}.');
rethrow;
}
}

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

finally

为了确保某些代码无论是否引发异常都可以运行，使用finally子句。 如果没有catch子句与该异常匹配，则在finally子句运行后传递该异常：

try {
 breedMoreLlamas();
} finally {
 // 总是执行，并且异常会抛出
 cleanLlamaStalls();
}

finally子句在任何匹配的catch子句之后运行：

try {
 breedMoreLlamas();
} catch (e) {
 print('Error: $e'); 
} finally {
 cleanLlamaStalls(); 
}