学习Flutter01---Dart开发语言概览

hello

Flutter使用Dart来编写框架和widget, Dart可以使用DartPad来快速学习, 而无需搭建相关环境, 国内用户可以访问DartPad.cn。DartPad支持dart:* libraries, 但是不支持dart:io以及packages。 如果你需要使用dart:io那么你需要使用Dart SDK, 如果你需要使用packages那么你需要使用平台, 对于开发移动应用, 你可以安装Flutter。

这里学习一下主要的Dart功能, 从变量、操作符、类到资源库。 如果你有其他语言基础, 那么学习Dart会很轻松。

Dart中重要的概念

  • 所有的变量引用的都是对象, 所有的对象都是一个类得实例。甚至数字、函数和null都是对象, 所有的对象都继承于Object类。
  • 虽然Dart是强类型, 但是在声明变量时可不指定类型, 因为Dart可以类型推导。如果想显式地声明一个不确定的类型, 可以使用dynamic或者基类Object。
    • 示例
1
2
3
4
5
6
7
8
void log(Object object) {
  print(object.toString());
}
bool convertToBool(dynamic arg) {
  if (arg is bool) return arg;
  if (arg is String) return arg == 'true';
  throw ArgumentError('Cannot convert $arg to a bool.');
}
  • Dart支持泛型, 例如List<int>(一个整数集合)和List<dynamic>(一个任意对象的集合)。
  • Dart支持顶级函数(例如main()), 同时支持类或对象函数(静态方法和实例方法), 你也可以在函数中嵌套函数。
  • Dart同样支持顶级变量以及在类或对象中创建静态和实例变量。实例变量有时被称为域或属性。
  • 不像Java, Dart没有public, protectd和private限定符, 如果你定义一个以下划线(_)开始的变量, 那么它在库中就是私有的。
  • 标示符由数字、字母、美元符号($)和下划线(_)构成, 但只能以字母或下划线开头。
  • Dart有表达式和语句,表达式有值而语句没有. 例如条件表达式condition ? expr1 : expr2。一个语句通常包含一个或者多个表达式, 但是表达式不能只包含一个语句。
  • Dart工具可以报告两类问题: 警告和错误。警告只表示你的代码可能不工作, 但是不会阻止你的程序执行。错误分为编译时错误和运行时错误, 编译时错误会阻止代码运行, 当代码执行时一个运行时错误会导致抛出一个异常。

Dart中关键字

应该避免使用下面的关键字作为标示符。

abstract else import super
as enum in switch
assert export interface sync
async entends is this
await extension library throw
break external mixin true
case factory new try
catch false null typedef
class final on var
const finally operator void
continue for part while
covariant Function rethrow with
default get return yield
deferred hide set
do if show
dynamic implements static

变量

你可以隐式的声明变量, Dart会自动类型推导, 你也可以显示的声明变量的类型, 此时变量的类型就不能再变化(继承关系的除外)。如果变量的类型需要变化, 那么你可以使用Ojbect或者dynamic来定义。

var name1 = ‘Bob’; //推荐

dynamic name2 = ‘Bob’;

Object name3 = ‘Bob’;

String name4 = “Bob”;

变量的默认值

未初始化的变量默认值是null, 甚至未初始化的数值类型默认值也是null, 因为Dart中所有都是对象。

int lineCount;

assert(lineCount == null);

final 和 const

如果你不希望改变一个变量, 那么使用final和const取代var修饰变量。一个final变量只可以赋值一次, 而const变量是一个编译时常量。

实例变量可以使用final修饰但是不能使用const修饰, final修饰的变量必须在构造函数体前被初始化, 如在声明的时候或作为构造器参数, 或者initializer list中。const修饰的变量只能是具体数值, 不能是函数的返回值。如果const修饰类中的变量, 则必须加上static关键字, 即static const。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import 'dart:math';
class Point {
  final num x;
  final num y;
  // 声明的时候
  final num z = 10;
  final num distanceFromOrigin;
  //initializer list
  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}
main() {
  const double PI = 3.14;
  var p = new Point(2, 3);
  print(p.distanceFromOrigin);
}

内置类型

num

int和double都继承于num, num包含了一些基础的操作, 例如+、-、*和/, 同时你也会发现abs()、floor()、ceil()和round()等函数以及isNaN、isEven和isOdd等属性。

1
2
3
4
5
var x = 1;
var hex = 0xDEADBEEF;
var y = 1.1;
var exponents = 1.42e5;
double z = 1; // 在Dart 2.1及以后
  • int
    • 整数值不超过64 bits, 这取决于平台。
  • double
    • double 是64 bits。
    • 在Dart2.1及以后, 你也可以赋值int给double, 但是在Dart 2.1之前会报错。
  • int、double和String的转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 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');

