自学flutter系列dart语言学习概览

Flutter 是由 Google 开发的 UI 工具包, 是采用了 Dart 来编写的框架和 widget。
所以我们要学习 Flutter 开发，就有必要了解 dart 语言，不说精通，至少得对 dart 的一些语法有一些了解。
其实如果你以前有过其它程序开发经验，很快便能掌握 dart 语法。
和 javascript 相比，dart 是一门强类型的语言，Dart 综合了动态语言和静态语言的特性。

变量与内置类型

变量

声明变量

// 声明变量并赋值
var name = 'Bob'

// 如果声明时没有赋值，默认值为 null
String name; // name 的值为 null

final 与 const

如果你以后不打算修改一个变量，使用 final 或者 const。一个 final 变量只能赋值一次；一个 const 变量是编译时常量。

const age = 123; // const 在代码编译时就已经确定了变量的值
final age; // 默认为 null
age = 123; // 第一次赋值为 123
age = 234; // Error 报错，final 只能赋值一次

const 关键字不仅仅只用来定义常量。有时也可以用来创建不变的值，还能定义构造函数为 const 类型的，这种类型 的构造函数创建的对象是不可改变的。

内置类型

Numbers

• int 整数
• double 浮点数

int x = 1;
double y = 2.1;

// x = '222' // 报错，x 是整数

数字和字符串这间的转换

// String -> int
int strToInt = int.parse('1');
// String -> double
double strToDouble = double.parse('1.1');

// int -> String
String intToStr = 1.toString();

// double -> String
String doubleToStr = 3.14159.toStringAsFixed(2);

Strings

Dart 字符串是 UTF-16 编码的字符序列。可以使用单引号或者双引号来创建字符串

var s1 = 'Single quotes work well for string literals.';
var s2 = "Double quotes work just as well.";

// 在字符串中使用表达式 ${expression}, 如果表达式是个变量，可以省去{}。// 类似 JS 里的 `abc${var}`
var s = 'string interpolation';
var p = '这是一个表达式 ${s}';
var k = '这是一个表达式 $s';
// 和 js 一样，可以使用 + 连接多个字段串
var t = s + p + k;

使用三个单引号或者双引号也可以 创建多行字符串对象

var s1 = '''
You can create
multi-line strings like this one.
''';

var s2 = """This is also a
multi-line string.""";

Booleans（布尔值）

Dart 有一个名字为 bool 的类型。只有两个对象是布尔类型的：true 和 false 所创建的对象，这两个对象也都是编译时常量。

通俗地讲就是 dart 判断 bool 值就是只能用 true 和 false，像 JS 的 0, 1, null 等都能判断表达式真假，dart 不能。

var name = 'Bob';
if (name) { // 这里 dart 会抛出一个异常，表示 name 变量不是一个布尔值。// javascript 可以这样判断，dart 不能
    print('Bob');
}

Lists（列表）

相当于 JS 里的数组，表示为有序的集合。

Maps

相当于 JS 里的对象字面量，python 里的字典.
Map 是一个键值对相关的对象。键和值可以是任何类型的对象。

var gifts = {
// Keys      Values
  'first' : 'partridge',
  'second': 'turtledoves',
  'fifth' : 'golden rings'
};

// 使用 Map 构造函数也可以实现同样的功能
var gifts = new Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

runes

runes 代表字符串的 UTF-32 code points。

symbols

略过

Functions 函数 (方法)

在 Dart 中，function 是一种类型为 Function 的对象，这意味着 function 可以赋值给变量，也可以当做其他 function 的参数。这和 Javascript 中 function 比较像。

对于只有一个表达式的 function，可以使用 => 形式 缩写:

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

dart 语言函数（方法）有两种参数：必需的和可选的。必需的参数在参数列表前面，后面是可选参数。

可选参数又可以分为命名参数或者基于位置的参数，但是这两种参数不能同时当做可选参数。

参数如果没有设置默认值，默认值为 null。

