Flutter學習指南：熟悉Dart語言

玉剛說發表於2018-10-22

本文是 Flutter 學習指南的第4篇，假定讀者有一定的程式設計經驗。通過快速瀏覽 Dart 的一些基礎特性，讓讀者具備使用它進行開發的基本能力。

變數

基本型別

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 的型別推斷功能：

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

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

// 使用建構函式建立物件
// 跟 var list = new List<int>(); 一樣
var list = List<int>();
list.add(1);
list.add(2);

// 通過字面量建立物件，list 的泛型引數可以從變數定義推斷出來。
// 推薦使用字面量方式建立物件
var list2 = [1, 2];
// 沒有元素，顯式指定泛型引數為 int
var list3 = <int>[];
list3.add(1);
list3.add(2);

var list4 = const[1, 2];
// list4 指向的是一個常量，我們不能給它新增元素（不能修改它）
list4.add(3);       // error
// list4 本身不是一個常量，所以它可以指向另一個物件
list4 = [4, 5];     // it's fine

const list5 = [1, 2];
// 相當於 const list5 = const[1, 2];
list5.add(3);       // error

// Dart 同樣提供了 for-in 迴圈。
// 因為語音設計時就考慮到了這個需求，in 在 Dart 裡是一個關鍵字
var list6 = [1, 3, 5, 7];
for (var e in list6) {
  print(e);
}
複製程式碼

在 Dart 2 裡，建立物件時可以省略 new 關鍵字，也推薦省略 new。

Set

var set = Set<String>();
set.add('foo');
set.add('bar');
assert(set.contains('foo'));
複製程式碼

我們只能通過 Set 的建構函式建立例項。

Map

var map = Map<String, int>();
// 新增
map['foo'] = 1;
map['bar'] = 3;
// 修改
map['foo'] = 4;
// 對應的 key 不存在時，返回 null
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。

Object o = 'string';
o = 42;
o.toString();   // 我們只能呼叫 Object 支援的方法

dynamic obj = 'string';
obj['foo'] = 4;  // 可以編譯通過，但在執行時會丟擲 NoSuchMethodError
複製程式碼

Object 和 dynamic 都使得我們可以接收任意型別的引數，但兩者的區別非常的大。

使用 Object 時，我們只是在說接受任意型別，我們需要的是一個 Object。型別系統會保證其型別安全。

使用 dynamic 則是告訴編譯器，我們知道自己在做什麼，不用做型別檢測。當我們呼叫一個不存在的方法時，會執行 noSuchMethod() 方法，預設情況下（在 Object 裡實現）它會丟擲 NoSuchMethodError。

為了在執行時檢測進行型別檢測，Dart 提供了一個關鍵字 is：

dynamic obj = <String, int>{};
if (obj is Map<String, int>) {
  // 進過型別判斷後，Dart 知道 obj 是一個 Map<String, int>，
  // 所以這裡不用強制轉換 obj 的型別，即使我們宣告 obj 為 Object。
  obj['foo'] = 42;
}

// 雖然 Dart 也提供了 as 讓我們進行型別的強制轉換，但為了進來更安全
// 的轉換，更推薦使用 is
var map = obj as Map<String, int>;
複製程式碼

語句

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 裡的一樣：

int foo(int x) {
  return 0;
}
複製程式碼

Dart 也支援可選引數：

void main() {
  print(foo(2));
  print(foo(1, 2));
}

int foo(int x, [int y]) {
  // 是的，int 也可以是 null
  if (y != null) {
    return x + y;
  }
  return x;
}

// 結果：
// 2
// 3
複製程式碼

預設引數也是支援的：

int foo(int x, [int y = 0]) {
  return x + y;
}
複製程式碼

還能用具名引數（named parameters）：

void main() {
  print(foo(x: 1, y: 2));
  // 具名引數的順序可以是任意的
  print(foo(y: 3, x: 4));
  // 所有的具名引數都是可選的，這個呼叫是合法的，但它會導致 foo() 在執行時拋異常
  print(foo());
}

int foo({int x, int y}) {
  return x + y;
}
複製程式碼

具名引數也可以有預設引數：

void main() {
  print(foo(x: 1, y: 2));
  print(foo());
}

int foo({int x = 0, int y = 0}) {
  return x + y;
}
複製程式碼

如果想告訴使用者某個具名引數是必須的，可以使用註解 @required：

int foo({@required int x, @required int y}) {
  return x + y;
}
複製程式碼

@required 是 meta 包裡提供的 API，更多的資訊讀者可以檢視 pub.dartlang.org/packages/me…。

函式還可以在函式的內部定義：

// typedef 在 Dart 裡面用於定義函式型別的別名
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));
}

// 結果：
// 5
複製程式碼

像上面這樣簡單的函式，我們還可以使用 lambda：

typedef Adder = int Function(int, int);