整型支持传统的位移操作, 比如左移(向左边移位右侧补0)<<、右移(向右移位左侧补0)>>、按位与(都为1结果为1, 否则为0)&、按位或(都为0结果为0, 否则为1)|和按位异或(相同为1, 不相同为0)^

1
2
3
4
5
assert((3 << 1) == 6); // 0011 << 1 == 0110
assert((3 >> 1) == 1); // 0011 >> 1 == 0001
assert((3 | 4) == 7); // 0011 | 0100 == 0111
assert((3 & 4) == 0); // 0011 & 0100 == 0000
assert((3 ^ 5) == 6); // 0011 & 0101 == 0110

String

Dart中string是一个UTF-16编码的字符串, 你可以使用单引号'或者双引号"创建字符串。

1
2
3
4
5
6
7
8
9
var s1 = 'Single quotes work well for string literals.';
var s2 = "Double quotes work just as well.";
var s3 = 'It\'s easy to escape the string delimiter.';
var s4 = "It's even easier to use the other delimiter.";

var s1 = '使用单引号创建字符串字面量。';
var s2 = "双引号也可以用于创建字符串字面量。";
var s3 = '使用单引号创建字符串时可以使用斜杠来转义那些与单引号冲突的字符串：\'。';
var s4 = "而在双引号中则不需要使用转义与单引号冲突的字符串：'";

你可以在字符串中使用${expression}将表达式的值放在字符串中。如果expression是一个变量标识, 那么你可以省略{}, 你可以使用对象的toString()方法获取相应的字符串对象。

1
2
3
4
5
6
7
8
9
var s = 'string interpolation';
/// == 如果两个字符串序列一样,那么会返回true
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!');

你也可以使用相邻字符串即使他们不在一行或者+来连接字符串。

1
2
3
4
5
6
7
8
9
var s1 = 'String '
    'concatenation'
    " works even over line breaks.";
assert(s1 ==
    'String concatenation works even over '
        'line breaks.');

var s2 = 'The + operator ' + 'works, as well.';
assert(s2 == 'The + operator works, as well.');

另外一种创建多行字符串的方法是: 使用三个单引号'或者三个双引号’”‘创建字符串。

1
2
3
4
5
6
7
var s1 = '''
You can create
multi-line strings like this one.
''';

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

你可以在字符串前面加上r创建一个原始字符串。

1
var s = r'In a raw string, not even \n gets special treatment.';

bool

Dart中布尔有true和false, 它们都是编译时常量。

Dart是类型安全的, 这意味着你不能使用if (nonbooleanValue)或者assert (nonbooleanValue)进行判断, 如果需要判断请使用下面的方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Check for an empty string.
var fullName = '';
assert(fullName.isEmpty);

// Check for zero.
var hitPoints = 0;
assert(hitPoints <= 0);

// Check for null.
var unicorn;
assert(unicorn == null);

// Check for NaN.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);

List

大多数语言中叫Collection或者Array, 在Dart中类名是List。

  • 常用属性
    • length: 长度
    • reversed: 反转
    • isEmpty: 是否为空
    • isNotEmpty: 是否为非空
  • 常用方法
    • add(xxx): 添加元素
    • addAll(xxx): 从List里面添加所有元素
    • indexOf(xxx): 查找元素
    • remove(xxx): 删除元素
    • removeAt(xxx): 根据下标删除元素
    • fillRange(xxx): 修改
    • insert(index,value): 指定位置插入
    • insertAll(index,list): 指定位置插入List
    • toList(xxx): 转为List
    • join(xxx): 转换成字符串
    • forEach: 循环
    • map
    • where
    • any
    • every
  • 相关其他类方法
    • split(xxxx): 字符串转成List
1
2
3
4
5
6
7
8
9
10
11
var list = [1, 2, 3];
List<int> list1 = [1, 2, 3];
print(list1.length);
var list2 = <String>[];

var constantList = const [1, 2, 3];
constantList[0] = 5;  // 错误的
constantList = [2, 3]; //正确 [2, 3]
constantList[0] = 5;  // 再次修改正确 [5, 3]

var list2 = List<String>();

Dart 2.3支持 ...、...?操作符, 同时可以使用collection if和collection for构建集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var list1 = [1, 2, 3];
var list2 = [0, ...list1];  //[0, 1, 2, 3]
assert(list2.length == 4);

var list3;
// list为null时不会插入
var list4 = [0, ...?list3]; //[0]
assert(list4.length == 1);

// 判断为true后再添加
var promoActive = true;
var nav = [
  'Home',
  'Furniture',
  'Plants',
  if (promoActive) 'Outlet'
];
// 将listOfInts修改后放入新集合
var listOfInts = [1, 2, 3];
var listOfStrings = [
  '#0',
  for (var i in listOfInts) '#$i'
];

Set

Set是一个无序不重复的集合。和List一样在Dart 2.3版本开始支持...、...?、condiction if和condiction for。

