Dart学习1-语法

Dart特点：

1、基于JIT的快速开发周期：
flutter在开发阶段采用了JIT模式，避免了每次改动都要进行编译，节省开发时间（运行的时候再去编译成机器码）

2、基于AOT的发布包：
flutter在发布时可以通过AOT生成高效的ARM代码以保证应用性能。
（提前将我们的代码编译成机器码）

3、单线程
不需要锁，不存在数据竞争和变量状态同步，也没有线程上下文切换的性能顺灏和锁导致的卡顿

4、垃圾回收
多生代（新生代：复制-清除算法、老生代：标记-清除算法。第一次创建的时候就是新生代，每隔一段时间检查一遍变量，有用的就保留，没用的清除，这些存活下来的就会标记一下，到了一定数量就会进入老生代，老生代的对象很少被清理）无锁垃圾回收器，专门为UI框架中常见的大量widgets对象创建和销毁优化

1、变量

1.1 var与dynamic

void main() {
  // 方法可以不写在类中，独立存在
  int a = 0; // 声明变量，可以直接用int，与java类型

  var b = "哈哈";
  // b = 10; // 报错，声明变量赋值的那一刻，就决定了它的类型。b是string类型

  var c; // 没有给变量c赋值，那c的值就是null，类型是object。下面就可以任意赋值
  c = "嘿嘿";
  c = 10;

  // dynamic关键字，意思是动态的。不是在编译的时候来确定变量的实际类型，而是在运行的时候动态的确定类型
  // 效率没有静态的高。
  // 在不确定类型时传入，不经常使用
  dynamic d = "呵呵";
  d = 20;

  // 以下三个的区别。是编译和运行的时候，底层实现上存在区别
  Object i = 1; // 在编译的时候是object，任意类型。它的类型由它的值确定
  var j = 1; // 在编译期确定了j的类型是int
  dynamic z = 1; // 在运行时才确定z的类型，它的类型也是由它的值确定
}

2.2 final与const

void main2() {
  final i = 1; // final是运行时常量
  // i = 2; // 报错，final修饰的变量不能再赋值。和java中用法一样

  const j = 1; // const是编译器常量，在编译期就已经确定了值，运行效率比final高
  // j =2; // 报错，const修饰的变量也不能再赋值。

  // const z = i; // 报错，i是运行时才确定值，不能赋值给编译期就需要确定的变量
  const z = j; // 这个是可以的，都是编译器就能确定的值
  const z2 = j + 1;

  final k = z2; // 这个也可以的。可以将编译时就确定的值赋值给运行时才确定的变量
}

2、七大内置类型

数值类型（num）、字符串类型（String）、布尔类型（bool）、数组类型（List）、映射类型（Map）、Unicode（Runes）、标识符（Symbols）

2.1 数值类型（num）

void main() {
  // java中的int占4个字节，dart中的int 是动态确定字节大小的
  // 在编码的时候，可以将int当成java的short、int、long来使用，
  // 如果我们写的dart代码超过了4个字节，那么dart会将其编译成类似java中的long类型
  // 否则编译成java中的short或者int
  int i = 1; // 占1个字符
  int i1 = 2; // 占2个字符
  int i2 = 3; // 占2个字符
  int i3 = 10; // 占4个字符
}

2.2 字符串类型（String）

void main() {
  String str = "haha"; //声明和java中的string一样
  String str2 = "${str}hehe"; // 字符串的拼接和kotlin中的类似

  String str3 = 'heihei'; // dart中既可以使用单引号，也可以使用双引号，没有区别
  // 其好处是，可以混合使用。比如说在java中如果想要打印带有双引号的字符串，就需要使用转义
  String str4 = "\"test\""; // java中写法。dart也可以这样写，但还有下面两种写法。
  String str5 = "'test'"; // dart中就可以混合写，写法2
  String str6 = '"test2"'; // dart中写法3

  // 如果我们想在dart中打印带转义字符的字符串，比如打印 /n ,也需要使用转义
  String str7 = "\\n";
  // 也可以使用r前缀，r的意思就是raw,原始。舍弃字符串中所有的字表符、换行符、空格符等
  String str8 = r"\n";

  // 三个双引号用来声明多行字符串。与kotlin中类似
  String str9 = """
  aaaa
  bbbbbb
  cccccccc
  """;
}