Adder makeAdder(int extra) {
  return (int x, int y) {
    return x + y + extra;
  };
  // 如果只有一個語句，我們可以使用下面這種更為簡潔的形式
  // return (int x, int y) => x + y + extra;
}

void main() {
  var adder = makeAdder(2);
  print(adder(1, 2));
}
複製程式碼

Dart 裡面不僅變數支援型別推斷，lambda 的引數也支援自動推斷。上面的程式碼還可以進一步簡化為：

typedef Adder = int Function(int, int);

Adder makeAdder(int extra) {
  // 我們要返回的型別是 Adder，所以 Dart 知道 x, y 都是 int
  return (x, y) => x + y + extra;
}

void main() {
  var adder = makeAdder(2);
  print(adder(1, 2));
}
複製程式碼

美中不足的是，Dart 不支援函式的過載。

異常

丟擲異常：

throw Exception('put your error message here');
複製程式碼

捕獲異常：

try {
  // ...
// 捕獲特定型別的異常
} on FormatException catch (e) {
  // ...
// 捕獲特定型別的異常，但不需要這個物件
} on Exception {
  // ..
// 捕獲所有異常
} catch (e) {
  // ...
} finally {
  // ...
}
複製程式碼

跟 Java 不同的是，Dart 可以丟擲任意型別的物件：

throw 42;
複製程式碼

類

定義一個類：

class Point2D {
  static const someConst = 2;

  int x;
  // 成員變數也可以是 final 的
  final int y;

  Point2D(int x, int y) {
    this.x = x;
    this.y = y;
  }
}
複製程式碼

由於這種初始化方式很常見，Dart 提供了更簡潔的方式：

class point2d {
  int x;
  int y;

  point2d(this.x, this.y);
}
複製程式碼

此外，還可以使用初始化列表（initializer list）對物件進行初始化：

class Point2D {
  int x;
  int y;

  // 由於是在 initializer list 中，Dart 知道第一個 x 是 this.x，
  // 第二個 x 是建構函式的引數
  Point2D(int x, int y) : x = x, y = y {
    // ...
  }
}
複製程式碼

initializer list 會在建構函式的函式體執行前執行。

Dart 具有垃圾收集功能，物件的使用跟 Java 裡幾乎是一樣的：

main() {
  var point = Point2D(1, 2);
  point.x = 4;
  print(point);
}

class Point2D {
  int x;
  int y;
  Point2D(this.x, this.y);

  // 所有的類都繼承自 Object，toString() 是 Object 中的方法
  @override
  String toString() {
    // 在字串的內部可以通過 ${expression} 的方式插入值，如果
    // expression 是一個變數，可以省略花括號
    return "Point2D{x=$x, y=$y}";
  }
}

// 結果：
// Point2D{x=4, y=2}
複製程式碼

Dart 使用 package 的概念來管理原始碼和可見性。它沒有 public、private 之類的訪問許可權控制符，預設情況下，所有的符號都是公開的。如果我們不想某個變數對包的外部可見，可以使用下劃線開頭來給變數命名。

class _Foo {
  // ...
}

class Bar {
  int _x;
}
複製程式碼

下面我們使用 Dart 的訪問控制，實現一個帶偏移量的 Point：

class OffsetPoint {
  int _x;
  int _y;
  int offset;

  OffsetPoint(int x, int y, int offset)
      : _x = x, _y = y, offset = offset {}

  // 定義一個 getter
  int get x => _x + offset;
  // getter 不能有引數，連括號都省掉了
  int get y {
    return _y + offset;
  }
  // 定義 setter
  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);
  // 使用 getter/setter 時，就像它是一個普通的成員變數
  print(point.x)
  print(point);
  point.x = 4;
  print(point);
}

// 結果：
// 11
// OffsetPoint{x=11, y=12}
// OffsetPoint{x=14, y=12}
複製程式碼

在 Dart 裡繼承物件也很簡單：

class Point2D {
  int x;
  int y;
  Point2D(this.x, this.y);
}

class Point3D extends Point2D {
  int z;
  // 父類的建構函式只能在 initializer list 裡呼叫
  Point3D(int x, int y, int z): z = z, super(x, y) {
  }
}
複製程式碼

但是物件構造時它跟 Java、C++ 都不太一樣：

先執行子類 initializer list，但只初始化自己的成員變數
初始化父類的成員變數
執行父類建構函式的函式體
執行之類建構函式的函式體

基於這個初始化順序，推薦是把 super() 放在 initializer list 的最後。此外，在 initializer list 裡不能訪問 this（也就是說，只能呼叫靜態方法）。

雖然 Dart 是單繼承的，但它也提供了一定程度的多重繼承支援：

abstract class Bark {
  void bark() {
    print('woof');
  }
}