1
2
3
4
5
6
7
8
9
10
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
halogens.add('first');
print(halogens.length);

//创建一个空的set
var names = <String>{};
//或者
Set<String> names = {};
//这创建的是map
var map = {};

Map

通常来说, Map包含key、value对, key是唯一的。往Map中设置key-value时, 存在key则是修改, 不存在key则是添加。当从Map中根据key取value时, 不存在的key会返回null。和List一样在Dart 2.3版本开始支持...、...?、condiction if和condiction for。

  • 常用属性
    • keys: 获取所有key的值
    • values: 获取所有value的值
    • isEmpty: 是否为空
    • isNotEmpty: 是否不为空
  • 常用方法
    • remove(xxx): 删除指定key的数据
    • addAll(xxx): 合并
    • containsValue(xxx): 是否包含值
    • forEach: 循环
    • map
    • where
    • any
    • every
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};
print(gifts.length);

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

Map person = {
  "name":"张三",
  "age":20
};

person.forEach((key,value){            
  print("$key---$value");
});

如果Map中不存在key, 那么取值时会返回null。

runes

Dart中表示UTF-32编码的字符串。
通常的表达方式是\uxxxx, xxxx表示4位16进制数。特殊情下如果多于或少于4位16进制数使用{}括起来。

1
2
var heart = '\u2665';  //♥
var laughing = '\u{1f600}'; //😆

如果你需要读写单个 Unicode 字符，可以使用 characters 包中定义的 characters getter。它将返回 Characters 作为一系列 grapheme clusters 的字符串。下面是使用 characters API 的样例：

1
2
3
4
5
6
import 'package:characters/characters.dart';
...
var hi = 'Hi 🇩🇰';
print(hi);
print('The end of the string: ${hi.substring(hi.length - 1)}');
print('The last character: ${hi.characters.last}\n');

symbols

一个Symbols对象是Dart项目中的一个操作符或者标示符。你可能无需使用symbols, 但是对于通过名称指向标识的APIs却是有价值的。
使用#identifier来使用一个标识的symbols。symbols是编译时常量。

1
2
#radix
#bar

Functions

在Dart中Function也是对象, 这意味着你可以赋值Function给变量或者作为参数传递给其他Function。

1
2
3
4
5
6
7
bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}
//可以省略返回值类型或形参类型, 该函数同样可以正常运行, 建议最好还是指定类型
isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

如果函数只包含一个表达式, 那么可以使用=>简写的语法。
1
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

一个Dart函数可以包括两种类型的参数: 必要参数(required)和可选参数(optional)。必要参数放在前面, 可选参数放在后面。可选命名参数可以使用@required修饰表示它是必须的。

可选参数

可选参数可以是可选命名参数: Optional named parameters或者可选位置参数: Optional positional parameters, 在同一个函数中, 不能同时使用。

命名参数

Dart中定义Funtion时使用{param1, param2, ...}来定义可选命名参数, 同时可以使用@required表示它是必须的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void printValue({Object value1, Object value2}) {
  if (value1 != null) {
      print(value1.toString());
  }

  if (value2 != null) {
      print(value2.toString());
  }
}
void main() {
  var heart = '\u2665'; //♥
  var laughing = '\u{1f600}'; //😆
 
  //调用printValue时未使用@required参数都是可选的
  printValue();
  printValue(value1: heart);
  printValue(value2: laughing);
  printValue(value1: heart, value2: laughing);
}
//使用@required, 那么调用时必须要传入该参数
const Scrollbar({Key key, @required Widget child})

可选位置参数

Dart中定义Funtion时使用[]包裹住参数来定义可选位置参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void main() {
  var heart = '\u2665'; //♥
  var laughing = '\u{1f600}'; //😆
  
  printValue(heart);
  printValue(heart, laughing);
}

void printValue(Object value1, [Object value2]) {
  print(value1.toString());
  if (value2 != null) {
    print(value2.toString());
  }
}

参数默认值

Dart中定义函数使用=来给可选名称变量或者可选位置变量一个默认值, 该默认值必须是编译时常量, 如果没有默认值, 那么默认值是null。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void main() {
  var heart = '\u2665'; //♥
  var laughing = '\u{1f600}'; //😆
  
  printValue(heart);
  printValue(heart, laughing);
}

void printValue(Object value1, [Object value2 = "2"]) {
  print(value1.toString());
  if (value2 != null) {
    print(value2.toString());
  }
}

main()主函数

每个App必须要有一个主函数main(), 返回值为void, 它有一个可选的List<String>类型的参数arguments。

1
2
3
4
5
6
void main() {
  //code
}
void main(List<String> arguments) {
  //code
}

函数作为参数传递

你可以把函数作为参数传递给另外一个函数。

1
2
3
4
5
6
void printElement(int element) {
  print(element);
}

var list = [1, 2, 3];
list.forEach(printElement);

