Flutter--实战Dart 语言快速入门
Posted Kevin-Dev
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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 = <String, int>;
if (obj is Map<String, int>)
// 进过类型判断后，Dart 知道 obj 是一个 Map<String, int>，
// 所以这里不用强制转换 obj 的类型，即使我们声明 obj 为 Object。
obj['foo'] = 42;
// 虽然 Dart 也提供了 as 让我们进行类型的强制转换，但为了进来更安全
// 的转换，更推荐使用 is
var map = obj as Map<String, int>;
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<int>(); 一样
var list = List<int>();
list.add(1);
list.add(2);
// 通过字面量创建对象，list 的泛型参数可以从变量定义推断出来。
// 推荐使用字面量方式创建对象
var list2 = [1, 2];
// 没有元素，显式指定泛型参数为
intvar list3 = <int>[];
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<String>();
set.add('foo');
set.add('bar');
assert(set.contains('foo'));
我们只能通过 Set 的构造函数创建实例。
- Map
var map = Map<String, int>();
// 添加
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 = <String, String>;
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 < 5; ++i)
print(i);
var sum = 0;
var j = 1;
do
sum += j;
++j;
while (j < 5);
while (sum-- > 0)
print(sum);
var type = 1;
switch (type)
case 0:
// ...
break;
case 1:
// ..
break;
case 2:
// ...
break;
default:
// ...
break;
7. 异常
抛出异常：
throw Exception('put your error message here');
捕获异常：
try
// ...
// 捕获特定类型的异常
on FormatException catch (e)
// ...
// 捕获特定类型的异常，但不需要这个对象
on Exception
// ..
// 捕获所有异常
catch (e)
// ...
finally
// ...
跟 Java 不同的是，Dart 可以抛出任意类型的对象：
throw 42;
8. 类
定义一个类：
class Point2D
static const someConst = 2;
int x;
// 成员变量也可以是 final 的
final int y;
Point2D(int x, int y)
this.x = x;
this.y = y;
由于这种初始化方式很常见，Dart 提供了更简洁的方式：
class point2d
int x;
int y;
point2d(this.x, this.y);
此外，还可以使用初始化列表（initializer list）对对象进行初始化：
class Point2D
int x;
int y;
// 由于是在 initializer list 中，Dart 知道第一个 x 是 this.x，
// 第二个 x 是构造函数的参数
Point2D(int x, int y) : x = x, y = y
// ...
initializer list 会在构造函数的函数体运行前执行。
Dart 具有垃圾收集功能，对象的使用跟 Java 里几乎是一样的：
main()
var point = Point2D(1, 2);
point.x = 4;
print(point);
class Point2D
int x;
int y;
Point2D(this.x, this.y);
// 所有的类都继承自 Object，toString() 是 Object 中的方法
@override
String toString()
// 在字符串的内部可以通过 $expression 的方式插入值，如果
// expression 是一个变量，可以省略花括号
return "Point2Dx=$x, y=$y";
输出结果：
Point2Dx=4, y=2
9. mixin
Dart 是不支持多继承的，但是它支持 mixin，简单来讲 mixin 可以 “组合” 多个类，我们通过一个例子来理解。
定义一个 Person 类，实现吃饭、说话、走路和写代码功能，同时定义一个 Dog 类，实现吃饭、和走路功能：
class Person
say()
print('say');
mixin Eat
eat()
print('eat');
mixin Walk
walk()
print('walk');
mixin Code
code()
print('key');
class Dog with Eat, Walk
class Man extends Person with Eat, Walk, Code
我们定义了几个 mixin，然后通过 with 关键字将它们组合成不同的类。有一点需要注意：如果多个mixin 中有同名方法，with 时，会默认使用最后面的 mixin 的，mixin 方法中可以通过 super 关键字调用之前 mixin 或类中的方法。我们这里只介绍 mixin 最基本的特性，关于 mixin 更详细的内容读者可以自行百度。
10. 泛型
跟 Java 不同，Dart 的泛型参数类型在运行时是保留的。
class Pair<S, T>
S first;
T second;
Pair(this.first, this.second);
void main()
var p = Pair('hello', 2);
print(p is Pair<String, int>);
// is! 也是 Dart 的运算符，下面的语句跟 !(p is Pair<int, int>) 是一样的，
// 但 is! 读起来跟像英语
print(p is! Pair<int, int>);
print(p is Pair);
输出结果：
true true true
11. Future
Dart 是单线程的，主线程由一个事件循环来执行（类似 android 的主线程）。对于异步代码，我们通过 Future 来获取结果：
import 'dart:io';
void foo()
var file = File('path-to-your-file');
file.exists()
.then((exists) 以上是关于Flutter--实战Dart 语言快速入门的主要内容，如果未能解决你的问题，请参考以下文章