Dart语法笔记总结

Flutter学习之Dart语法特性

https://juejin.cn/post/6844903795630194701

Dart语言的特色

• 编译成快速、可预测的本地代码，使Flutter几乎都可以使用Dart编写，在Debug下，Dart是JIT(jUST In Time 运行时编译，边运行边编译，java虚拟机就用到)编译，开发周期快，就好像Flutter亚热级的热重载。
• Dart可以在没有锁的情况下进行对象分配和垃圾回收 而Dart针对这个问题，采取了isolate方法来解决，Dart中的线程称为isolate，不共享内存
• 易于移植，Dart可编译成ARM和X86代码，这样Dart移动应用程序可以在iOS、Android和其他地方运行。

2.一个最基本的Dart程序

var一种不指定类型声明变量的方式

4.Default value(默认值)

没有初始化的变量自动获取一个默认值为null。类型为数字的变量如果没有初始化那么默认的值也是null

5.Optional types（可选的类型）

声明变量的时候，可以选择加上具体类型,如下面：

6.Final and const

如果以后不打算修改一个变量，使用final或者const。一个final变量只能赋值一次；一个const变量是编译时常量。注意：const变量同时也是final变量，实例变量可以为final但不能是const

7.Built-in types(内置的类型)

在Dart有几种内置的数据类型：数值型-Number、布尔型-boolean、键值对-Map、字符串-String、列表-List、其他类型-Runes、Symbols

7.1数值型-Number

• 使用num声明的变量，可以随意的转换类型，如果使用int或者double明确的声明,那就不能转换了
• 判断一个int值需要多少位时，可以使用bitLength

8.数值型的操作

奇数 偶数 比较 保留2位小数 int 和double 互转
绝对值 , 四舍五入 , //求小于它的最大整数
//求大于它的最小整数

//执行程序入口
void main(){


  int i =7;
  double d = 10.1;

  print(i / d);               //0.6930693069306931
  print(i ~/ d);              //0   这个操作是取整 就是得出商

  print(i.isOdd);             // 判断是奇数
  print(i.isEven);            // 判断是偶数


  //String -> int
  var x1 = int.parse("7");
  print(x1 == 7);              //输出true

  //Sting -> double
  var x2 = double.parse("7.7");
  print(x2 == 7.7);             //输出true

  //int -> String
  var x3 = 7.toString();
  print(x3 == '7');             //输出true

  //double -> String
  var x4 = 7.1234.toStringAsFixed(2);
  print(x4 == '7.12');          //输出true

  //求绝对值
  var x5 = (-7).abs();
  print(x5 == 7);

  //四舍五入1
  var x6 = (7.7).round();
  print(x6);                   //输出8

  //四舍五入2
  var x7 = (7.3).round();
  print(x7);                   //输出7

  //求小于它的最大整数
  var x8 = (7.7).floor();
  print(x8);                   //输出7

  //求大于它的最小整数
  var x9 = (7.7).ceil();
  print(x9);                   //输出8

  double num1 = 7.77;
  print(num1);                //结果是7.77
  double num2 = 7;
  print(num2);                //结果是7.0
  int num3 = 7;
  print(num3.toDouble());     //int 转 double 结果是7.0
  double num4 = 7.77;
  print(num4.toInt());        //double 转 int 结果是7
  
}

9.Strings(字符串)

字符串比较==
字符串拼接+
单双引号 , 并且可以有嵌套

可以获取字符串的内容，用{表达式}也可以使用字符串拼接。下面也是直接上例子：

bool flag = true;
  String m_str1 = "字符串";
  print("看看这个值：${m_str1} ""看看这个值flag：${flag}"); //输出：字符串：字符串 看看这个值flag：true

  //使用$+字符串
  String name = "knight";
  print("$name" + "CTO");     //输出：knightCTO；

  //使用字符串拼接，运用了String类中的toUpperCase函数，把字母变成大写 
  String m_str = "Android";
  assert('${m_str.toUpperCase()} is very good' ==       
        'ANDROID is very good');
  

断言: assert() 语句被忽略了。在检查模式assert(condition) 会执行

10.Boolean（布尔值）

只有两个对象是布尔类型的，那就是true和false所创建的对象，这两个对象都是编译时常量。当Dart需要一个布尔值，只有true对象才被认为是true

11.Lists列表

array是编程语言中最常见的集合类型，我相信身为开发者，都用过。在Dart中数组就是List对象，所以一般称为lists,下面直接上Dart list的示例：

问题