函数定义为变量

Dart执行将函数定义为一个变量。

1
2
3
4
5
void main() {
  var func = (int element) => print(element);
  
  func(10);
}

匿名函数

匿名函数就是没有方法名的函数。
定义语法:

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

1
2
3
4
var list = ['apples', 'bananas', 'oranges'];
list.forEach((item) {
  print('${list.indexOf(item)}: $item');
});

作用域

Dart中定义的非静态变量的作用域一般是它所在的{}内。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideFunction = true;

    void nestedFunction() {
      var insideNestedFunction = true;

      assert(topLevel);
      assert(insideMain);
      assert(insideFunction);
      assert(insideNestedFunction);
    }
  }
}

闭包

闭包是一个函数对象，它可以访问范围内的变量，甚至可以使用函数范围外的变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Function makeAdder(num addBy) {
  return (num i) => addBy + i;
}

void main() {
  // Create a function that adds 2.
  var add2 = makeAdder(2);

  // Create a function that adds 4.
  var add4 = makeAdder(4);

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

Dart中全局函数、静态方法以及实例方法

函数的相等问题。

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
void foo() {} // A top-level function

class A {
  static void bar() {} // A static method
  void baz() {} // An instance method
}

void main() {
  var x;

  // Comparing top-level functions.
  x = foo;
  assert(foo == x); //true
 
  // Comparing static methods.
  x = A.bar;
  assert(A.bar == x); //true

  // Comparing instance methods.
  var v = A(); // Instance #1 of A
  var w = A(); // Instance #2 of A
  var y = w;
  x = w.baz;

  // These closures refer to the same instance (#2),
  // so they're equal.
  assert(y.baz == x); //true

  // These closures refer to different instances,
  // so they're unequal.
  assert(v.baz != w.baz);
}

函数的返回值

所有的函数都有返回值, 没有显示返回语句的函数最后一行默认执行return null;。

1
2
3
foo() {}

assert(foo() == null);

Operators

算术运算符

操作符 描述
+ 加
- 减
-expr 表示负数
* 乘
/ 除
~/ 除, 返回整数
% 求余
++var 自增, 表达式取var+1的值
var++ 自增, 表达式取var的值
--var 自减, 表达式取var-1的值
var-- 自减, 表达式取var的值

关系运算符

操作符 描述
== 等于, 特殊情况下两个对象完全相同可以使用identical()方法, 如果==两边都为null返回true, 如果两个有一个为null, 另一个不为null返回false。同样的你也可以重新==方法。
!= 不等于
> 大于
>= 大于等于
< 小于
<= 小于等于

类型操作符

操作符 描述
as 1、强制类型转换(可能会抛出异常) 2、库别名
is 判断对象是某种类型
is! 判断对象不是某种类型 
1
2
3
4
5
6
if (emp is Person) {
  // Type check
  emp.firstName = 'Bob';
}
//如果emp是null或者不是Person类型那么会抛出异常。
(emp as Person).firstName = 'Bob';

赋值操作符

描述 操作符
= 赋值
??= a ??= b, 如果a为null, 赋值b给a, 否则不赋值
–= a -= b等价于 a = a - b
/= a /= b等价于 a = a / b
%= a %= b等价于 a = a % b
>>= a >>= b等价于 a = a >> b
^= a ^= b等价于 a = a ^ b
&= a &= b等价于 a = a & b
|= a |= b等价于 a = a | b
+= a += b等价于 a = a + b
*= a *= b等价于 a = a * b
~/= a ~/= b等价于 a = a ~/ b

逻辑操作符

描述 操作符
!expr 逻辑非
|| 逻辑或
&& 逻辑与

位移操作符

描述 操作符
& 按位与
^ 按位异或
| 按位或
~expr 补位
<< 左位移
>> 右位移

条件操作符

描述 操作符
condition ? expr1 : expr2 条件为true取值expr1, 否则取值expr2
expr1 ?? expr2 如果expr1不为null返回expr1, 否则返回expr2 
1
2
3
4
5
6
7
8
9
10
11
12
String playerName(String name) => name ?? 'Guest';
// Slightly longer version uses ?: operator.
String playerName(String name) => name != null ? name : 'Guest';

// Very long version uses if-else statement.
String playerName(String name) {
  if (name != null) {
    return name;
  } else {
    return 'Guest';
  }
}

级联运算符 (..)

Cascade(..)允许你多次操作同一个对象, 你可以调用函数, 也可以访问属性。值得注意的是, 如果一个方法返回值为void的方法则不能使用级联运算符。

1
2
3
4
querySelector('#confirm') // Get an object.
  ..text = 'Confirm' // Use its members.
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'));

其他操作符

描述 操作符
() 函数应用, 调用一个函数
[index] 从List中根据下标取值
[key] 从Map中根据key取值
. 从对象中取属性值
?. 从对象中取属性值, 如果对象为null那么取的值也为null

流程控制语句

if-else 

1
2
3
4
5
6
7
if (isRaining()) {
  you.bringRainCoat();
} else if (isSnowing()) {
  you.wearJacket();
} else {
  car.putTopDown();
}

for 

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

捕获变量

Dart中for循环中的闭包(匿名函数)可以捕捉下标。

1
2
3
4
5
6
7
8
9
10
void main() {
  var callbacks = [];
  for (var i = 0; i < 20; i++) {
    callbacks.add(() => print(i));
  }
  
  print(callbacks);
  callbacks.forEach((c) => c());
  callbacks[0]();
}

for-in

Dart同样支持for-in: 

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

while和 do-while

注意不要忘了do-while后的分号;。

1
2
3
4
5
6
7
while (!isDone()) {
  doSomething();
}

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

break和continue 

1
2
3
4
5
6
7
8
9
10
11
12
while (true) {
  if (shutDownRequested()) break;
  processIncomingRequests();
}

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

Switch 和 case

Switch 语句在 Dart 中使用 ==来比较整数、字符串或编译时常量，比较的两个对象必须是同一个类型且不能是子类并且没有重写 == 操作符。

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
38
39
40
41
42
43
44
45
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();
}