class Point3D extends Point2D with Bark {
  int z;
  // 父類的建構函式只能在 initializer list 裡呼叫
  Point3D(int x, int y, int z): z = z, super(x, y) {
  }
}

// 沒有其他類需要繼承，所以直接 extends Bark 就可以了
class Foo extends Bark {}

void main() {
  var p = Point3D(1, 2, 3);
  p.bark();
}
複製程式碼

Dart 把支援多重繼承的類叫做 mixin。更詳細的介紹，讀者可以參考www.dartlang.org/articles/la…。

泛型

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>);
  // is! 也是 Dart 的運算子，下面的語句跟 !(p is Pair<int, int>) 是一樣的，
  // 但 is! 讀起來跟像英語
  print(p is! Pair<int, int>);
  print(p is Pair);
}

// 結果：
// true
// true
// true
複製程式碼

跟 Java 不同，Dart 的泛型引數型別在執行時是保留的。

Future

Dart 是單執行緒的，主執行緒由一個事件迴圈來執行（類似 Android 的主執行緒）。對於非同步程式碼，我們通過 Future 來獲取結果：

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 函式，用來簡化這種程式設計正規化。下面這段程式碼的效果跟上面是一樣的：

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);
  }
}
複製程式碼

但是要注意，上面兩段程式碼並不是完全一樣的：

// import 語句用於匯入一個包
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: after file.exists() returned
// foo: file not exists
// foo: after file.exists() returned
// bar: file not exists
複製程式碼

這裡的關鍵在於，bar 函式裡面，file.exists() 執行完後，會馬上執行下面的語句；而 foo 則會等待結果，然後才繼續執行。關於 Future 的更多的細節，強烈建議讀者閱讀webdev.dartlang.org/articles/pe…。

最後需要說明的是，Dart 的生成器、Stream 在這裡我們並沒有介紹，讀者可以參考 www.dartlang.org/guides/lang…。此外，Dart 官網還有許多資源等待讀者去發掘。

程式設計·思維·職場
歡迎大家掃碼關注

Flutter Dart語法學習
2020-07-22
FlutterDart
Flutter學習筆記（2）--Dart語言簡介
2019-06-29
Flutter筆記Dart
Flutter學習之Dart語法(二)
2020-03-07
FlutterDart
Flutter學習之Dart語法(一)
2020-02-29
FlutterDart
Flutter學習之Dart語法(三)
2020-03-29
FlutterDart
Flutter學習之Dart語法特性
2019-03-13
FlutterDart
flutter【3】dart語言--方法
2019-08-09
FlutterDart
Dart語言學習筆記(一) —— Dart簡介
2018-08-24
Dart筆記
Dart程式語言入門學習
2019-05-19
Dart
Flutter系列之Dart語言概述
2019-08-25
FlutterDart
flutter【1】-dart語言--基本知識
2019-08-09
FlutterDart
flutter【4】dart語言--操作符
2019-08-09
FlutterDart
Flutter教程(二) 瞭解Dart語言
2018-05-04
FlutterDart
【Flutter 1-7】Flutter教程Dart語言——變數
2020-11-16
FlutterDart變數
Flutter:Dart 學習筆記
2020-03-18
FlutterDart筆記
Flutter開發之Dart語言基礎
2019-07-25
FlutterDart
Flutter學習記錄（一）Dart學習
2019-11-28
FlutterDart
Flutter 學習(三) dart基礎
2019-10-30
FlutterDart
Go 語言學習路線指南
2018-09-27
Go
以dart語言為例說說如何學習一門新的語言
2018-05-18
Dart
Flutter小白教程系列（三） --- Dart語言快速入門
2020-01-07
FlutterDart
flutter【2】dart語言--內建資料型別
2019-08-09
FlutterDart資料型別
Flutter - Dart特性語法
2021-03-21
FlutterDart
Flutter學習筆記（4）--Dart函式
2019-07-10
Flutter筆記Dart函式
Flutter學習筆記（5）--Dart運算子
2019-07-11
Flutter筆記Dart
七週學會七種語言：學習程式語言的實用指南
2011-10-25
Dart語言概覽
2019-09-18
Dart
dart語言基礎
2021-07-30
Dart
Flutter學習筆記（8）--Dart物件導向
2019-07-19
Flutter筆記Dart物件
函數語言程式設計：Flutter&Dart中的組合
2023-02-14
函數程式設計FlutterDart
Dart 語言入門（四）
2018-12-24
Dart
C語言學習方法，怎麼學習C語言？
2021-02-01
C語言
（六）Flutter學習之Dart非同步操作詳解
2019-07-24
FlutterDart非同步
Flutter之旅:Dart的基礎語法
2019-07-04
FlutterDart
簡易指南帶你啟動 R 語言學習之旅
2018-02-13
java語言學習
2021-09-09
Java
go語言學習
2024-04-14
Go
Dart 語言極簡入門
2020-04-13
Dart