Flutter (一) Dart 語言基礎詳解(變量、內置類型、函數、操做符、流程控制語句)

變量

變量的聲明

1. var
2. dynamic
3. Object

• 聲明一個未初始化的變量，變量的類型能夠更改

  //變量
  /// 三斜槓文檔註釋
  /// 返回類型 void 能夠省略，省略後的返回值爲 null
  
  void main(){
    ///----------------------- 變量的聲明-----------------
    ///聲明一個未初始化的變量，變量的類型可改變
    var data;
    data = "HelloWorld";
  
    dynamic data1;
    data1 = "HelloWorld1";
    data1 = 123;
  
    Object data2;
    data2 = 'HelloWorld2';
    data2 = 123;
    print([data,data1,data2]);
  }
  
  /// 打印效果
  lib/1-variables.dart:1: Warning: Interpreting this as package URI, 'package:flutter_test3/1-variables.dart'.
  [HelloWorld, 123, 123]
  
  複製代碼

• 聲明一個初始化的變量，變量類型不能再更改

  var variablel =
        'HelloWorld'; //變量是一個引用，名字爲 variablel 的變量引用了一個內容爲‘HelloWorld’的 String 對象。
  // variablel = 123; //變量初始化後，variablel 變量的類型被推斷爲String類型，其類型不能再改變
  複製代碼

• dynamic 和 Object 聲明的變量初始化後，變量的類型仍可改變

  dynamic variable2 = "HelloWorld";
    variable2 = 123;
  // variable2.test();//調用不存在的test()方法，編譯經過，運行報異常。編譯階段不檢查類型
  
    Object variable3 = 'HelloWorld';
    variable3 = 123;
  // variable3.test();//調用不存在的test()方法，編譯不經過。編譯階段檢查類型
  複製代碼

• 使用肯定類型顯示聲明變量，變量的類型不能再改變

  String name3 = "HelloWorld";
  // name3 =123; //變量的類型不能更改
  複製代碼

變量聲明總結

1. var: 若是沒有初始值，能夠變成任何類型

2. dynamic:動態任意類型，編譯階段不檢查類型

3. Object 動態任意類型，編譯階段檢查類型

   區別：

   1. 惟一區別 var 若是有初始值，類型被是鎖定

默認值

• 沒有初始化的變量默認值都是null

  一切皆對象，對象的默認值是null

  bool isEmpty;
  print((isEmpty == null));
  複製代碼

final 和 const

• 被 final 或者 const 修飾的變量，變量類型能夠省略

  final FVariablel = "HelloWorld";
  // final String FVariablel = "HelloWorld";
  
    const cVariablel = "HelloWorld";
  // const String cVariablel = "HelloWorld";
  複製代碼

• 被 final 或 const 修飾的變量沒法再去修改其值。

  // fVariable1 = '123';
  // cVariable1 = '123456';
  複製代碼

• 若是是類級別常量，使用 static, const 。

  DateTime; //可參照DateTime static const int monday = 1;
  複製代碼

• const 可使用其餘 const 常量的值來初始化其值.

  const width = 100;
  const height = 100;
  const square = width * height;
  複製代碼

• const 賦值申明可省略

  const List clist = [1, 2, 3];
  // const List clist = const [1, 2, 3];//dart 2以前，const賦值必須用const聲明
  print("\n\n\n");
  print(clist);
  複製代碼

• 能夠更改非 final,非 const 變量的值，即便它曾經具備 const 值

  var varList = const [1, 2, 3];
    final finalList = const [1, 2, 3];
    const constList = [1, 2, 3];
    print([varList, finalList, constList]);
    varList = [1];
  // constList[1];
  // finalList[1];
    print("\n\n");
    print([varList, finalList, constList]);
  
  	打印效果--
    /*** * [[1, 2, 3], [1, 2, 3], [1, 2, 3]] * [[1], [1, 2, 3], [1, 2, 3]] */
  
  複製代碼