// 可选命名参数
enableFlags({bool bold, bool hidden}) {// ...}

// 可选位置参数 把一些方法的参数放到 [] 中就变成可选 位置参数了
String say(String from, String msg, [String device]) {
  var result = '$from says $msg';
  if (device != null) {result = '$result with a $device';}
  return result;
}

函数参数到底是值传递，还是地址传递（引用）呢？

// 参数传递简单的数字
void main() {
  int k = 5;
  
  print(k);
  test(k);
  print(k);
}

void test(int a) {
  a = 77;
  print(a);
}
// 返回的结果是
5
77
5

// 函数传递 map
void main() {
  Map<int, String> k = {
    1: '123',
    2: '234'
  };
  
  print(k);
  test(k);
  print(k);
}

void test(Map a) {a[1] = 'kkkk';
  print(a);
}
// 返回的结果是
{1: 123, 2: 234}
{1: kkkk, 2: 234}
{1: kkkk, 2: 234}

看起来和 JS 的函数参数传递是差不多的。

按 JS 函数参数的理解是：

​ 简单的如数字，字符串，bool 是值传弟

​ Lists, Maps, Functions, 对象等是按引用传递。

这种解释在 dart 里可能不是太正确，毕竟在 dart 里，一切都是对象，继承自 Object。

但在我看来按 JS 传参这样理解起来可能更方便懂。

具体原理也可以可以参照 https://blog.csdn.net/bbdxf/a…

1. var a = 10; 这种赋值语法的含义是 a 是指向一个内存对象 10 的引用(ref).

2. var a = 10; var b=a; 则 a,b 都指向同一个内存对象，即引用同一个内存对象。但是 a,b 之间没有任何联系。3. 在 2 的情况下，修改 a 指向对象的值，b 也会跟着改。（矛盾点也在这里！）4. 但是，Dart 中不是所有的对象都可以修改的(mutable or immutable)，其中 number,String，bool 等都是不可变类型，每次修改都是产生一个新的对象。而其他大部分对象都是 mutable, 所以第 3 条的情况在面对 immutable 对象会表现不一致。

操作符

这节我们主要关注下那些与 JS 语法中不一样的那些操作符。其它的像 +, -, * , / , >, <, = ,%, ++, — 等 这些操作符和 js 里完全是一样的。

// 1 整除 ~/ 
// 相当于除数取整数部分，assert(5 ~/ 2 == 2) // 相当于 JS 里的 Math.floor(5/2)
assert(5 ~/ 3 == 1)

// as  类型转换
// is  如果对象是指定的类型返回 True
// is! 如果对象是指定的类型返回 False
// 只有当 obj 实现了 T 的接口，obj is T 才是 true。if (emp is Person) { // Type check
  emp.firstName = 'Bob';
}

(emp as Person).firstName = 'Bob';

// 如果 emp 是 null 或者不是 Person 类型，则第一个示例使用 is 则不会执行条件里面的代码，而第二个情况使用 as 则会抛出一个异常。// 赋值操作符
// ??=  有点像是 JS 里 || 表达式赋值
a = value;   // 给 a 变量赋值
b ??= value; // 如果 b 是 null，则赋值给 b；// 如果不是 null，则 b 的值保持不变
             
// 条件表达式 ??
// 相当于 js 里的 &&

// 级联操作符 ..
// 级联操作符 (..) 可以在同一个对象上 连续调用多个函数以及访问成员变量。// 条件成员访问 ?.  和 . 类似，但是左边的操作对象不能为 null，例如 foo?.bar 
// 如果 foo 为 null 则返回 null，否则返回 bar 成员

querySelector('#button') // Get an object.
  ..text = 'Confirm'   // Use its members.
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'));
  
// 和上面的代码和下面的代码功能一样：var button = querySelector('#button');
button.text = 'Confirm';
button.classes.add('important');
button.onClick.listen((e) => window.alert('Confirmed!'));

流程控制

流程控制和其它编程语言的基本上是一样的。需要注意的是条件表达式（if…else…）的判断条件只能是 True 和 false。

异常处理

Dart 提供了 Exception 和 Error 类型，以及一些子类型。你还 可以定义自己的异常类型。Dart 代码可以 抛出任何非 null 对象为异常，不仅仅是实现了 Exception 或者 Error 的对象。

Throw 抛出异常

try…catch 捕获异常

Finally 要确保某些代码执行，不管有没有出现异常都需要执行

Classes 类

class Point {
    // 类属性
    num x;
    num y;
    // this 关键字指当前的实例。// 构造函数
    Point(this.x, this.y)
    // 相当于
    //Point(num x, num y) {
    //    this.x = x;
    //    this.y = y;
    //}
    // 命名构造函数
    Point.fromJson(Map json) {x = json['x'];
      y = json['y'];
      print('in Super Classes');
    }
    // 方法
    num distanceTo(Point other) {
      var dx = x - other.x;
      var dy = y - other.y;
      return sqrt(dx * dx + dy * dy);
    }
    
