Flutter學習指南:熟悉Dart語言
本文是 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,更多的資訊讀者可以檢視 ofollow,noindex">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 官網還有許多資源等待讀者去發掘。
程式設計·思維·職場