2.3 布尔类型（bool）

void main() {
  bool b = false;
}

2.4 数组类型（List）

void main() {
  // List<String> list = new List(); // 可以省略new
  List<int> list1 = [1, 2, 3, 4]; // 可以直接用中括号进行赋值，初始列表
  // 像java数组一样通过下标取元素，和kotlin类似
  var item = list1[0];

  // 遍历数组方式1,（模板快捷键iter）
  for (var o in list1) {}

  // 遍历数组方式2,（模板快捷键itar）
  for (var i = 0; i < list1.length; ++i) {
    var o = list1[i];
  }

  // 在初始列表前添加关键字const
  // const前面学过，表示编译期就已经确定了的值，不可修改。这里表明这个集合对象是不可变的，不能再add元素了
  List<int> list2 = const [1, 2, 3, 4];
  // list2.add(5); // 运行时报错
  list2 = [1, 2]; // 不报错

  // 如果const修饰的是变量，也就是引用，那么变量就不能再重新引用其他对象了，也不能添加元素
  const List<int> list3 = [1, 2, 3, 4];
  // list3 = [1,2]; // 编译报错
  // list3.add(5); // 运行时报错
}

2.5 映射类型（Map）

void main() {
  // key和value用 : 分隔
  Map<int, int> map = {1: 2, 2: 3, 3: 4};
  var value = map[1]; // 中括号里的是key，得到的值是value
  map[1] = 1; // 修改value

  // 用const声明和list是一样的。const修饰对象，不可添加/修改元素
  var map1 = const {1: 2, 2: 3, 3: 4};
  // map1[3] = 100;// 添加元素，运行报错

  // const Map<int, int> map2 = {1: 2, 2: 3, 3: 4};
  // map2[3] = 100;// 添加元素，运行报错

  const Map<int, int> map2 = {1: 2, 2: 3, 3: 4};
  // map2[3] = 100;// 添加元素，运行报错
  // map2 = {1: 2, 2: 3};// 运行报错

  // 遍历:迭代器的遍历
  var keys = map2.keys;
  for (var value1 in keys) {}
}

2.6 Unicode（Runes）/ 标识符（Symbols）

Unicode Runes:特殊字符表示类（Unicode32，字符的编码标准）。不常用

// Symbols 标识符。不常用
void main() {
  var a = #afda;
  print(a.runtimeType);// 打印的结果就是Symbol
  // 可以用于switch语句
}

3、操作符

3.1 类型转换：as

void main() {
  var j = 1;
  var i = j as int; // 类型转换，类似kotlin，java中的强转
  print('i=$i');

3.2 类型判断 ：is 、 is!

void main() {
  Object i1 = 1;
  var isInt = i1 is int; // 类型判断，类似kotlin，java中的instantof
  var isBool = i1 is! bool; // 判断对象不是某个类型

3.3 赋值操作符：??=

void main() {
  var a;
  if (a == null) {
    a = "赋值了";
  }
  a ??= "我的值为null"; //安全赋值。如果k的值为null，则输出等号后面的值。相当于kotlin中的?=
}

3.4 条件表达式：

void main() {
  // 三目表达式 ? :
  var c = true ? "t" : "f"; // 与java用法一样

  // ??
  var d;
  var d1 = 1;

  var e = d ?? 2; // e = 2
  var e1 = d1 ?? 2; // e1 = 1
}

3.5 级联操作符：..

void main() {
  // 使用两个..来实现链式调用
  Builder()
    ..aa()
    ..bbbb() // bbbb()的返回值会被忽略
    ..ccccccc();
}

class Builder {
  void aa() {}

  bool bbbb() {
    return true;
  }

  void ccccccc() {}
}

3.6 安全操作符：?.

void main() {
  // 类似kotlin中的
  var str = null;
  print(str?.length); // 如果str为null，不执行str.length()
}