• 创建list
• 使用构建创建list
• 创建常量list
• 增加泛型
• 固定长度的list
• 创建包含以下元素的list
• 创建固定范围改变的长度的列表
• //创建包含所有元素的固定长度列表
• //用生成器给所有元素赋初始值

//创建一个int类型的list 并赋值为0，1，2，3，4
  List list =  [0,1,2,3,4];

  //使用构建的方式创建list
  List list1 = new List();

  //创建一个常量的List，不可以改变的List
  List list2 = const[0,1,2,3];

  //增加泛型
  List list3 = new List();

  //创建固定的长度的数组列表，不能移除或者增加
  List list4 = new List(5);

  //创建包含所有以下元素的可改变的长度列表
  List list5 = new List.from([0,1,2,3]);

  //创建在固定范围内改变长度的列表
  List list6 = new List()..length = 10;

  //创建包含所有元素的固定长度列表
  List list7 = new List.unmodifiable([0,1,2]);

  //用生成器给所有元素赋初始值
  List list8 = new List.generate(5, (int i){
    return i + i;

  });

List常用的一些api：

• 添加
• 修改
• 移除
• 获取列表的长度
• 向列表中的指定位置添加元素 在第0的位置上插入Android
• 判断数组中是否有某元素
• 排序

 //在列表中存放不同类型的对象
  List list = [1,2,3,false,"Kinght"];
  print(list);          //输出：[1, 2, 3, false, Kinght]

  //在列表中添加元素
  list.add(7);
  print(list);          //输出：[1, 2, 3, false, Kinght, 7]

  //修改列表下标为1的值
  list[1] = "paul";
  print(list);          //输出：[1, paul, 3, false, Kinght, 7]

  //移除列表的指定值得的元素
  list.remove("paul");
  print(list);          //输出：[1, 3, false, Kinght, 7]

  //移除列表指定下标下的元素
  list.removeAt(0);
  print(list);          //输出：[3, false, Kinght, 7]

  //获取列表的长度
  print(list.length);   //输出：4

  //向列表中的指定位置添加元素 在第0的位置上插入Android
  list.insert(0, "Android");
  print(list);          //输出：[Android, 3, false, Kinght, 7]

  //判断数组中是否有某元素
  print(list.indexOf("Android")); //这里存在，输出对应的下标，如果没有则输出-1

  //排序
  List list1 = [3,1,2,6,7];
  // 根据语法提示： List.sort([(int, int) → int compare]) → void
  list1.sort((a,b) => a.compareTo(b));
  print(list1);           //输出：[1, 2, 3, 6, 7]

12.Maps

通常来讲，Map是一个键值对相关的对象，键和值可以是任何类型的对象。每个键只出现一次，而一个值则可以出现多次。上面直接上Map集合的创建方式：

问题api:

• 创建
• 添加值
• 复制map
• 直接声明map
• 创建空map
• 在目标的map6 创建新的不可修改的map7
• 创建key为int
• 9.根据list所提供的key value来创建map
• //通过构建器来创建Map

  //1.通过构建器来创建Map
  Map map1 = new Map();
  //添加值 赋值
  map1["one"] = 'Android';
  map1["two"] = 'IOS';
  map1["three"] = 'Flutter';
  print(map1);              //输出：{one: Android, two: IOS, three: Flutter}

  //2.通过复制的形式
  Map map2 = Map.of(map1);
  print(map2);              //输出：{one: Android, two: IOS, three: Flutter}

  //3.跟上面形式一样  Object.fromEntries() 函数传入一个键值对的列表，并返回一个带有这些键值对的新对象。
  // 这个迭代参数应该是一个能够实现@iterator方法的的对象，返回一个迭代器对象。它
  // 生成一个具有两个元素的类似数组的对象，第一个元素是将用作属性键的值，第二个元素是与该属性键关联的值。
  Map map3 = Map.fromEntries(map1.entries);
  print(map3);

  //4.直接声明，直接赋值key为String类型的map
  Map map4 = {'one':'Android',
    'two':'IOS',
    'three':'Flutter'};
  print(map4);              //输出：{one: Android, two: IOS, three: Flutter}

  //5.创建一个空的Map
  Map map5 = Map.identity();
  print(map5);              //输出：{}


  //6.创建不可变的Map
  Map map6 = const {'one':'Android','two':'IOS','three':'flutter'};
  print(map6);              //输出：{one: Android, two: IOS, three: flutter}

  //7.在目标的map6创建(复制)新的不可修改map7
  Map map7 = Map.unmodifiable(map6);
  print(map7);              //输出：{one: Android, two: IOS, three: flutter}

  //8.创建key为int值得map
  Map map8 = {1:'Android',
    2:'IOS',
    3:'Flutter'};
  print(map8);              //输出：{1: Android, 2: IOS, 3: Flutter}

  //9.根据list所提供的key value来创建map
  List keys = ['one','two'];
  List values = ['Android','IOS'];
  Map map9 = Map.fromIterables(keys, values);
  print(map9);               //输出：{one: Android, two: IOS}
  
   //通过构建器来创建Map
   Map map10 = new Map();
   //添加值 赋值 赋值不同类型的Map
   map10["one"] = 'Android';
   map10["two"] = 'IOS';
   map10["three"] = 'Flutter';
   map10[4] = 'RN';
   print(map10);              //输出：{one: Android, two: IOS, three: Flutter, 4: RN}

