Flutter學習指南：熟悉Dart語言
本文是 Flutter 學習指南的第4篇，假定讀者有必定的編程經驗。經過快速瀏覽 Dart 的一些基礎特性，讓讀者具有使用它進行開發的基本能力。web
變量
基本類型
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 表示一個編譯時常量，在程序編譯的時候它的值就肯定了。express
若是你以爲每次寫變量類型太麻煩，你應該會喜歡 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 函數。app
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 的構造函數建立實例。async
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。ide
Object o = 'string';
o = 42;
o.toString(); // 咱們只能調用 Object 支持的方法
dynamic obj = 'string';
obj['foo'] = 4; // 能夠編譯經過，但在運行時會拋出 NoSuchMethodError
複製代碼
Object 和 dynamic 都使得咱們能夠接收任意類型的參數，但二者的區別很是的大。函數
使用 Object 時，咱們只是在說接受任意類型，咱們須要的是一個 Object。類型系統會保證其類型安全。oop
使用 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 官網還有許多資源等待讀者去發掘。
歡迎你們掃碼關注
- 1. Dart語言指南（一）
- 2. Dart語言指南（二）
- 3. Flutter學習之Dart語言註釋
- 4. Flutter-dart-語法學習
- 5. 熟悉編程語言
- 6. Flutter入門（一）------Dart語言
- 7. 一篇文章熟悉ubuntu desktop指南
- 8. Dart語言學習( 三) Dart數值型
- 9. Dart語言學習(十四) Dart泛型
- 10. Dart語言學習(七)Dart Map類型
- 更多相關文章...
- • SQL 指南 - 網站建設指南
- • HTML 指南 - 網站建設指南
- • Kotlin學習（一）基本語法
- • Tomcat學習筆記（史上最全tomcat學習筆記）
-
每一个你不满意的现在，都有一个你没有努力的曾经。