//空case 继续执行
var command = 'CLOSED';
switch (command) {
  case 'CLOSED': // Empty case falls through.
  case 'NOW_CLOSED':
    // Runs for both CLOSED and NOW_CLOSED.
    executeNowClosed();
    break;
}

//非空case 使用continue和label继续执行
var command = 'CLOSED';
switch (command) {
  case 'CLOSED':
    executeClosed();
    continue nowClosed;
  // Continues executing at the nowClosed label.

  nowClosed:
  case 'NOW_CLOSED':
    // Runs for both CLOSED and NOW_CLOSED.
    executeNowClosed();
    break;
}

断言Assert

在开发中你可以使用assert(condition, optionalMessage);, 当condition为false时, 会打断语句的执行。Debug模式会执行, release生产环境不会执行。

1
2
3
4
assert(urlString.startsWith('https'));

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

异常Exceptions

Dart可以thorw和catch异常, 异常如果没有catch, 那么有可能会导致应用程序终止。
Dart中所有的异常都是unchecked exceptions, 方法不一定会声明其所抛出的异常并且你也不会被要求捕获任何异常。

throw

Dart中你可以把任何非null对象作为异常抛出, 注意: 生产环境一般抛出Error或Exception类型的异常。

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

throw 'Out of llamas!';

Catch

捕捉或捕获异常, 阻止异常传播(当然你也可以重新抛出异常)。
当你需要知道异常类型时你可以使用on, 当你需要使用异常对象时, 你可以使用catch。

1
2
3
4
5
6
7
8
9
10
11
12
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的参数

catch可以有一个或者两个参数, 第一个参数是异常对象, 第二个参数是堆栈信息。

1
2
3
4
5
6
7
8
try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}

rethrow

你也可以使用rethrow重新抛出该异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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中语句。

1
2
3
4
5
6
7
try {
  breedMoreLlamas();
} catch (e) {
  print('Error: $e'); // Handle the exception first.
} finally {
  cleanLlamaStalls(); // Then clean up.
}

类

Dart中所有对象都一个类的实例, 他们都继承于Object类。Object类是所有类(除了Object类本身)的超类。

使用对象中属性、方法

使用.或者?.来访问对象中的实例属性或者方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
var p = Point(2, 2);

// Set the value of the instance variable y.
p.y = 3;

// Get the value of y.
assert(p.y == 3);

// Invoke distanceTo() on p.
num distance = p.distanceTo(Point(4, 4));

// If p is non-null, set its y value to 4.
p?.y = 4;

使用构造函数

从Dart 2开始, new是可选的。

1
2
3
4
5
var p1 = Point(2, 2);
var p2 = Point.fromJson({'x': 1, 'y': 2});

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

一些类提供常量构造函数, 在构造函数签使用const关键字来创建编译时常量。

1
2
3
4
var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b)); // They are the same instance!

对象的类型

获取一个对象的运行时类型使用对象的runtimeType属性。

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

实例变量

所有未初始化的实例变量都是null。

1
2
3
4
5
class Point {
  num x; // Declare instance variable x, initially null.
  num y; // Declare y, initially null.
  num z = 0; // Declare z, initially 0.
}

所有实例变量隐式生成getter方法, 一个非final的实例变量默认还会隐式生成setter方法。

构造函数

创建一个类名相同的函数(额外的标识符是可选的), 声明一个构造函数。
this关键字表示当前对象。

1
2
3
4
5
6
7
8
9
class Point {
  num x, y;

  Point(num x, num y) {
    // There's a better way to do this, stay tuned.
    this.x = x;
    this.y = y;
  }
}