• const 致使的不可變性是可傳遞的

  final List ls = [1, 2, 3];
    ls[2] = 444;
    print(ls);
    const List cLs = [4, 5, 6];
  // cLs[1] = 4;
    print("\n");
    print(ls);
  
  報錯：
        /*** * Unhandled exception:  Unsupported operation: Cannot modify an unmodifiable list  #0 UnmodifiableListBase.[]= (dart:_internal/list.dart:90:5)  #1 main (package:flutter_test3/1-variables.dart:103:6) */
  複製代碼

• 相同的 const 常量不會在內存中重複建立

  final finalList1 = [1, 2, 3];
  final finalList2 = [4, 5, 6];
  print("\n");
  print(identical(finalList1, finalList2)); //identical用於檢查兩個引用是否指向同一個對象
  
  const constList1 = [1, 2];
  const constList2 = [1, 2];
  print("\n");
  print(identical(constList1, constList2)); //identical用於檢查兩個引用是否指向同一個對象
  複製代碼

• const 須要是編譯時常量

  final DateTime finalDateTime = DateTime.now();
  // const DateTime constDateTime = DateTime.now();//DateTime.now() 是運行期計算出來的值
    const sum = 1 + 2; //使用內置數據類型的字面量經過基本運算獲得的值
    const aConstNum = 0;
    const aConstBool = true;
    const aConstString = 'a constant string';
    const aConstNull = null;
    const validConstString =
        '$aConstNum, $aConstBool, $aConstString, $aConstNull';
    print(validConstString); //使用計算結果爲null或數字，字符串或布爾值的編譯時常量的插值表達式
  複製代碼

final 和 const 總結

共同點

• 聲明的類型可省略
• 初始化後不能再賦值
• 不能和 var 同時使用

區別（須要注意的地方）

• 類級別常量，使用 static ，const 。
• const 可以使用其餘 const 常量的值來初始化其值
• const 可以使用其餘 const 常量的值來初始化其值
• 能夠更改非 final、非 const 變量的值，即便曾經具備 const 值
• const 致使的不可變性是可傳遞的
• 相同的 const 常量不會在內存中重複建立
• const 須要是編譯時常量

內置類型

Number 數值(num,int,double)

int i = 1; //整數型
double d = 1.0 ;//double b4-bit(雙精度)浮點數
int bitLength = i.bitLength;
print('bitLength:${bitLength}'); //bitLength 判斷 int 值須要多少位 bit 位。
double maxFinite = double.maxFinite;
print('maxFinite: ${maxFinite}'); //maxFinitedouble的最大值
//int和double都是num的子類
num n1 = 1;
num n2 = 1.0;
//支持 十進制、十六進制
int il = oxfff;
//科學計數法
double dl = 1.2e2; //120.0
//轉換
//String > int
int i2 = int.pasrse('1');
double d2 = 1;//當 double 的值爲 int 值時，int 自動轉爲 double
print('d2：${d2}');
int i2 = int.try.parse('1.0');//返回 null

//int > String
int is = 123;
String s = 123.toString;

複製代碼

String 字符串

//Dart 字符串是 UTF-16 編碼的字符序列，可使用單引號或者雙引號來建立字符串
var name = 'HelloWorld';
//能夠在字符串中使用表達式： ${expression},若是表達式是一個標識符，能夠省略 {}。 若是表達式的結果爲一個對象，則 Dart 會調用對象的 toString() 函數來獲取一個字符串
var names = 'HelloWorld ${name}';
//r 前綴能夠建立一個 「原始 raw」 字符串
var rawNames = r"HelloWorld ${name}";
print('name:${names}');
print('rawNames :${rawNames}');
//若是表達式的結果爲一個對象，則 Dart 會調用對象的 toString() 函數來獲取一個字符串。
pint(Map);
//可使用三個單引號或者雙引號也能夠 建立多行字符串對象
var multiLinesString = ''' Java Android Flutter''';
pint('mutiLinesString:${mutiLinesString}');

