Dart 学习笔记

布尔值判断：只有 true 对象才被认为是 true，其他：实例对象，null，false 都判断为false

创建一个 “原始 raw” 字符串：

通过提供一个 r 前缀可以创建一个 “原始 raw” 字符串：

var s = r"In a raw string, even \n isn't special."
\n 不起作用，直接当做普通字符

Cascade notation (..)（级联操作符）

方法参数：命名参数，可选参数，参数默认值

命名参数：

enableFlags({bool bold, bool hidden}) {
  // ...
}
调用例子： enableFlags(bold: true, hidden: false)

可选参数：

String say(String from, String msg, [String device]) {
   var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}
调用例子：say('Bob', 'Howdy')  say('Bob', 'Howdy', 'smoke signal')

参数默认值（可选参数，默认值为null ）

void enableFlags({bool bold = false, bool hidden = false}) {
  // ...
}
调用例子：enableFlags(bold: true);

Anonymous functions（匿名方法）也被称为 lambda 或者 closure 闭包

var list = ['apples', 'oranges', 'grapes', 'bananas', 'plums'];
list.forEach((i) {
  print(list.indexOf(i).toString() + ': ' + i);
});
//如果方法只包含一个语句，可以使用胖箭头语法缩写
list.forEach((i) => print(list.indexOf(i).toString() + ': ' + i));

操作符优先级

从左到右，从上到下
描述操作符
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 = *= /= ~/= %= += -= <<= >>= &= ^= |= ??=

算术操作符

操作符解释

加号
– 减号
-expr 负号

乘号
/ 除号
~/ 除号，但是返回值为整数
% 取模

赋值操作符 ??=

b ??= value; // 如果 b 是 null，则赋值给 b；
             // 如果不是 null，则 b 的值保持不变

操作符 ?. ??

foo?.bar 如果 foo 为 null 则返回 null，否则返回 bar 成员
String toString() => msg ?? super.toString(); // 如果布尔表达式是测试值是否为 null，考虑使用 ??。

支持 for-in 形式的遍历

####### Catch
对于可以抛出多种类型异常的代码，你可以指定多个捕获语句。每个语句分别对应一个异常类型，如果捕获语句没有指定异常类型，则该可以捕获任何异常类型：

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // A specific exception
  buyMoreLlamas();
} on Exception catch (e) {
  // Anything else that is an exception
  print('Unknown exception: $e');
} catch (e) {
  // No specified type, handles all
  print('Something really unknown: $e');
}

函数 catch() 可以带有一个或者两个参数，第一个参数为抛出的异常对象，第二个为堆栈信息 (一个 StackTrace对象)。

...
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}

构造函数语法糖

class Point {
  num x;
  num y;

  // Syntactic sugar for setting x and y
  // before the constructor body runs.
  Point(this.x, this.y);
}

命名构造函数

class Point {
  num x;
  num y;

// Named constructor
  Point.fromJson(Map json) {
    x = json['x'];
    y = json['y'];
  }
}
注意：构造函数不能继承，所以超类的命名构造函数 也不会被继承。如果你希望 子类也有超类一样的命名构造函数， 你必须在子类中自己实现该构造函数

Initializer list（初始化列表）

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

class Point {
  num x;
  num y;

  Point(this.x, this.y);

  // Initializer list sets instance variables before
  // the constructor body runs.
  Point.fromJson(Map jsonMap)
      : x = jsonMap['x'],
        y = jsonMap['y'] {
    print('In Point.fromJson(): ($x, $y)');
  }
}

初始化列表非常适合用来设置 final 变量的值。下面示例代码中初始化列表设置了三个 final 变量的值。

import 'dart:math';

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

main() {
  var p = new Point(2, 3);
  print(p.distanceFromOrigin);
}

可覆写的操作符

< + | []

/ ^ []=
<= ~/ & ~
= * << ==
– % >>

Implicit interfaces（隐式接口）

每个类都隐式的定义了一个包含所有实例成员的接口，并且这个类实现了这个接口。如果你想创建类 A 来支持类 B 的 api，而不想继承 B 的实现，则类 A 应该实现 B 的接口。

一个类可以通过 implements 关键字来实现一个或者多个接口，并实现每个接口定义的 API。例如：

// A person. The implicit interface contains greet().
class Person {
  // In the interface, but visible only in this library.
  final _name;

  // Not in the interface, since this is a constructor.
  Person(this._name);

  // In the interface.
  String greet(who) => 'Hello, $who. I am $_name.';
}

// An implementation of the Person interface.
class Imposter implements Person {
  // We have to define this, but we don't use it.
  final _name = "";

  String greet(who) => 'Hi $who. Do you know who I am?';
}

greetBob(Person person) => person.greet('bob');

main() {
  print(greetBob(new Person('kathy')));
  print(greetBob(new Imposter()));
}

支持集合泛型判断

var names = new List();
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List);