【Flutter--实战】Dart 语言快速入门

前言

Dart 是 Flutter SDK 指定的语言，因此要学习 Flutter，Dart 是必须掌握的。本篇文章来介绍下 Dart 的精髓，带你快速入门。

1. Dart开发环境搭建

学习 Dart 语法最好需要用一个编辑器来实践，推荐使用 IntelliJ IDEA 。

• 下载 Dart SDK, 地址为：http://www.gekorm.com/dart-windows/

• 打开 IntelliJ IDEA，菜单中点击 File–>Settings–>plugins，在 plugins 的搜索框中搜索 Dart 并安装，然后重启 IntelliJ IDEA。

• 点击 File–>New Project–>Dart ，按照下图配置 Dart SDK 。 注意:要选择第三个选项 Constole Application ,否则会默认创建一个 Web 项目。点击 Next 然后配置项目的名称就可以创建项目了。

在项目中的 bin/main.dart 中加入如下测试代码：

void main() {
  print("Hello World");
}

点击菜单的 Run–>Run’main.dart’ 或者点击工具条的运行图标，就能在控制台看到输出的结果：

2. 变量

• 基本类型

bool done = true;
int num = 2;
double x = 3.14;

final bool visible = false;
final int amount = 100;
final double y = 2.7;

const bool debug = true;
const int sum = 42;
const double z = 1.2;

跟常用的其他语言不同，Dart 没有 byte、char 和 float，int、double 都是 64 位。final 跟 Java 里的 final 一样，表示一个运行时常量（在程序运行的时候赋值，赋值后值不再改变）。const 表示一个编译时常量，在程序编译的时候它的值就确定了。

如果你觉得每次写变量类型太麻烦，你应该会喜欢 Dart 的类型推断功能：

var done = true;
var num = 2;
var x = 3.14;

final visible = false;
final amount = 100;
final y = 2.7;

const debug = true;
const sum = 42;
const z = 1.2;

Dart 里所有的东西都是对象，包括 int、函数。

• dynamic 和 Object

Object o = 'string';
o = 42;
o.toString();   // 我们只能调用 Object 支持的方法

dynamic obj = 'string';
obj['foo'] = 4;  // 可以编译通过，但在运行时会抛出 NoSuchMethodError

Object 和 dynamic 都使得我们可以接收任意类型的参数，但两者的区别非常的大。

使用 Object 时，我们只是在说接受任意类型，我们需要的是一个 Object。类型系统会保证其类型安全。

使用 dynamic 则是告诉编译器，我们知道自己在做什么，不用做类型检测。当我们调用一个不存在的方法时，会执行 noSuchMethod() 方法，默认情况下（在 Object 里实现）它会抛出 NoSuchMethodError。

为了在运行时检测进行类型检测，Dart 提供了一个关键字 is：

dynamic obj = {};
if (obj is Map) {  
	// 进过类型判断后，Dart 知道 obj 是一个 Map，  
	// 所以这里不用强制转换 obj 的类型，即使我们声明 obj 为 Object。  
	obj['foo'] = 42;
}

// 虽然 Dart 也提供了 as 让我们进行类型的强制转换，但为了进来更安全
// 的转换，更推荐使用 is
var map = obj as Map;

3. 空安全（null-safety）

Dart 中一切都是对象，这意味着如果我们定义一个数字，在初始化它之前如果我们使用了它，假如没有某种检查机制，则不会报错，比如：

test() {
  int i; 
  print(i*8);
}

在 Dart 引入空安全之前，上面代码在执行前不会报错，但会触发一个运行时错误，原因是 i 的值为 null 。但现在有了空安全，则定义变量时我们可以指定变量是可空还是不可空。

int i = 8; //默认为不可空，必须在定义时初始化。
int? j; // 定义为可空类型，对于可空变量，我们在使用前必须判空。

// 如果我们预期变量不能为空，但在定义时不能确定其初始值，则可以加上late关键字，
// 表示会稍后初始化，但是在正式使用它之前必须得保证初始化过了，否则会报错
late int k;
k=9;

如果一个变量我们定义为可空类型，在某些情况下即使我们给它赋值过了，但是预处理器仍然有可能识别不出，这时我们就要显式（通过在变量后面加一个”!“符号）告诉预处理器它已经不是null了，比如：

class Test{
  int? i;
  Function? fun;
  say(){
    if(i!=null) {
      print(i! * 8); //因为已经判过空，所以能走到这 i 必不为null，如果没有显式申明，则 IDE 会报错
    }
    if(fun!=null){
      fun!(); // 同上
    }
  }
}

上面中如果函数变量可空时，调用的时候可以用语法糖：

fun?.call() // fun 不为空时则会被调用

4. 数据基本类型

Dart 的基本数据类型包括 Number、String、List、Set、Map 。

• Number number类型为两类：

  • int：整数值不大于64位，具体取决于平台。在Dart VM上，值可以是-2 ^63到2 ^63 - 1，如果编译为JavaScript，允许值为-2^53 to 2^53 - 1。
  • double：64-bit (双精度) 浮点数，符合 IEEE 754 标准。

• String

var str = ' foo';
var str2 = str.toUpperCase();
var str3 = str.trim();
assert(str == str2);
assert(!identical(str, str2));

Dart 里的 String 跟 Java 中的一样，是不可变对象；不同的是，检测两个 String 的内容是否一样事，我们使用 == 进行比较；如果要测试两个对象是否是同一个对象（indentity test），使用 identical 函数。

• List

// 使用构造函数创建对象
// 跟 var list = new List(); 一样
var list = List();
list.add(1);
list.add(2);