/// StringBuffer
var sb = StringBuffer(); //dart 2 能夠省略 new
sb..write('aaa')..write('bbb')..write('ccc');//..級聯符實現鏈式調用
sb.writeAll([aaa,bbb,ccc],',');//第二個參數表示分隔符，將第一個參數列表裏的數據用這個分隔符拼接起來
pint('sb:${sb}');

複製代碼

Booleans 布爾值 (bool)

//bool :true 和 false
bool isNull;
print('isNull: ${isNull}');
複製代碼

List 列表(數組 List)

//聲明一個自動長度的數組
List growableList = new List();
//List growbleList = new List()..length = 3;
growbleList..add(1)..add(2)..add('HelloWorld');
pint('growbleList: ${growbleList}');

//聲明一個固定長度的數組
var list = List(6);// 這裏能夠用 var 聲明，也能夠用 List
list[0] = "Java";
list[1] = "Android";
list[2] = "Dart";
list[3] = "Flutter";
list[4] = "C++";
list[5] = "C"
pint('list:${list}');

//元素固定類型
var typeList = List<String>;
typeList..add("1")..add("2")..add("3");
pint('typeList:${typeList}');

//經常使用屬性-獲取第一個元素
String first = typeList.fisrt;
pint('typeList.fisrt:$typeFirst');
//最後一個元素
String last = typeList.last;
pint('typeList.last:${last}');
//元素個數
int typeListLength = typeList.length;
pint('typeListLength:${typeListLength}');
//元素是否爲空
bool isEmpty = typeList.isEmpty;
pint('typeList.isEmpty:${isEmpty}');
//元素是否不爲空
bool isNotEmpty = typeList.isNotEmpty;
pint('typeList.isNotEmpty:${isNotEmpty}');
//數組倒序
Iterable reversed = typeList.reversed;
print('typeList.reversed:${reversed}');

// 經常使用方法 增刪改查，排序，洗牌，複製子列表
var list4 = [];
//增
list4.add(1);
pint('add 1:${list4}');
list4.addAll([2,3,4]);
print('addAll[2,3,4]:${list4}');
list4.insert(0,0);
print('insert(0,0) : ${list4}');
list4.insertAll(1,[5,6,7,8]);
print('insertAll(1,[5,6,7,8]) :${list4}');
//刪除
list4.remove(5);
print('remove 5 :${list4}');
list4.removeAt(2);
print('remove at 0:${list4}');
//改
list4[4] = 5;
print('updata list4[4] to 5 :${list4}');
//range
list4.fillRange(0,3,9);
print('fillRange updata list4[0] - list[2] to 9 :$list4');
Iterable getRange = list4.getRange(0,3);
print('getRange list4[0]-list[2]:${getRange}');
//查
var contains = list.contains(5);
print('contains 5 :${contains}');
var indexOf = list4.indexOf(1);
print('list4 indexOf 1 :${indexOf}');
int indexWhere = list4.indexWhere((test) => test == 5);
print('list4 indexWhere 5 :${indexWhere}');
// 排序
list4.sort();
print('list4 sort:${list4}');
//洗牌
list4.shuffle();
print('list4 shuffle:${list4}');
//複製子列表
var list5 = list4.shulist(1);
print('sublist(1) list5: ${list5}');
//操做符
var list6 =[8,9];
print('list6:${list6}');
var list7 = list5 + list7;
print('list5 + list6:${list7}');

複製代碼

Maps 鍵值對集合 (Map)

//聲明一個動態類型的 Map
var dynamicMap = Map();
dynamicMap['name'] = 'HelloWorld';
dynamicMap[1] = 'android';
print('dynamicMap :${dymaicMap}');
//強類型
var map = Map<int,String>();
map[1] = 'java';
map[2] = 'Android';
print('map :${map}');
//也能夠這樣聲明
var map1 = {'name':'Java',1:'android'};
map1.addAll({'name','Flutter'});
print('map1:${map1}');
  //經常使用屬性
// print(map.isEmpty); //是否爲空
// print(map.isNotEmpty); //是否不爲空
// print(map.length); //鍵值對個數
// print(map.keys); //key 集合
// print(map.values); //value集合 
複製代碼

