Dart 基礎入門
參考連接markdown
Built-in Data Types
- Numbers
- int
- double
- Strings
- Booleans
- Lists
- Maps
- Runes
- Symbols
Dart 中全部的數據類型都是 Object， 因此數據類型的默認值爲 nullide
在 Dart 中定義一個變量的方法： 例如：定義一個整型的變量 age，並賦上初始值爲 10函數
int age = 10;
var age = 10;
複製代碼
上面這兩種寫法都是能夠的，第二種方式會自動推斷出 age 的類型爲整型。oop
定義一個字符串類型的變量 name，並賦上初始值爲 "jack"ui
String name = "jack";
var name = "jack";
複製代碼
布爾值類型this
bool isAlive = true;
var isAlive = true;
複製代碼
三目運算
var name_1;
var name_2 = "Jack";
複製代碼
和 Java 中的三目運算同樣：spa
// name_1是否爲空？爲空 則取 name_2 不然 取值 name_1 的值
var finalName = name_1 == null ? name_2 : name_1;
複製代碼
在 Dart 中判空還有一種寫法，使用 ?? 來判斷，以下：3d
var finalName = name_1 ?? name_2;
複製代碼
表示 若是 name_1 不爲空，則返回 name_1，不然返回 name_2code
Switch
switch 的條件能夠是 int， String， boolcdn
for loop
List letters = ["a", "b", "c", "d"];
for (String letter in letters) {
print(letter);
}
複製代碼
For 循環執行邏輯以下： Initialize --> Condition check --> Code Execute --> Increment / Decrement
While 循環執行邏輯： Condition Check --> Code Execute --> Increment / Decrement
Do - While 循環執行邏輯： Code Execute --> Increment / Decrement --> Condition Check
Function
Functions in Dart are Object
Dart 中的函數能夠做爲變量，也能夠做爲參數傳遞給其餘的函數。
使用簡短語法定義函數中的表達式
void main() {
sum(2, 3);
int result = reduce(2, 3);
print(result);
}
void sum(int a, int b) => print("a + b = ${a + b}");
int reduce(int a, int b) => a - b;
複製代碼
Output:
a + b = 5
-1
複製代碼
參數
Dart 中的參數分爲兩種，必須的和可選的，可選參數又包含三種分別爲 位置參數（Positional），具名參數（Named）， 默認參數（Default）
參數的分類以下：
Required Parameters
void main() {
printName("Jack", "Rose");
}
// Required Parameters
void printName(String name1, String name2) {
print('Name 1 is $name1, Name 2 is $name2');
}
複製代碼
可選參數
可選參數使用
[ ]來包裹
void main() {
printCountries("China", "USA", "India");
}
// Optional Positional Parameters
void printCountries(String name1, String name2, String name3) {
print('Name 1 is $name1');
print('Name 2 is $name2');
print('Name 3 is $name3');
}
複製代碼
Output
Name 1 is China
Name 2 is USA
Name 3 is India
複製代碼
這個時候咱們想讓第三個位置的參數變爲可選的，就是用戶調用的時候能夠不傳遞。怎麼寫呢，以下：
void main() {
printCountries("China", "USA");
}
// Optional Positional Parameters
void printCountries(String name1, String name2, [String name3]) {
print('Name 1 is $name1');
print('Name 2 is $name2');
print('Name 3 is $name3');
}
複製代碼
Output:
Name 1 is China
Name 2 is USA
Name 3 is null
複製代碼
那若是咱們想讓最後兩個參數都變成可選的呢，也就是咱們在調用上述方法的時候只須要傳遞一個參數：
void main() {
printCountries("China");
}
// Optional Positional Parameters
void printCountries(String name1, [String name2, String name3]) {
print('Name 1 is $name1');
print('Name 2 is $name2');
print('Name 3 is $name3');
}
複製代碼
Output:
Name 1 is China
Name 2 is null
Name 3 is null
複製代碼
具名參數
具名參數使用
{ }來包裹 具名參數傳遞的時候，和參數順序無關
當一個方法中有大量的參數的時候，咱們可使用具名參數來傳遞，能夠防止參數傳遞錯誤：
void main() {
printCities("Beijing", name2: "Shanghai", name3: "Guangzhou");
}
// Named Parameters
void printCities(String name1, {String name2, String name3}) {
print('Name 1 is $name1');
print('Name 2 is $name2');
print('Name 3 is $name3');
}
複製代碼
Output:
Name 1 is Beijing
Name 2 is Shanghai
Name 3 is Guangzhou
複製代碼
咱們也能夠值傳遞具名參數中的某一部分：
printCities("Beijing", name2: "Shanghai");
複製代碼
Output:
Name 1 is Beijing
Name 2 is Shanghai
Name 3 is null
複製代碼
或者
printCities("Beijing");
複製代碼
Output:
Name 1 is Beijing
Name 2 is null
Name 3 is null
複製代碼
默認值參數
顧名思義，默認參數就是能夠爲參數設置一個默認值。
void main() {
printNameByDefaultParameters("jack");
}
// default parameters
void printNameByDefaultParameters(String name1, {String name2 = "rose"}) {
print('name 1 is $name1');
print('name 2 is $name2');
}
複製代碼
上述 printNameByDefaultParameters 方法中，咱們爲 name2 參數設置了默認值爲 rose ，而後咱們在調用該方法的時候就能夠只傳遞參數 name1 。
Output：
name 1 is jack
name 2 is rose
複製代碼
固然，咱們也能夠不適用默認的參數的值，咱們能夠爲其傳遞值，從而覆蓋默認值：
printNameByDefaultParameters("jack", name2: "Han Meimei");
複製代碼
Output
name 1 is jack
name 2 is Han Meimei
複製代碼
Exception
異常處理
當程序終端或者程序崩潰的時候，這個時候就須要咱們處理異常。 咱們來看一個例子：
void main() {
int result = 12 ~/ 0;
print('The result is $result');
}
複製代碼
上述程序會拋出除數不能爲0的異常：
Unhandled exception:
IntegerDivisionByZeroException
#0 int.~/ (dart:core/runtime/libintegers.dart:18:7)
...
複製代碼
若是咱們知道程序會拋出哪個異常，在 Dart 中，咱們可使用 try on 來捕獲，以下：
void main() {
try{
int result = 12 ~/ 0;
print('The result is $result');
} on IntegerDivisionByZeroException {
print('Cannot devide by zero');
}
}
複製代碼
輸出：
Cannot devide by zero
複製代碼
若是咱們不知道程序會拋出什麼異常，使用 try catch 來捕獲：
try{
int result = 12 ~/ 0;
print('The result is $result');
} catch (e) {
print('The exception is $e');
}
複製代碼
Output：
The exception is IntegerDivisionByZeroException
複製代碼
那若是咱們想知道在拋出異常以前發生了什麼，可使用 Stack Trace 以下：
try{
int result = 12 ~/ 0;
print('The result is $result');
} catch (e, s) {
print('The exception is $e');
print('Stack Trace \n $s');
}
複製代碼
Output:
The exception is IntegerDivisionByZeroException
Stack Trace
#0 int.~/ (dart:core/runtime/libintegers.dart:18:7)
#1 main (file:///Users/liusilong/Dev/Flutter/workspace/DartDemo/src/youtube/exception/Demo1.dart:24:21)
#2 _startIsolate.<anonymous closure> (dart:isolate/runtime/libisolate_patch.dart:289:19)
#3 _RawReceivePortImpl._handleMessage (dart:isolate/runtime/libisolate_patch.dart:171:12)
複製代碼
Finally
不管異常是否拋出，finally 語句塊總會被執行：
try{
int result = 12 ~/ 0;
print('The result is $result');
} catch (e) {
print('The exception is $e');
}finally{
print('finally is always executed');
}
複製代碼
Output:
The exception is IntegerDivisionByZeroException
finally is always executed
複製代碼
上述代碼即便不拋出異常，finally 語句塊中仍是會被執行：
try{
int result = 12 ~/ 3;
print('The result is $result');
} catch (e) {
print('The exception is $e');
}finally{
print('finally is always executed');
}
複製代碼
Output:
The result is 4
finally is always executed
複製代碼
自定義異常
下面來定義一個方法，該方法不能接受小於 0 的參數，而後咱們自定義一個異常，來捕獲傳入該方法的參數是否小於 0 。
// 自定義異常
class MyException implements Exception {
String errorMsg() {
return "count 不能小於0";
}
}
// counter 參數不能小於 0
void enterCounter(int counter) {
if(counter < 0) {
throw MyException();
}
}
// 調用
try {
enterCounter(-2);
} catch(e) {
print(e.errorMsg());
}
複製代碼
Output：
count 不能小於0
複製代碼
面向對象
定義一個類
下面咱們來定義一個 Student 類，並聲明一些實例變量和實例方法：
class Student {
// 默認值爲 null
int id = 7;
// 默認值爲 null
String name;
void study(){
print('${this.name} is now studying');
}
void sleep(){
print('${this.name} is now sleeping');
}
}
複製代碼
接下來咱們實例化一個 Student 而後爲其屬性賦值，並調用其方法：
void main() {
var stu = Student();
stu.id = 8;
stu.name = "jack";
print('${stu.id} and ${stu.name}');
stu.study();
stu.sleep();
}
複製代碼
Output:
8 and jack
jack is now studying
jack is now sleeping
複製代碼
定義構造函數
默認構造函數
同 Java 同樣，在 Dart 中，一個類也會有一個默認的無參的構造函數，咱們也能夠將其定義出來：
// default constructor
Student() {
print('This is default constructor');
}
複製代碼
帶有參數的構造函數
// 帶有參數的構造方法
Student(int id, String name) {
this.id = id;
this.name = name;
}
複製代碼
默認構造方法和帶有參數的構造方法不能同時存在，不然在編譯期就會報錯，以下：
參數化構造函數
通常狀況下，咱們的在構造方法中傳遞的參數會給當前類的實例變量賦值如：this.id = id，這個時候，咱們能夠直接使用參數化構造函數，以下：
// 參數化構造函數
Student(this.id, this.name);
複製代碼
那麼，若是咱們在一個類中先要定義多個構造方法怎麼辦，這個時候可使用 命名構造函數
咱們在構造方法中一樣可使用具名參數，以下：
void main(){
var p = Person("Jack");
p.getInfo();
var p2 = Person("Rose", age: 18);
p2.getInfo();
}
class Person{
String name;
int age;
Person(this.name, {this.age});
void getInfo(){
print('name is $name, age is $age');
}
}
複製代碼
Output:
name is Jack, age is null
name is Rose, age is 18
複製代碼
命名構造函數
// 參數化構造函數
Student(this.id, this.name);
Student.myConstructor(int id) {
this.id = id;
this.name = "Jack";
}
Student.anotherConstructor(String name) {
this.id = 10;
this.name = name;
}
複製代碼
調用以下：
void main() {
var stu1 = Student(8, "jack");
print('${stu1.id} and ${stu1.name}');
var stu2 = Student.myConstructor(7);
print('${stu2.id} and ${stu2.name}');
var stu3 = Student.anotherConstructor("Rose");
print('${stu3.id} and ${stu3.name}');
}
複製代碼
Output:
8 and jack
7 and Jack
10 and Rose
複製代碼
Getter 和 Setter
默認的 Getter 和 Setter
下面咱們仍是定義一個 Student 類，裏面有 name 和 age 兩個屬性：
class Student {
String name;
int age;
}
複製代碼
接着咱們來實例化出一個 Student 的實例，而且爲其屬性賦值：
void main() {
var stu = Student();
// 調用默認的 Setter 方法設置 name
stu.name = "Jack";
// 調用默認的 Getter 方法獲取 name
print('name is ${stu.name}');
}
複製代碼
注意：上述代碼中，咱們分別調用了默認的 Setter 方法和 Getter 方法。
Output:
name is Jack
複製代碼
自定義的 Getter 和 Setter
下面咱們在 Student 類中新添加一個屬性爲 address，咱們來自定義這個屬性的 getter 和 setter 方法：
class Student {
String name; // 默認的 getter 和 setter
int age; // 默認的 getter 和 setter
// new line
String address; // 自定義的 getter 和 setter
set setAddress(String address) {
this.address = address;
print('調用了 address 的 setter 方法，值爲 $address');
}
get getAddress {
print('調用了 address 的 getter 方法');
return address;
}
}
複製代碼
調用
stu.setAddress = "China";
print('stu address is ${stu.getAddress}');
複製代碼
Output:
調用了 address 的 setter 方法，值爲 China
調用了 address 的 getter 方法
stu address is China
複製代碼
繼承
和 Java 中的繼承相似，Dart 中也是使用 extends 關鍵字來實現繼承，一樣，也能夠實現方法重載
下面例子中，咱們定義一個父類 Animal，子類 Dog 來演示他們之間的繼承關係以及方法重載的實現：
void main() {
var dog = Dog();
dog.bark();
dog.eat();
}
// 父類
class Animal {
void eat() {
print('Animal is eating');
}
}
// 子類
class Dog extends Animal {
// 方法重載
void eat() {
// 經過 super 調用父類方法
super.eat();
print('Dog is eating');
}
void bark() {
print('Brak!');
}
}
複製代碼
Output:
Brak!
Animal is eating
Dog is eating
複製代碼
繼承中的構造方法
通常狀況下，若是父類沒有有參構造方法，那麼咱們能夠直接這樣:
// 父類
class Animal {
String color;
// 默認的構造方法
Animal() {}
}
// 子類
class Dog extends Animal {
final String name;
// 帶有一個參數的構造方法
Dog(this.name):super() {}
}
複製代碼
上述狀況中，Animal 類中的構造方法沒有參數，咱們在 Dog 類中能夠將 Dog(this.name):super() 後面部分省略，寫爲Dog(this.name)
那麼若是父類中有參數的狀況下，上述 Dog 類中的寫法就會報錯了，以下：
提示大概意思就是在父類中找不到一個包含0個參數的構造方法，咱們以前也說過，默認的構造方法和帶有參數的構造方法不能同時存在。
因此咱們能夠這樣寫：
class Animal {
String color;
Animal(String color) {}
}
class Dog extends Animal {
final String name;
Dog(this.name, String color) : super(color) {}
}
複製代碼
一樣的，咱們也能夠在子類中使用命名構造方法：
class Dog extends Animal {
final String name;
Dog(this.name, String color) : super(color) {}
Dog.myDog(this.name): super("White"){
}
}
複製代碼
咱們在實例化 Dog 類的時候能夠這樣：
void main() {
var dog1 = Dog("petter", "Blcak");
var dog2 = Dog.myDog("Hello");
}
複製代碼
固然，若是父類中有命名構造方法，咱們在子類中構造方法中去調用父類的命名構造方法：
class Animal {
String color;
Animal(String color) {}
Animal.myAnimal() {}
}
class Dog extends Animal {
final String name;
Dog(this.name, String color) : super(color) {}
Dog.myDog(this.name) : super("White") {}
// 調用父類的 命名構造 方法
Dog.smallDog(this.name) : super.myAnimal() {}
}
複製代碼
注意：
默認狀況下，子類中的構造方法調用的是父類的無參構造方法 父類的構造方法老是在子類的構造方法以前調用 若是在父類中沒有默認構造方法（無參構造方法），那麼須要咱們手動調用父類中的某一個構造方法
抽象類和抽象方法
和 Java 中的抽象類同樣，Dart 中的抽象類也是使用 abstract 關鍵字類修飾。如： abstract class shape{} 抽象類不能直接被實例化，須要實現一個子類來繼承它。 抽象類中能夠包含抽象方法和非抽象方法。抽象方法不能包含方法體且子類必須實現，非抽象方法能夠包含方法體且子類能夠重寫。 抽象類中也能夠定義的實例變量。 抽象方法只能定義在抽象類中。
void main() {
var rect = Rectangle();
rect.draw();
rect.drawShape();
}
// 抽象類
abstract class Shape {
// 定義實例變量
int x;
int y;
// 非抽象方法，子類能夠重寫
void drawShape() {
print('draw shape');
}
// 抽象方法，子類必須實現
void draw();
}
// 子類
class Rectangle extends Shape {
// 實現父類的抽象方法（必選）
@override
void draw() {
// TODO: implement draw
print('draw Rectangle...');
}
// 重寫父類的方法（可選）
@override
void drawShape() {
// TODO: implement drawShape
super.drawShape();
print('rectangle drawshape');
}
}
複製代碼
Output：
draw Rectangle...
draw shape
rectangle drawshape
複製代碼
接口
Java 中的接口是使用 Interface 關鍵字類修飾一個類，可是 Dart 中沒有 Interface 關鍵字。Dart 中的接口依然是使用 class 類定義：
void main() {
var b = B();
b.hello();
b.hi();
}
class A {
void hello() {
print('A hello');
}
}
class C {
void hi() {
print('C hi');
}
}
// class B 實現了 接口 A，C
class B implements A, C {
@override
void hello() {
// TODO: implement hello
print('B hello');
}
@override
void hi() {
// TODO: implement hi
print('B hi');
}
}
複製代碼
Output：
B hello
B hi
複製代碼
那麼咱們在實現的接口方法中能不能使用 super.hello() 呢？
如上圖，是不能夠的，大概意思就是 hello 方法在父類型中是抽象的。
若是咱們將 implements 改成 extends 以後就能夠了。
總結： Dart 沒有特定的語法來聲明一個接口。 Dart 中的接口就是一個普通的類。 當你須要在子類中從新實現父類中的全部方法的時候，可使用接口。 在接口的實現類中，會被強制要求實現父類中的全部方法。 能夠implements多個類，可是隻能 extends 一個類。
靜態方法和變量
和 Java 中的靜態變量相似，Dart 中的靜態變量也是經過 static 關鍵字來聲明，經過 類名.變量名 來訪問：
void main() {
print(Circle.pi);
}
class Circle {
// 定義一個靜態變量
static double pi = 3.14;
}
複製代碼
Output:
3.14
複製代碼
可是，在 Dart 中若是咱們使用類的實例去訪問該類中的靜態變量，編譯時就會報錯：
大概意思就是靜態變量不能經過實例來訪問。
一樣的，靜態方法也是經過 static 關鍵字類聲明，經過 類名.方法名 來調用； 一樣的，靜態方法也不能經過實例來訪問。
void main() {
// 訪問靜態變量
print(Circle.pi);
// 調用靜態方法
Circle.calculateAre();
}
class Circle {
// 定義靜態變量
static double pi = 3.14;
// 定義靜態方法
static void calculateAre() {
print('some code');
}
}
複製代碼
Output：
3.14
some code
複製代碼
靜態方法中只能訪問靜態變量和靜態方法，不能訪問實例變量或者實例方法。
總結：
靜態變量也被稱爲 類變量 靜態方法也被稱爲 類方法 靜態變量都是懶加載的，意思就是當你在程序中使用到的時候該靜態變量纔會被初始化。 靜態變量或者靜態方法與類的實例無關，它們都屬於類自己，因此我麼在靜態方法中不能使用 this 關鍵字 在靜態方法中，咱們只能訪問靜態方法或者靜態變量，不能訪問該類中的實例變量或者實例方法
高階函數和 Lambda 表達式
在 Dart 中，方法也是一個對象 Lambda 是一個沒有方法名的方法
下面咱們來看看示例：
void main() {
// 普通方法調用
addTwoNumbers(2, 3);
// 沒有返回值的 Lambda
Function addTwoNumbersByFunction = (int a, int b) {
var sum = a + b;
print('$sum');
};
addTwoNumbersByFunction(2, 3);
// 帶有返回值的 Lambda
var sum = (int a, int b) {
return a + b;
};
print('${sum(3, 4)}');
}
void addTwoNumbers(int a, int b) {
var sum = a + b;
print('$sum');
}
複製代碼
Output：
5
5
7
複製代碼
咱們還可使用另一種簡短的語法來表示 Lambda，使用 => 來表示
void main(){
// 使用簡短語法聲明沒有返回值的 Lambda
Function addTwoNumbersWithArrows = (int a, int b) => print('${a + b}');
// 調用
addTwoNumbersWithArrows(3, 8);
// 使用簡單語法聲明帶有返回值的 Lambda
var sumWithArrows = (int a, int b) => a + b;
// 調用
print('${sumWithArrows(3, 7)}');
}
複製代碼
Output:
11
10
複製代碼
高階函數
高階函數的定義
- 能夠接受一個 Function 做爲參數的函數
- 能夠返回一個 Function 的函數
- 以上二者都容許
下面咱們來寫一個用於四則運算的高階函數：
void main() {
var plusResult = arithmetic(12, 3, (a, b) => a + b);
var reduceResult = arithmetic(12, 3, (a, b) => a - b);
var multiplyResult = arithmetic(12, 3, (a, b) => a * b);
var divideResult = arithmetic(12, 3, (a, b) => a / b);
print('plus result is $plusResult');
print('reduce result is $reduceResult');
print('myltiply result is $multiplyResult');
print('divide result is $divideResult');
}
// 接受一個 Function 參數，而且返回了一個 Function
double arithmetic(double a, double b, Function function) {
return function(a, b);
}
複製代碼
上述代碼中 arithmetic 方法接受了一個 Function，而且將其做爲返回值返回； 而參數 Function 是接受兩個 double 類型的參數。
咱們在上一小節中講到 高階函數 可使用沒有名稱的方法來表示也可使用 Lambda 來表示。
上述代碼中使用的是 Lambda 做爲高階函數進行傳遞的，那麼若是咱們使用沒有名稱的方法來表示，以下：
var modelResult = arithmetic(12, 3, (a, b) {
return a % b;
});
print('model result is $modelResult');
複製代碼
Output:
plus result is 15.0
reduce result is 9.0
myltiply result is 36.0
divide result is 4.0
model result is 0.0
複製代碼
Collections
固定長度的 List
咱們來聲明一個長度爲 5 的整型 List
定長的集合在被定義以後，長度就不能被改變
void main() {
// 聲明一個固定長度的集合
List<int> numList = List(5);
// 添加元素
numList.add(9);
// 刪除元素
numList.remove(9);
// 刪除指定位置上的元素
numList.removeAt(0);
// 清空集合
numList.clear();
}
複製代碼
那麼若是咱們只想上述代碼以後會怎樣呢？答案是會報錯，由於上述代碼中的4中操做在固定長度的集合中都不支持。
Output：
Unhandled exception:
Unsupported operation: Cannot add to a fixed-length list
...
複製代碼
這裏順帶提一下，上述代碼中咱們知道了會拋出 Unsupported 異常，那麼根據前面的知識，咱們可使用 try..on.. 來捕獲，就當複習一下：
void main() {
try {
// 聲明一個固定長度的集合
List<int> numList = List(5);
// 添加元素
numList.add(9);
// 刪除元素
numList.remove(9);
// 刪除指定位置上的元素
numList.removeAt(0);
// 清空集合
numList.clear();
} on UnsupportedError {
print('操做不支持...');
}
}
複製代碼
Output：
操做不支持...
複製代碼
那麼回到咱們的問題，固定長度的集合要怎麼添加刪除元素呢？以下：
void main() {
// 聲明一個固定長度的集合
List<int> numList = List(5);
numList[0] = 1;
numList[1] = 2;
numList[2] = 3;
numList[3] = 4;
numList[4] = 5;
print('遍歷元素：');
for (int value in numList) {
print(value);
}
print('----更新第一個元素爲 10------');
numList[0] = 10;
print('遍歷元素：');
numList.forEach((value) => print(value));
print('----將第一個元素置爲NULL---');
numList[0] = null;
print('遍歷元素：');
for (int i = 0; i < numList.length; i++) {
print('${numList[i]}');
}
}
複製代碼
上述代碼中，咱們使用了索引的方式來給固定長度的 List 賦值，並使用三種方式來遍歷，第一種爲 for..in ；第二種爲 Lambda 表達式；第三種爲常規的 for 循環
Output：
遍歷元素：
1
2
3
4
5
----更新第一個元素爲 10------
遍歷元素：
10
2
3
4
5
----將第一個元素置爲NULL---
遍歷元素：
null
2
3
4
5
複製代碼
動態長度的 List
咱們直接看示例：
void main() {
// 動態長度的 集合
List<int> list = List();
list.add(1);
list.add(2);
list.forEach((value) => print('$value'));
print('');
list.removeAt(0);
list.forEach((value) => print('$value'));
print('');
list.add(3);
list[0] = null;
list.forEach((value) => print('$value'));
}
複製代碼
Output：
1
2
2
null
3
複製代碼
還有一種聲明方法：
// 這樣也是一個動態的集合
List<String> letterList = ["A", "B", "C"];
letterList.add("D");
letterList.add("E");
letterList.forEach((letter) => print('$letter'));
複製代碼
Output：
A
B
C
D
E
複製代碼
Set
Set 是無序的；Set 是不容許添加劇復元素；Set 不能使用下標來獲取裏面裏面的元素，由於它是無序 的。
void main() {
// 方式一：
Set<String> letterSet = Set.from(["A", "B", "C"]);
letterSet.add("D");
letterSet.add("E");
// 重複的元素將被忽視
letterSet.add("A");
// 使用 for..in.. 遍歷 Set
for (String letter in letterSet) {
print('$letter');
}
print('');
// 方式二：
Set<int> numSet = Set();
numSet.add(0);
numSet.add(1);
numSet.add(2);
// 使用 Lambda 遍歷 Set
numSet.forEach((value) => print('$value'));
}
複製代碼
Output:
A
B
C
D
E
0
1
2
複製代碼
Map
Dart 中 Map 的特性和 Java 中的相似，都是以鍵值對的形式存放，Map 中的鍵是惟一的，可是值能夠重複，Map 也是無序的。
下面看看 Dart 中 Map 的基本操做：
void main() {
Map<String, String> letterMap = Map();
letterMap["a"] = "A";
letterMap["b"] = "B";
letterMap["c"] = "C";
// 檢查是否存在某個 key
letterMap.containsKey("a");
// 更新某個 key 對應的 value，注意 value 爲一個 Lambda 表達式
letterMap.update("a", (value) => "${value}AA");
// 獲取 Map 的長度
letterMap.length;
// 刪除 Map 中的某個元素
letterMap.remove("c");
// 清空 Map
letterMap.clear();
// 遍歷全部的 key
for (String key in letterMap.keys) {
print('$key');
}
print('');
// 遍歷全部的 value
for (String value in letterMap.values) {
print('$value');
}
print('');
// 遍歷全部的 key-value
letterMap.forEach((key, value) => print('$key == $value'));
}
複製代碼
上述代碼中使用的是構造方法的方式來建立 Map，咱們還可使用一下方式來建立：
Map<String, int> studentScoreMap = {
"Jack": 90,
"Rost": 100,
"Mary": 30,
"LiLei": 56
};
studentScoreMap.forEach((name, source) => print('$name == $source'));
複製代碼
Output:
Jack == 90
Rost == 100
Mary == 30
LiLei == 56
複製代碼
Callable
Callable 能讓咱們像調用方法同樣調用某個類，不過咱們在類中須要實現 call 方法：
void main() {
var personOne = Person();
var info = personOne("Jack", 18);
print('$info');
}
class Person {
// 實現 call 方法
String call(String name, int age) {
return "$name is $age years old";
}
}
複製代碼
Output：
Jack is 18 years old
複製代碼
若有錯誤，還請指出。謝謝！！！
- 1. Dart入門基礎介紹
- 2. Dart 語言基礎入門篇
- 3. Flutter基礎（三）Dart快速入門
- 4. Flutter開發必備Dart基礎：Dart快速入門
- 5. Dart 基礎之Mixin（混入）
- 6. Dart入門
- 7. Dart入門（二）
- 8. Dart入門（一）
- 9. Dart基礎（一）
- 10. Dart基礎（四）
- 更多相關文章...
- • Memcached入門教程 - NoSQL教程
- • Kotlin 基礎語法 - Kotlin 教程
- • YAML 入門教程
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Dart入門基礎介紹
- 2. Dart 語言基礎入門篇
- 3. Flutter基礎（三）Dart快速入門
- 4. Flutter開發必備Dart基礎：Dart快速入門
- 5. Dart 基礎之Mixin（混入）
- 6. Dart入門
- 7. Dart入門（二）
- 8. Dart入門（一）
- 9. Dart基礎（一）
- 10. Dart基礎（四）