一、 Dart 基本語法

1、 Hello Dart

/*
1.Dart語言的入口是main函數(shù)，并且必須顯示的進(jìn)行定義
2.打印是使用print
3.每行語句必須適應(yīng)分號結(jié)尾
*/
void main(List<String> args) {
  // List<String> args -> 列表<String> - 泛型
  print('Hello World!!!!');
}

• 1.Dart語言的入口也是main函數(shù)，并且必須顯示的進(jìn)行定義；
• 2.Dart的入口函數(shù)main是沒有返回值的；
• 3.傳遞給main的命令行參數(shù)，是通過List<String>完成的。
  從字面值就可以理解List是Dart中的集合類型。
  其中的每一個(gè)String都表示傳遞給main的一個(gè)參數(shù)；
• 4.定義字符串的時(shí)候，可以使用單引號或雙引號；
• 5.每行語句必須使用分號結(jié)尾，很多語言并不需要分號，比如Swift、JavaScript；

2、 聲明變量

2.1 明確聲明

變量類型 變量名稱 = 賦值;

  String name = "why";
  int age = 18;
  double height = 1.88;

注意事項(xiàng): 定義的變量可以修改值, 但是不能賦值其他類型

String content = 'Hello Dart';
content = 'Hello World'; // 正確的
content = 111; // 錯(cuò)誤的, 將一個(gè)int值賦值給一個(gè)String變量

2.2 類型推導(dǎo)(var/final/const/dynamic)

var/dynamic/const/final 變量名稱 = 賦值;

類型推導(dǎo)的方式雖然沒有明確的指定變量的類型，但是變量是有自己的明確的類型的

2.2.1 var的使用

var的使用示例:

• runtimeType用于獲取變量當(dāng)前的類型

  var age = 10;
  age = 30;
  print(age.runtimeType);

var的錯(cuò)誤用法:

var age = 18;
age = 'why'; // 不可以將String賦值給一個(gè)int類型

2.2.2 dynamic 使用

如果確實(shí)希望這樣做,可以使用dynamic來聲明變量:
但是在開發(fā)中, 通常情況下不使用dynamic, 因?yàn)轭愋偷淖兞繒?huì)帶來潛在的危險(xiǎn)

dynamic name = 'coderwhy';
print(name.runtimeType); // String
name = 18;
print(name.runtimeType); // int

2.2.3 final & const

final和const都是用于定義常量的, 也就是定義之后值都不可以修改

final name = 'coderwhy';
name = 'kobe'; // 錯(cuò)誤做法

const age = 18;
age = 20; // 錯(cuò)誤做法

final 和 const的區(qū)別

• const 必須賦值 常量值（編譯期間需要一個(gè)明確的值）
• final 可以通過計(jì)算/函數(shù)來獲取一個(gè)值（運(yùn)行期間來確定一個(gè)值）

String getName() {
  return 'coderwhy';
}

main(List<String> args) {
  const name = getName(); // 錯(cuò)誤的做法, 因?yàn)橐獔?zhí)行函數(shù)才能獲取到值
  final name = getName(); // 正確的做法
}

const date1 = DateTime.now(); // 寫法錯(cuò)誤 const 編譯期間需要一個(gè)明確的值
final date2 = DateTime.now(); // 寫法正確

• const放在賦值語句的右邊，可以共享對象，提高性能:

void main(List<String> args) {
  // 在Dart2.0之后，const 可以省略
  const p1 = Person("why1");
  const p2 = Person("why1");
  const p3 = const Person("why2");

  print(identical(p1, p2)); // p1 和 p2 是同一個(gè)對象
  print(identical(p1, p3)); // p1 和 p3 不是同一個(gè)對象
}

class Person {
  final String? name; // 此處必須使用final，否則會(huì)報(bào)錯(cuò)。不能在一個(gè)沒有final聲明變量的類中定義一個(gè)常量函數(shù)
  const Person(this.name); // 常量構(gòu)造函數(shù)
}