// 通过字面量创建对象，list 的泛型参数可以从变量定义推断出来。
// 推荐使用字面量方式创建对象
var list2 = [1, 2];
// 没有元素，显式指定泛型参数为 
intvar list3 = [];
list3.add(1);
list3.add(2);

var list4 = const[1, 2];
// list4 指向的是一个常量，我们不能给它添加元素（不能修改它）
list4.add(3);       // error
// list4 本身不是一个常量，所以它可以指向另一个对象
list4 = [4, 5];     // it's fine

const list5 = [1, 2];
// 相当于 const list5 = const[1, 2];
list5.add(3);       // error

// Dart 同样提供了 for-in 循环。
// 因为语音设计时就考虑到了这个需求，in 在 Dart 里是一个关键字
var list6 = [1, 3, 5, 7];
for (var e in list6) {  
	print(e);
}

在 Dart 2 里，创建对象时可以省略 new 关键字，也推荐省略 new。

• Set

var set = Set();
set.add('foo');
set.add('bar');
assert(set.contains('foo'));

我们只能通过 Set 的构造函数创建实例。

• Map

var map = Map();
// 添加
map['foo'] = 1;
map['bar'] = 3;
// 修改
map['foo'] = 4;
// 对应的 key 不存在时，返回 null
if (map['foobar'] == null) {  
	print('map does not contain foobar');
}

var map2 = const {  
	'foo': 2,  
	'bar': 4,
};
var map3 = {};

5. 函数

最普通的函数看起来跟 Java 里的一样：

int foo(int x) {  
	return 0;
}

Dart 也支持可选参数：

void main() {  
	print(foo(2));  
	print(foo(1, 2));
}

int foo(int x, [int y]) {  
	// 是的，int 也可以是 null  
	if (y != null) {    
		return x + y;  
	}  
	return x;
}

输出结果：

2 3

默认参数也是支持的：

int foo(int x, [int y = 0]) {  
	return x + y;
}

还能用具名参数（named parameters）：

void main() {  
	print(foo(x: 1, y: 2));  
	// 具名参数的顺序可以是任意的  
	print(foo(y: 3, x: 4));  
	// 所有的具名参数都是可选的，这个调用是合法的，但它会导致 foo() 在运行时抛异常  
	print(foo());
}

int foo({int x, int y}) {  
	return x + y;
}

具名参数也可以有默认参数：

void main() {  
	print(foo(x: 1, y: 2));  
	print(foo());
}

int foo({int x = 0, int y = 0}) {  
	return x + y;
}

如果想告诉用户某个具名参数是必须的，可以使用注解 @required：

int foo({@required int x, @required int y}) {  
	return x + y;
}

函数还可以在函数的内部定义：

// typedef 在 Dart 里面用于定义函数类型的别名
typedef Adder = int Function(int, int);

Adder makeAdder(int extra) {  
  int adder(int x, int y) {    
	  return x + y + extra;  
  }  
  return adder;
}

void main() {  
  var adder = makeAdder(2);  
  print(adder(1, 2));
}

输出结果：

5

像上面这样简单的函数，我们还可以使用 lambda：

typedef Adder = int Function(int, int);

Adder makeAdder(int extra) {  
  return (int x, int y) {    
    return x + y + extra;  
  };  
  // 如果只有一个语句，我们可以使用下面这种更为简洁的形式  
  // return (int x, int y) => x + y + extra;
}

void main() {  
  var adder = makeAdder(2);  
  print(adder(1, 2));
}

Dart 里面不仅变量支持类型推断，lambda 的参数也支持自动推断。上面的代码还可以进一步简化为：

typedef Adder = int Function(int, int);

Adder makeAdder(int extra) {  
	// 我们要返回的类型是 Adder，所以 Dart 知道 x, y 都是 int  
	return (x, y) => x + y + extra;
}

void main() {  
	var adder = makeAdder(2);  
	print(adder(1, 2));
}

美中不足的是，Dart 不支持函数的重载。

6. 语句

常见的 if/else，do while，while 和 switch 在 Dart 里面都支持。switch 也支持 String 和 enum。

var success = true;
if (success) {  
	print('done');
} else {  
	print('fail');
}

for (var i = 0; i  print('file ${exists ? 'exists' : 'not exists'}'))      
		.catchError((e) => print(e));
}

Dart 2 提供了 async 函数，用来简化这种编程范式。下面这段代码的效果跟上面是一样的：

void foo() async {  
	var file = File('path-to-your-file');  
	try {    
		var exists = await file.exists();    
		print('file ${exists ? 'exists' : 'not exists'}');  
	} catch (e) {    
		print(e);  
	}
}

但是要注意，上面两段代码并不是完全一样的：

// import 语句用于导入一个包
import 'dart:io';

void main() {  
	foo();  
	bar();
}

void bar() {  
	var file = File('path-to-your-file');  
	file.exists()      
		.then((exists) => print('bar: file ${exists ? 'exists' : 'not exists'}'))      
		.catchError((e) => print(e));  
	print('bar: after file.exists() returned');
}

void foo() async {  
	var file = File('path-to-your-file');  
	try {    
		var exists = await file.exists();    
		print('bar: file ${exists ? 'exists' : 'not exists'}');    
		print('bar: after file.exists() returned');  
	} catch (e) {    
		print(e);  
	}
}

// 一种可能的结果：
// bar: after file.exists() returned
// foo: file not exists
// foo: after file.exists() returned
// bar: file not exists

这里的关键在于，bar 函数里面，file.exists() 执行完后，会马上执行下面的语句；而 foo 则会等待结果，然后才继续执行。