共计 6834 个字符，预计需要花费 18 分钟才能阅读完成。
Flutter 是由 Google 开发的 UI 工具包, 是采用了 Dart 来编写的框架和 widget。
所以我们要学习 Flutter 开发，就有必要了解 dart 语言，不说精通，至少得对 dart 的一些语法有一些了解。
其实如果你以前有过其它程序开发经验，很快便能掌握 dart 语法。
和 javascript 相比，dart 是一门强类型的语言，Dart 综合了动态语言和静态语言的特性。
变量与内置类型
变量
声明变量
// 声明变量并赋值
var name = 'Bob'
// 如果声明时没有赋值，默认值为 null
String name; // name 的值为 nullfinal 与 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 语法通读一遍文档就基本上能掌握个大概。