3. 數(shù)據(jù)類型

3.1 數(shù)字類型

對于數(shù)值來說，我們也不用關(guān)心它是否有符號，以及數(shù)據(jù)的寬度和精度等問題。只要記著整數(shù)用int，浮點(diǎn)數(shù)用double就行了。
不過，要說明一下的是Dart中的int和double可表示的范圍并不是固定的，它取決于運(yùn)行Dart的平臺

  // 1.整數(shù)類型
  var age = 18;
  int hexage = 0x12;
  print(age);
  print(hexage);

  // 2.浮點(diǎn)類型
  double height = 1.88;
  print(height);

字符串和數(shù)字之間的轉(zhuǎn)化:

  // 1.字符串和數(shù)字之間的轉(zhuǎn)換
  var one = int.parse('111');
  var two = double.parse('12.22');
  print('${one} ${one.runtimeType}');
  print('${two} ${two.runtimeType}');

  // 2.數(shù)字轉(zhuǎn)字符串
  var num1 = 123;
  var num2 = 123.456;
  var num1Str = num1.toString();
  var num2Str = num2.toString();
  var num2StrD = num2.toStringAsFixed(2); // 保留兩位小數(shù)
  print('$num1Str ${num1Str.runtimeType}');
  print('$num2Str ${num2Str.runtimeType}');
  print('${num2StrD} ${num2StrD.runtimeType}');

3.2 布爾類型 (true / false)

  var isflag = true;
  bool isflag2 = false;

  print('$isflag ${isflag.runtimeType}');
  print('$isflag2 ${isflag2.runtimeType}');

注意: Dart中不能判斷非0即真, 或者非空即真
Dart的類型安全性意味著您不能使用if(非booleanvalue)或assert(非booleanvalue)之類的代碼。

  var message = "Hello Dart";
  // 錯(cuò)誤寫法
  if (message) {
    print(message);
  }

3.3 字符串類型

使用單引號或雙引號創(chuàng)建一個(gè)字符串 可以使用三個(gè)單引號或者雙引號表示多行字符串

  String s1 = 'Hello World';
  var s2 = "Hello World";
  var s3 = 'Hello\'Flutter';
  var s4 = "Hello'Flutter";
  var msg = '''
  哈哈哈哈
  呵呵呵呵 
  啦啦啦啦''';

  print('$s1');
  print('$s2');
  print('$s3');
  print('$s4');
  print('$msg');

字符串和其他變量或表達(dá)式拼接: 使用${expression}, 如果表達(dá)式是一個(gè)標(biāo)識符, 那么{}可以省略

  var myname = 'why';
  var myage = 18;
  var myheight = 1.88;
  print("my name is $myname, age is $myage, height is $myheight");

3.4 集合類型

集合類型 List / Set / Map

• List 定義

  // 使用類型推導(dǎo)
  var letters = ['a', 'b', 'c', 'd', 'a'];
  print('$letters, ${letters.runtimeType}');
  // 明確指定類型
  List<int> numbers = [1, 2, 3, 5];
  print('$numbers, ${numbers.runtimeType}');

• Set 定義
  其中，set可以這樣來定義：其實(shí)，也就是把[]換成{}就好了。
  Set和List最大的兩個(gè)不同就是：Set是無序的，并且元素是不重復(fù)的

  // 1.使用類型推導(dǎo)
  var letterSet = {'a', 'b', 'c', 'd'};
  print("$letterSet, ${letterSet.runtimeType}");

  // 2.明確指定類型
  Set<int> numberSet = {1, 2, 3, 4};
  print('$numberSet, ${numberSet.runtimeType}');

• Map定義 （字典類型）

  // 1.使用類型推導(dǎo)
  var infoMap1 = {'name': 'why', 'age': 18};
  print('$infoMap1 ${infoMap1.runtimeType}');

  // 2.明確指定類型
  Map<String, Object> infoMap2 = {'height': 1.88, 'address': 'beijing'};
  print('$infoMap2, ${infoMap2.runtimeType}');