    // Getter, setters
    // 每个实例变量都隐含的具有一个 getter，如果变量不是 final 的则还有一 setter。// 你可以通过实行 getter 和 setter 来创建新的属性，使用 get 和 set 关键字定义 getter 和 setter
}

// 调用超类构造函数

class ChildClass extends Point {
    // 采用
    ChildClass.fromJson(Map json) : super.fromJson(data) {print('in Child Classes')
    }
}

抽象类与抽象函数

// 使用 abstract 修饰符定义一个 抽象类—一个不能被实例化的类。抽象类通常用来定义接口，以及部分实现
abstract class Doer {
  // 定义一个抽象类
  void doSomething();}

class EffectiveDoer extends Doer {void doSomething() {// 实现这个抽象类}
}

扩展类（extends）

使用 extends 定义子类，supper 引用 超类

class Television {void turnOn() {_illuminateDisplay();
    _activateIrSensor();}
  void test() {print('Television')
  }
}

class SmartTelevision extends Television {void turnOn() {super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();}
  // 使用 @override 注解来 表明你的函数是想覆写超类的一个函数
  @override
  void test() {print('SmartTelevision')
  }
}

枚举类型

// 使用 enum 关键字来定义枚举类型
enum Color {
  red,
  green,
  blue
}

assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);

类变量和类函数

何为类变量和类函数？即不需实例化该类，使用 类名.即可使用的变量或函数

使用 static 关键字来实现类级别的变量和函数。

import 'dart:math';

class Point {
  num x;
  num y;
  Point(this.x, this.y);

  static num distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

main() {var a = new Point(2, 2);
  var b = new Point(4, 4);
  var distance = Point.distanceBetween(a, b);
  assert(distance < 2.9 && distance > 2.8);
}

泛型

这个泛型对于前端开发人员来说是个新概念。如果你查看 List 类型的 API 文档，则可以看到 实际的类型定义为 List<E>。这个 <…> 声明 list 是一个 泛型 (或者 参数化) 类型。通常情况下，使用一个字母来代表类型参数，例如 E, T, S, K, 和 V 等。

例如，如果你希望一个 list 只包含字符串对象，你可以 定义为 List<String>，这样你、你的同事、以及所使用的工具 (IDE 以及 检查模式的 Dart VM)可以帮助你检查你的代码是否把非字符串类型对象给放到 这个 list 中了。

另外一个使用泛型的原因是减少重复的代码。泛型可以在多种类型之间定义同一个实现，同时还可以继续使用检查模式和静态分析工具提供的代码分析功能。

var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
// 错误
names.add(42); 


// 减少代码量
// 对象缓存
abstract class ObjectCache {Object getByKey(String key);
  setByKey(String key, Object value);
}
// 缓存字符串
abstract class StringCache {String getByKey(String key);
  setByKey(String key, String value);
}
....

// 使用泛型后，定义一个通用的实现
abstract class Cache<T> {T getByKey(String key);
  setByKey(String key, T value);
}
// T 是一个备用类型。这是一个类型占位符，在开发者调用该接口的时候会指定具体类型


//  泛型函数

T first<T>(List<T> ts) {
  // ...Do some initial work or error checking, then...
  T tmp ?= ts[0];
  // ...Do some additional checking or processing...
  return tmp;
}

异步支持

Dart 有一些语言特性来支持 异步编程。最常见的特性是 async 方法和 await 表达式。

Dart 库中有很多返回 Future 或者 Stream 对象的方法。这些方法是 异步的。

是不是很眼熟。async, await 是我们在写 JS 中经常见到的呀。那在我的理解是：

dart 中的 Future 和 Stream 对象就相当于 JS 中的 Promise 对象
async 方法和 await 表达式 使用的 JS 中的使用是一样的。

总结

我们学习 Flutter App 开发，是需要了解一些 dart 语言的语法。我个人的理解是就目前初学者的情况下，我们不需要太深入的学习，大概能掌握 dart 的一些基本语法就够了，很多地语法和 JS 很像，如果有前端基础，dart 语法通读一遍文档就基本上能掌握个大概。