Set 集合 (Set)

// Set 無重複列表
var dynamicSet = Set();
dynamicSet.add('java');
dynamicSet.add('Android');
dynamicSet.add('Flutter');
dynamicSet.add('C/C++');
dynamicSet.add('1');
dynamicSet.add('1');
print('dynamicSet :${dynamicSet}');

//經常使用屬性與 List 相似
//經常使用方法 增刪改查與 List 相似
var set1 = {'java','Android'};
print('set1: ${set1}');
var differencel2 = set1.difference(set2);
var difference21 = set1.difference(set1);
print('set1 difference set2 :${differencel2}');//返回 set1 集合裏有但 set2 裏沒有的元素集合
print('set2 difference set1 :${difference2l}');//返回 set2 集合裏面有但 set1 裏沒有的元素集合
var intersection = set1.intersection(set2);
print('set1 set2 交集 :${intersection}');//返回 set1 和 set2 的交集
var union = set1.union(set2);
print('set2 set1並集：${union}');
set2.retainAll(['java','Android']);//只保留（要保留的元素要在原 set 中存在）
print('set2 只保留 java Android :${set2}');
複製代碼

Runes 符號字符

//Runes用於在字符串中表示Unicode字符 //https://copychar.cc/emoji/
String runesStr = '👄';
print(runesStr);
print(runesStr.length); //表示佔 2 個 16 位字符
print(runesStr.runes.length); //表示佔 1 個 32 位字符

Runes runes = new Runes('\u{1f605} \u6211');
var str1 = String.fromCharCodes(runes); //使用String.fromCharCodes顯示字符圖形
print(str1);
String str2 = '\u{1f605} \u6211'; //若是非4個數值，須要把編碼值放到大括號中
print(str2)

複製代碼

Symbols 標識符

//Symbol標識符 主要是反射用，如今mirrors已經被移除了
複製代碼

函數

定義

• 可在函數內定義

  void main(){
      int add(int x,int y){
          return x + y;
      }
      
      print(add(1,2));
  }
  複製代碼

• 定義函數時可省略類型

  void main(){
      add( x, y){ //不建議省略
          return x + y;
      }
      print(add(3,4));
  }
  複製代碼

• 支持縮寫語法 =>

  void main(){
      int add2(int x,int y) => x + y;
      /// 等同於
      int add3(int x，int y){
          return x + y;
      }
       print(add2(3,4));
       print(add3(3,4));
  }
  複製代碼

可選參數

• 可選命名參數，使用 {param1,param2,...} 的形式來指定命名參數

  void main(){
      int add3({int x,int y,int z}){
          x ?? = 1;
          x ?? = 2;
          x ?? = 3;
          return x + y + z;
      }
      print(add3());
  }
  複製代碼

• 可選位置參數，把可選參數放在 [ ] 中，必填參數要放在可循參數前面

  void main(){
      int add(int x,[int y ,int z]){
          y ?? = 2;
          z ?? = 3;
          return x + y + z;
      }   
      print(add(1));
  }
  複製代碼

• 可選命名參數默認值(默認值必須是編譯時常量)，目前可以使用等號 ‘=’ 或 ‘:’,Dart SDK 1.21 以前只能用冒號，冒號的支持之後會移除，因此建議使用等號

  void main(){
      int add5(int x,[int y =2,int z = 3]){
          return x + y +z;
      }
      //前面的必填參數沒有名字
      print(add(5,y:10,z:20));
  }
  
  //可選位置參數默認值(默認值必須是編譯時常量)，只能使用等號 「=」
  void mian (){
      int add6(int x,[int y = 2,int z = 3]){
          return x + y + z;
      }
      
      print(add6(1));
  }
  
  //使用 list 或者 map 做爲默認值，但必須是 const
  void func({List list = const [1,2,3],Map map = const {1:1,'fun' :'全棧'}}){
      //TODO ----
  }
  複製代碼

匿名函數