3.4.1 集合常見操作

• length 集合長度

  // 1.集合長度length
  print('${letterSet.length}');
  print(letters.length);
  print(infoMap1.length);

• 添加/刪除/包含元素

  // 2.添加/刪除/包含元素
  numbers.add(8);
  numberSet.add(8);
  infoMap1["height"] = 1.88;
  print('$numbers,$numberSet');

  numbers.remove(1);
  numberSet.remove(1);
  infoMap1.remove("name");
  print('$numbers $numberSet $infoMap1');

  print(
      '${numbers.contains(8)}, ${numberSet.contains(8)}, ${infoMap1.containsKey("name")}');

  numbers.removeAt(0);
  numbers.removeLast();

• Map 操作

  // map 操作
  // 1.根據(jù)key獲取value
  print(infoMap1['name']);
  // 2.獲取所有的entries
  print('${infoMap1.entries}');
  // 3.獲取所有keys values
  print('${infoMap1.keys}   ${infoMap1.values}');
  // 4.是否包含某個(gè)key 或 value
  print(
      '${infoMap1.keys.contains('name')}   ${infoMap1.values.contains('20')}');
  // 5.根據(jù)key刪除元素
  infoMap1.remove('age');
  print(infoMap1);

二、Dart函數(shù)調(diào)用

Dart是一種真正的面向?qū)ο笳Z言，所以即使函數(shù)也是對象，也有類型, 類型就是Function。
這也就意味著函數(shù)可以作為變量定義或者作為其他函數(shù)的參數(shù)或者返回值.

1. 函數(shù)的基本使用

函數(shù)的定義方式:

返回值 函數(shù)的名稱(參數(shù)列表) {
  函數(shù)體
  return 返回值
}

按照上面的定義方式, 我們定義一個(gè)完整的函數(shù):

// 返回值的類型可以省略（開發(fā)中不推薦）
int sum(num num1, num num2) {
  return num1 + num2;
}

返回值的類型可以省略（開發(fā)中不推薦）

如果函數(shù)中只有一個(gè)表達(dá)式, 那么可以使用箭頭語法(arrow syntax)

注意, 這里面只能是一個(gè)表達(dá)式, 不能是一個(gè)語句

sum(num1, num2) => num1 + num2;

2. 函數(shù)的參數(shù)問題

函數(shù)的參數(shù)可以分成兩類: 必須參數(shù)和可選參數(shù)
前面使用的參數(shù)都是必須參數(shù).

// 必選參數(shù)：必須傳
void sayHello(String name) {
  print(name);
}

2.1 可選參數(shù)

可選參數(shù)可以分為 命名可選參數(shù) 和 位置可選參數(shù)

定義方式:
命名可選參數(shù): {param1, param2, ...}
位置可選參數(shù): [param1, param2, ...]

命名可選參數(shù)的演示:

// 命名可選參數(shù)
// 根據(jù)名字匹配  必須有名字的 對順序無要求
printInfo1(String name, {int age, double height}) {
  print('name=$name age=$age height=$height');
}

// 調(diào)用printInfo1函數(shù)
printInfo1('why'); // name=why age=null height=null
printInfo1('why', age: 18); // name=why age=18 height=null
printInfo1('why', age: 18, height: 1.88); // name=why age=18 height=1.88
printInfo1('why', height: 1.88); // name=why age=null height=1.88

位置可選參數(shù)的演示:
實(shí)參和形參在進(jìn)行匹配時(shí)，是根據(jù)位置匹配的

// 定義位置可選參數(shù)
printInfo2(String name, [int age, double height]) {
  print('name=$name age=$age height=$height');
}

// 調(diào)用printInfo2函數(shù)
printInfo2('why'); // name=why age=null height=null
printInfo2('why', 18); // name=why age=18 height=null
printInfo2('why', 18, 1.88); // name=why age=18 height=1.88