Map常用的一些api：

• //创建Map key是int类型，value是String类型
• //对Map第一个位置赋值，中括号是key
• //获取Map的长度
• //判断Map是否为空
• //判断Map是否不为空
• //检索Map是否含有某个Key
• //检索Map是否包含某个Value
• //删除某个键值对
• //获取所有的key
• //获取所有的values

 //创建Map key是int类型，value是String类型
   var  map1 = new Map();

   //对Map第一个位置赋值，中括号是key
   map1[0] = 'Android';
   //对Map第二个位置赋值
   map1[1] = 'IOS';
   //对Map第三个值赋值
   map1[2] = 'flutter';
   //对Map赋空值
   map1[3] = null;
   //因为Map中的键值是唯一的，当第二次输入的key如果存在，Value会覆盖之前
   map1[2] = 'RN';
   print(map1);                //{0: Android, 1: IOS, 2: RN, 3: null}

   //获取Map的长度
   print(map1.length);         //输出：4

   //判断Map是否为空
   print(map1.isNotEmpty);     //输出结果：true

   //判断Map是否不为空
   print(map1.isEmpty);        //输出结果：false

   //检索Map是否含有某个Key
   print(map1.containsKey(1)); //输出：true

   //检索Map是否包含某个Value
   print(map1.containsValue('Android'));  //输出：true

   //删除某个键值对
   map1.remove(0);
   print(map1);                //输出：{1: IOS, 2: RN, 3: null}

   //获取所有的key
   print(map1.keys);           //输出：(1, 2, 3)

   //获取所有的values
   print(map1.values);         //输出：(IOS, RN, null)

   //循环打印
   /*
     key:1, value:IOS
     key:2, value:RN
     key:3, value:null

    */
     map1.forEach((key,value) {
     print("key:${key}, value:${value}");
   });

当Map的Key没有指定类型时，Key类型不一致也不会报错。
Map里面的key不能相同。但是value可以相同,value可以为空字符串或者为null。
创建Map有两种方式：通过构造器(new)和直接赋值。

Runes

runes代表字符串的UTF-32 code points。Unicode为每一个字符、标点符号、表情符号等都定义了一个唯一的数值。什么意思呢？也就是在书写系统中，每一个字母，数字都是有唯一的数值。由于在Dart字符串是UTF-16 code units字符序列，所以在字符串表达32-bit Unicode值就需要新的语法，通常用\uXXXX的方式表示Unicode code point，这里的XXXX是4个16进制的数。如：心形符号是\u2665。对于非4个数值的情况，把编号放到大括号即可。例如，笑脸()是\u{1f600}。String类有一些属性可以提取rune信息。codeUnitAt和codeUnit属性返回16-bit code units。使用runes属性来获取字符串的runes信息。下面示例演示了runes、16-bit code units、和32-bit code points之间的关系：

Symbols

一个Symbolobject代表Dart程序声明的操作符或者标识符。你也许从来不会用到Symbol，但是该功能对于通过名字来引用标识符的情况是非常有价值的，特别是混淆后的代码，标识符的名字被混淆了，但是Symbol的名字不会改变，下面列下例子：

15.function方法

Dart是一个真正的面向对象语言，方法也是对象并且具有一种类型，Function。这意味着，方法可以赋值给变量，也可以当做其他方法的参数。也可以把Dart类的实例当做方法来调用

bool isNoble(int atomicNumber) => list[atomicNumber] != null;

=> expr是语法{return expr;}形式的缩写。=>形式也称为胖箭头语法。注意：在箭头(=>)和冒号(;)之间只能使用一个表达式，不能使用语句。方法可以有两种类型的参数：必需和可选的。必需的参数在参数列表前面，后面是可选参数。