我们可以使用语法糖来进行快速创建构造函数。

1
2
3
4
5
6
class Point {
  num x, y;

  // 在构造函数体执行前用于设置 x 和 y 的语法糖.
  Point(this.x, this.y);
}

默认构造函数

如果你没有声明构造函数，那么 Dart 会自动生成一个无参数的构造函数并且该构造函数会调用其父类的无参数构造方法。如果存在有参数的构造函数, 那么就不会有默认的无参构造函数。

构造函数不能继承

构造函数是不能继承的, 这意味着假如在父类中定义了一个命名构造函数, 如果你想在子类中同样有相同名称的命名构造函数, 那么你实现该命名构造函数。

命名构造函数 

1
2
3
4
5
6
7
8
9
10
11
class Point {
  num x, y;

  Point(this.x, this.y);

  // Named constructor
  Point.origin() {
    x = 0;
    y = 0;
  }
}

子类定义构造函数时默认先调用父类的构造函数, 当父类没有无参的构造函数时, 你必须手动调用父类有参构造函数之一。
你需要使用冒号(:)在构造函数体前面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Person {
  String firstName;

  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');
  }
}

初始化器列表

除了调用父类构造函数, 你还有使用初始化器列表初始化变量在构造函数体执行之前。

1
2
3
4
5
6
7
8
9
10
class Point {
  num x, y;
  // Initializer list sets instance variables before
  // the constructor body runs.
  Point.fromJson(Map<String, num> json)
      : x = json['x'],
        y = json['y'] {
    print('In Point.fromJson(): ($x, $y)');
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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);
}

重定向构造函数

当一个类中有多个构造函数, 其他构造函数可以调用当前类的其他构造函数。

1
2
3
4
5
6
7
8
9
class Point {
  num x, y;

  // The main constructor for this class.
  Point(this.x, this.y);

  // Delegates to the main constructor.
  Point.alongXAxis(num x) : this(x, 0);
}

常量构造函数

如果你生成的对象永远不会变化, 你可以使这些对象编译时常量。你只需定义一个const构造函数, 然后设置所有实例变量final。

1
2
3
4
5
6
7
8
class ImmutablePoint {
  static final ImmutablePoint origin =
      const ImmutablePoint(0, 0);

  final num x, y;

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

工厂构造函数

使用factory关键字定义工厂构造函数时, 并不需要一直创建新的实例对象。

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
class Logger {
  final String name;
  bool mute = false;

  // _cache is library-private, thanks to
  // the _ in front of its name.
  static final Map<String, Logger> _cache =
      <String, Logger>{};

  factory Logger(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final logger = Logger._internal(name);
      _cache[name] = logger;
      return logger;
    }
  }

  Logger._internal(this.name);

  void log(String msg) {
    if (!mute) print(msg);
  }
}

方法

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

实例方法

实例方法可以访问实例变量和实例方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
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);
  }
}

Setter和Getter方法

Setter和Getter方法, 每个实例变量都会有一个隐式Getter方法, 根据实际情况生成隐式Setter方法, 当然也可以使用关键字set和get自己实现Getter和Setter方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Rectangle {
  num left, top, width, height;

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

  // Define two calculated properties: right and 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、Setter都可以是抽象的, 抽象方法只能存在于抽象类中。抽象方法一般交给子类实现。

1
2
3
4
5
6
7
8
9
10
11
abstract class Doer {
  // Define instance variables and methods...

  void doSomething(); // Define an abstract method.
}

class EffectiveDoer extends Doer {
  void doSomething() {
    // Provide an implementation, so the method is not abstract here...
  }
}

抽象类

使用关键字abstract定义抽象类, 它一般用于定义接口。

1
2
3
4
5
abstract class AbstractContainer {
  // Define constructors, fields, methods...

  void updateChildren(); // Abstract method.
}

隐式接口

每一个类都隐式地定义了一个接口并实现了该接口，这个接口包含所有这个类的实例成员以及这个类所实现的其它接口。如果想要创建一个 A 类支持调用 B 类的 API 且不想继承 B 类，则可以实现 B 类的接口。

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

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
// A person. The implicit interface contains greet().
// Person 类的隐式接口中包含 greet() 方法。
class Person {
  // _name 变量同样包含在接口中，但它只是库内可见的。
  final _name;

  // 构造函数不在接口中。
  Person(this._name);

  // greet() 方法在接口中。
  String greet(String who) => '你好，$who。我是$_name。';
}

// Person 接口的一个实现。
class Impostor implements Person {
  get _name => '';

  String greet(String who) => '你好$who。你知道我是谁吗？';
}

String greetBob(Person person) => person.greet('小芳');

void main() {
  print(greetBob(Person('小芸')));
  print(greetBob(Impostor()));
}

实现多个接口时:

1
class Point implements Comparable, Location {...}

继承类

使用关键字extends来创建子类, super指向它的父类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
  // ···
}

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