命名可選參數(shù), 可以指定某個(gè)參數(shù)是必傳的(使用@required)
不傳時(shí)，編譯不會(huì)報(bào)錯(cuò)，會(huì)報(bào)警告

// 命名可選參數(shù)的必須
printInfo3(String name, {int age, double height, @required String address}) {
  print('name=$name age=$age height=$height address=$address');
}

2.2 參數(shù)默認(rèn)值

參數(shù)可以有默認(rèn)值, 在不傳入的情況下, 使用默認(rèn)值
注意, 只有可選參數(shù)才可以有默認(rèn)值, 必須參數(shù)不能有默認(rèn)值

// 參數(shù)的默認(rèn)值

void sayHello2(String name, [int? age = 29, double? height = 2.0]) {
  print('$name  $age  $height');
}
printInfo4(String name, {int age = 18, double height=1.88}) {
  print('name=$name age=$age height=$height');
}

3、 函數(shù)是一等公民

函數(shù)是一等公民：可以將函數(shù)賦值給一個(gè)變量, 也可以將函數(shù)作為另外一個(gè)函數(shù)的參數(shù)或者返回值來使用.

void main(List<String> args) {
  // 1.將函數(shù)賦值給一個(gè)變量
  var bar = foo;
  bar();
  print(bar);

  // 2.將函數(shù)作為另一個(gè)函數(shù)的參數(shù)
  test(foo);

  // 3.函數(shù)作為另一個(gè)函數(shù)的返回值
  var tempfunc = getFunc();
  tempfunc();
}

void foo() {
  print("foo 調(diào)用");
}

void test(Function func) {
  func();
}

Function getFunc() {
  return foo;
}

4、 匿名函數(shù)的使用

匿名函數(shù)(參數(shù)列表){函數(shù)體}

void main(List<String> args) {
  test((name) {
    print(name);
  });

  test2((str) {
    print("$str");
    return 10;
  });
}

void test(Function func) {
  func("why");
}

void test2(Function func) {
  int res = func("why");
  print("$res");
}

void main(List<String> args) {
  test1((name, {age, height}) {
    return "$name --- $age -- $height";
  });
}

// 將 函數(shù) String foo(String name,{int age,double height} 作為 test1的參數(shù)
test1(String foo(String name, {int? age, double? height})) {
  String res = foo("why", age: 18, height: 2.0);
  print(res);
}

void main(List<String> args) {
  test2((num1, num2) => num1 + num2);
}

typedef Calculate = int Function(int num1, int num2);

test2(Calculate cal) {
  var res = cal(10, 20);
  print(res);
}

void main(List<String> args) {
  var cal = test3();
  print(cal(10, 20));
}

typedef Calculate = int Function(int num1, int num2);
// 函數(shù)作返回值
Calculate test3() {
  return (num1, num2) {
    return num1 * num2;
  };
}

5、 詞法作用域

dart中的詞法有自己明確的作用域范圍，它是根據(jù)代碼的結(jié)構(gòu)({})來決定作用域范圍的
優(yōu)先使用自己作用域中的變量，如果沒有找到，則一層層向外查找

var name = "global";
void main(List<String> args) {
  var name = "main";
  void foo() {
    // var name = "foo";
    print("$name");
  }
  foo();
}

6、 詞法閉包

閉包可以訪問其詞法范圍內(nèi)的變量，即使函數(shù)在其他地方被使用，也可以正常的訪問。

void main(List<String> args) {
  makeAddr(num addBy) {
    return (num i) {
      return i + addBy;
    };
  }

  var addr2 = makeAddr(2);
  print(addr2(10)); // 12
  print(addr2(6)); // 8

  var addr5 = makeAddr(5);
  print(addr5(10)); // 15
  print(addr5(8)); // 13
}

7、 返回值問題

所有函數(shù)都返回一個(gè)值。如果沒有指定返回值，則語句返回null;隱式附加到函數(shù)體。

void main(List<String> args) {
  print(foo()); // null
}

foo() {
  print("foo 調(diào)用");
}