15.5.静态作用域

Dart是静态作用域语言，变量的作用域在写代码的时候就缺的过了。基本上大括号里面定义的变量就只能在大括号里面访问，和java作用域类似。

15.6.Lexical closures(词法闭包)

一个闭包是一个方法对象，不管该对象在何处被调用，该对象都可以访问其作用域内的变量，方法可以封闭定义到其作用域内的变量。方法可以封闭定义到其作用域内的变量。下面示例中，makeAdder()捕获到了变量addBy。

15.7.Testing functions for equality(测试函数是否相等)

15.8.Return values (返回值)

所有的函数都返回一个值。如果没有指定返回值，则默认把语句return null;作为函数的最后☝一个语句执行。

16.3.类型判定操作符

image.png

16.4.赋值操作符

使用=操作符赋值。但是还有一个??=操作符来指定值为null的变量值。

a = value;   // 给 a 变量赋值
b ??= value; // 如果 b 是 null，则赋值给 b；
             // 如果不是 null，则 b 的值保持不变

16.8.级联操作符

• 级联操作符(..)可以在同一对象上连续调用多个函数以及访问成员变量。使用级联操作符可以避免创建临时变量，并且写出来的代码看起来更加流畅

• 级联调用也可以嵌套：

final addressBook = (new AddressBookBuilder()
      ..name = 'jenny'
      ..email = '[email protected]'
      ..phone = (new PhoneNumberBuilder()
            ..number = '415-555-0100'
            ..label = 'home')
          .build())
    .build();

在方法上使用级联操作符需要非常小心，例如下面代码是不合法的：

var sb = new StringBuffer();
sb.write('foo')..write('bar');

17.Control flow statements(流程控制语句)

17.1.if else

if (isRaining()) {//条件语句
  you.bringRainCoat();//内容体
} else if (isSnowing()) {//条件语句
  you.wearJacket();//内容体
} else {
  car.putTopDown();//内容体
}

17.3.While and do-while

17.6.Assert(断言)

assert上面也说过了，assert方法参数可以为任何布尔值的表达式或者方法。如果返回的值为true，断言执行通过，执行结束。如果返回值为false，断言执行失败，会抛出异常，断言只有在检查模式运行有效，如果生产模式运行，则断言不会执行。

18.Exceptions(异常)

对于可以抛出多种类型异常的代码，你可以指定多个捕获语句。每个语句分别对应一个异常类型，如果捕获语句没有指定异常类型，则该可以捕获任何异常类型：

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // A specific exception
  buyMoreLlamas();
} on Exception catch (e) {
  // Anything else that is an exception
  print('Unknown exception: $e');
} catch (e) {
  // No specified type, handles all
  print('Something really unknown: $e');
}

使用rethrow关键字可以把捕获的异常重新抛出：

void misbehave() {
  try {
    foo = "You can't change a final variable's value.";
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }
}

18.3.Finally

try {
  breedMoreLlamas();
} finally {
  // 即使抛出异常也会执行
  cleanLlamaStalls();
}

19.Classes

var p = new Point(2, 2);

// 对实例对象的变量y赋值
p.y = 3;

// 从成员变量得到值
assert(p.y == 3);

// 从p复制实例对象
num distance = p.distanceTo(new Point(4, 4));

19.1.Instance variables

19.8.Overridable operators(可覆写的操作符)

class Vector {
  final int x;
  final int y;
  const Vector(this.x, this.y);

  /// 覆写 + (a + b).
  Vector operator +(Vector v) {
    return new Vector(x + v.x, y + v.y);
  }

  /// 覆写 - (a - b).
  Vector operator -(Vector v) {
    return new Vector(x - v.x, y - v.y);
  }
}

main() {
  final v = new Vector(2, 3);
  final w = new Vector(2, 2);

  // v == (2, 3)
  assert(v.x == 2 && v.y == 3);

  // v + w == (4, 5)
  assert((v + w).x == 4 && (v + w).y == 5);

  // v - w == (0, 1)
  assert((v - w).x == 0 && (v - w).y == 1);
}

19.10.Implicit interfaces(隐式接口)

19.12.Enumerated types(枚举类型)

enum Color {
 red,
 green,
 blue
}

19.14.2.Static methods(静态函数)

对于通用的或者经常使用的静态函数，考虑使用顶级方法而不是静态函数，静态函数还可以当做编译时常量使用，如：把静态函数当做常量构造函数的参数来使用。

20.泛型