重写方法

使用@override注解重写方法

1
2
3
4
5
class SmartTelevision extends Television {
  @override
  void turnOn() {...}
  // ···
}

重写操作符

重写operators, 下面的操作符都是可以重写的

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

!=是不能重写的, 它只是相当于!(expr1 ==expr2)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Vector {
  final int x, y;

  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. For details, see note below.
  // ···
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

如果你重写了==操作符, 你同时需要重写hashCode方法: 

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
class Person {
  final String firstName, lastName;

  Person(this.firstName, this.lastName);

  // Override hashCode using strategy from Effective Java,
  // Chapter 11.
  @override
  int get hashCode {
    int result = 17;
    result = 37 * result + firstName.hashCode;
    result = 37 * result + lastName.hashCode;
    return result;
  }

  // You should generally implement operator == if you
  // override hashCode.
  @override
  bool operator ==(dynamic other) {
    if (other is! Person) return false;
    Person person = other;
    return (person.firstName == firstName &&
        person.lastName == lastName);
  }
}

void main() {
  var p1 = Person('Bob', 'Smith');
  var p2 = Person('Bob', 'Smith');
  var p3 = 'not a person';
  assert(p1.hashCode == p2.hashCode);
  assert(p1 == p2);
  assert(p1 != p3);
}

noSuchMethod()

当你调用了一个对象的不存在的实例变量或者方法时, 重写noSuchMethod即可检测到。

1
2
3
4
5
6
7
8
9
class A {
  // Unless you override noSuchMethod, using a
  // non-existent member results in a NoSuchMethodError.
  @override
  void noSuchMethod(Invocation invocation) {
    print('You tried to use a non-existent member: ' +
        '${invocation.memberName}');
  }
}

一般情况下, 你无法调用未实现的类, 除非下面几种情况:
1、调用者静态类型是dynamic
2、调用者类型是静态的, 但是定义了未实现的方法(如抽象类), 同时实现了noSuchMethod()方法, 并且和Object中的不一样。

Extension

使用extension关键字可以定义方法、getter、setter和operator等。

1
2
3
4
5
6
7
8
extension NumberParsing on String {
  int parseInt() {
    return int.parse(this);
  }
  double parseDouble() {
    return double.parse(this);
  }
}

枚举类型

使用enum关键字定义枚举, 枚举中的值有一个index的getter属性, 该属性返回该枚举值的从0开始的位置。

1
2
3
4
5
enum Color { red, green, blue }

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

获取所有枚举值

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

在switch中可以使用枚举值:

1
2
3
4
5
6
7
8
9
10
11
12
var aColor = Color.blue;

switch (aColor) {
  case Color.red:
    print('Red as roses!');
    break;
  case Color.green:
    print('Green as grass!');
    break;
  default: // Without this, you see a WARNING.
    print(aColor); // 'Color.blue'
}

混入(mixin)

它是一种可以在多个类中重复使用另外同一个类代码的方式。使用关键字with跟随一个或多个mixin名称, 使用mixin定义mixins, 并且可以使用关键字on来指定哪些类可以使用该Mixin类。

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
mixin Musical on Musician {
  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');
    }
  }
}

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

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

静态变量和静态方法

使用static来定义静态变量和静态方法, 静态变量只有在使用的时候才会初始化一次, 它是编译时常量。

1
2
3
4
5
6
7
8
9
10
11
class Queue {
  static const initialCapacity = 16;
  
  static void printCapacity() {
  	// ···
  }
}

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

泛型

如果你看的API文档基本类型List,你会发现实际上是Lit类型。<…>符号标志着作为一个通用的列表(或参数化), 一个有正式类型的参数。按照惯例,大多数类型变量单字母的名字,如E T, S、K、V。
当你使用了泛型List, 你就不能添加其他类型的对象到List中。

1
2
3
var names = List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
names.add(42); // Error

使用泛型可以减少重复代码

1
2
3
4
abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}

集合字面量

List、Set使用<type>, Map使用<Type, Type>字面量定义泛型集合。

1
2
3
4
5
6
7
var names = <String>['Seth', 'Kathy', 'Lars'];
var uniqueNames = <String>{'Seth', 'Kathy', 'Lars'};
var pages = <String, String>{
  'index.html': 'Homepage',
  'robots.txt': 'Hints for web robots',
  'humans.txt': 'We are people, not machines'
};

使用构造函数创建泛型集合 

1
2
3
var list = List<String>();
var set = Set<String>();
var map = Map<String, String>();

泛型集合的类型

Dart中泛型的类型是具体化的, 这意味着运行时你可以判断该类型, 在Java中你无法判断。

1
2
3
var names = List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List<String>); // true

限制参数类型

当我们使用泛型时, 希望限定某些类型可以使用extends关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Foo<T extends SomeBaseClass> {
  // Implementation goes here...
  String toString() => "Instance of 'Foo<$T>'";
}