• 可賦值給變量，經過變量調用

  //無參匿名函數
  var anonFunc1 = () => print('無參匿名函數');
  anonFunction();
  
  //有參匿名函數
  var anonFunc = (name) => 'I am ${name}';
  print(anonFunc('DevYK'));
  
  //經過（）調用，不推薦
  (() => print('不推薦'))();
      
  複製代碼

• 可在其餘函數中直接調用或傳遞給其餘函數

  void main(){
      List test(List list,String func(str)){
          for(var i =0;i < list.length;i++){
              list[i] = func(list[i]);
          }
          return list;
      }
      
      var list = ['a','b','c','d','e'];
      print(test(list,(str) => str * 2)); // String * int ,Dart 和 Py 能夠這樣用。
  
  
    //List.forEach()就用的匿名函數
    List list1 = [11, 12, 13];
    list1.forEach((item) => print('$item'));
  }
  
  複製代碼

閉包

• 返回 Function 對象（閉包）

  void main(){
      Function makeAddFunc(int x){
          x++;
          return (int y) => x + y;
      }
      var addFunc = makeAddFunc(2);
      print(addFunc(3));
  }
  複製代碼

函數別名

• 能夠指向任何同簽名的函數

  void main(){
      MyFunc myFunc;
      myFunc = subtsract;
      myFunc(4,2);
      myFunc = divide;
      myFunc(4,2);
      //typeDef 做爲參數傳遞給參數
      calculator(4,2,subtsract);
  }
  
  //函數別名
  typedef MyFunc(int a,int b);
  //根據 MyFunc 相同的函數簽名定義兩個函數
  subtsract(int a,int b){
      print('subtsract: ${a-b}');
  }
  divide(int a,int b){
      print('divide: ${a / b}');
  }
  //typedef 也能夠做爲參數傳遞給函數
  calculator(int a,int b,MyFunc func){
      func(a,b);
  }
  複製代碼

操做符

後綴操做

• 條件成員訪問 和 . 相似，可是左邊的操做對象不能爲 null，例如 foo?.bar 若是 foo 爲 null 則返回 null，不然返回 bar 成員。

  String a;
  print(a?.length);
  複製代碼

取商操做符

• 被除數 ÷ 除數 = 商 ... 餘數，A ~/ B = C，這個C就是商。至關於Java裏的 /

  print(2 / 3);
  print(2 ~/ 3);
  複製代碼

類型斷定操做符

• as、is、is! 在運行時斷定對象類型

  void main(){
      //as 類型轉換
  num iNum = 1;
  num dNum = 1.0;
  int i = iNum as int;
  double d = dNum as double;
  print([i,d]);
  
  // is 若是對象是指定的類型返回 true
  print(iNum is int);
  Child child;
  Child childl = new Child();
  print(child is Parent);//child is Null
  print(childl is Parent);
  
  // is! 若是對象是制定的類型返回 False
  print(iNum is! int);
  }
  class Parent {}
  class Child extends Parent {}
  
  複製代碼

條件表達式

• 三目運算符 condition ? expr1 : expr2

  bool isFinish = true;
  String textVal = isFinish ？'yes':'no';
  // expr1 ?? expr2，若是 expr1 是 non-null，返回其值； 不然執行 expr2 並返回其結果。
  bool isPaused;
  isPaused = isPaused ?? false;
  //或者
  isPaused ??= false;
  複製代碼

級聯操做符

• .. 能夠在同一個對象上 連續調用多個函數以及訪問成員變量。 嚴格來講， 兩個點的級聯語法不是一個操做符。 只是一個 Dart 特殊語法。

  StringBuffer sb = new StringBuffer();
   sb
    ..write('Java')
    ..write('Android')
    ..write('\n')
    ..writeln('DevYK');
  複製代碼

流程控制語句

if else

for , forEach , for-in

• forEach

  collection.forEach(item) => print('forEach: ${item}');
  複製代碼

• for-in

  for (var item in collection) {
      print('for-in: $item');
    }
  複製代碼

while , do 、while

break，continue

whitch case