class Extender extends SomeBaseClass {...}

void main() {
	var someBaseClassFoo = Foo<SomeBaseClass>();
	var extenderFoo = Foo<Extender>();
	var foo = Foo();
	
	var fooObject = Foo<Object>(); // 错误的写法
}

泛型方法

Dart同样支持泛型方法或者泛型函数。

1
2
3
4
5
6
T first<T>(List<T> ts) {
  // Do some initial work or error checking, then...
  T tmp = ts[0];
  // Do some additional checking or processing...
  return tmp;
}

资源库和可见性

资源库Library和import可以方便的构建一个模块化和可共享的代码库。它不仅仅提供API, 以下划线(_)开始的标示符都只在该资源库中可见。每个Dart应用都是一个资源库。

内置库导入 

1
import 'dart:html';

其他库导入 

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

指定库前缀

如果你导入了两个包含了相同标识的库, 那么你可以使用库前缀来区别他们。

1
2
3
4
5
6
7
8
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// Uses Element from lib1.
Element element1 = Element();

// Uses Element from lib2.
lib2.Element element2 = lib2.Element();

导入库的一部分 

1
2
3
4
5
// Import only foo.
import 'package:lib1/lib1.dart' show foo;

// Import all names EXCEPT foo.
import 'package:lib2/lib2.dart' hide foo;

延迟加载库

延迟加载库运行应用程序在需要的时候加载库, 以下情况你可以使用延迟加载:
1、减少应用程序初始启动时间
2、例如执行A/B测试, 测试各种算法的不同实现
3、加载很少使用的功能, 例如可选的屏幕和对话框
目前只有dart2js支持延迟加载, Flutter暂不支持.

1
2
3
4
5
6
7
8
//首先使用`deferred as`导入库
import 'package:greetings/hello.dart' deferred as hello;

Future greet() async {
  //然后调用oadLibrary()方法, 该方法你多次调用, 但是只会加载库一次
  await hello.loadLibrary();
  hello.printGreeting();
}

异步函数

关键字async和await可以用于异步编程, 使用await的方法或者函数必须是async。尽管异步函数可以处理耗时操作，但是它并不会等待这些耗时操作完成，异步函数执行时会在其遇到第一个 await 表达式的时候返回一个 Future 对象，然后等待 await 表达式执行完毕后继续执行。

1
2
3
4
Future checkVersion() async {
  var version = await lookUpVersion();
  // Do something with version
}

异常

使用try-catch-finally处理异常和清理相关资源。

1
2
3
4
5
6
7
8
Future checkVersion() async {
  try {
  	 var entrypoint = await findEntrypoint();
	 var exitCode = await runExecutable(entrypoint, args);
  } catch (e) {
    // React to inability to look up the version
  }
}

await返回值

await expr返回值都是Future类型的, 如果不是该类型, 系统会自动包装成Future类型。

声明异步函数

在函数声明中使用async即可声明该函数为异步函数, 该函数返回值不用返回Future对象, Dart会自动包装。如果没有没有返回值, 确保返回Furhure<Void>类型。

1
2
3
4
5
6
7
8
//同步函数
String lookUpVersion() => '1.0.0';

//异步函数
Future<String> lookUpVersion() async => '1.0.0';
Future<String> lookUpVersion() async { 
	return '1.0.0';
}

可调用类

实现call()函数, 允许对象的实例像函数一样调用, 参数随意。

1
2
3
4
5
6
7
8
9
class WannabeFunction {
  call(String a, String b) => '$a $b!';
}

main() {
  var wf = new WannabeFunction();
  var out = wf("Hi","there");
  print('$out');
}

类型定义

使用typedef给Function命名, 这样可以保留相关的类型信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef Compare = int Function(Object a, Object b);

class SortedCollection {
  Compare compare;

  SortedCollection(this.compare);
}

// 简单的不完整实现。
int sort(Object a, Object b) => 0;

void main() {
  SortedCollection coll = SortedCollection(sort);
  assert(coll.compare is Function);
  assert(coll.compare is Compare);
}

使用typedef时可以使用泛型:

1
2
3
4
5
6
7
typedef Compare<T> = int Function(T a, T b);

int sort(int a, int b) => a - b;

void main() {
  assert(sort is Compare<int>); // True!
}

元数据

元数据注解以 @ 开头，其后紧跟一个编译时常量（比如 deprecated）或者调用一个常量构造函数。Dart 中有两个注解是所有代码都可以使用的：@deprecated 和 @override。你也可以自定义注解: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
library todo;

class Todo {
  final String who;
  final String what;

  const Todo(this.who, this.what);
}

import 'todo.dart';

@Todo('seth', 'make this do something')
void doSomething() {
  print('do something');
}

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

iOS、Objective-C、Swift、Java、Flutter