C 系程序员20分钟学会 Dart 语言

mryangjx

2020-04-09

1. 概述

Dart 是 Google 下一代操作系统 Fuchsia 的御用程序开发语言，而是 App 跨平台框架 Flutter 使用的开发语言。它是一种面向对象的语言，使用 C 风格语法，揉合了 Javascript、Python、Java 等语言的相关特性。

如果之前熟悉这几门语言，可以快速入门。

2. 应知就会

2.1. 语句结束符

同 C 语言一样，Dart 所有语句都以 ; 结束。

2.2. 注释

同 Javascript，单行用 //, 多行用 /* */。

如果要支持文档生成工具，则单行注释用 ///，多行注释用 /** */, 例如：

/// This is a documentation comment

/**
  This , too,
  is a
  documentation comment.
*/

2.3. 变量声明与类型

Dart 是强类型语言，即所有变量都是有类型的。

同 C 语言一样，可以在声明变量时指定类型 <specific_type> variable; ，如：

int a = 3;

也可以同 Javascript 中一样，用 var a = 3; 声明，此时 Dart 会从赋值语句的右值推导出变量的类型，如本例中将推导出 a 变量是 int 型。
那么之后该变量的类型就确定了，不能再赋值其它类型的值了，例如本例中再给 a 赋值字符串值编译会通不过： a = "String Value";。

如果将变量声明为 dynamic 类型，那么当变量赋值为一个类型的值后，可随时再次赋值为其它类型的值，如：

dynamic x = 42;
x = "Hello World";

同 Java 一样， Dart 中的一切都是对象，都最终继承自 Object 类，因此将变量声明为 Object 类型类似于声明为 dynamic 类型，可以赋值任何类型的值，如：

Object x = 42;
x = "Hello World";

两都区别是： dynamic 类型告诉 Dart 不要查检变量的类型，即关闭类型检测功能，因此若引用 dynamic 变量上不存在的方法时，编译是能通过的，但在运行时出错; 而引用
Object 类上不存在的方法时，编译就不能通过。

2.4. 常量和 final 值

同 Java 类似，常量值用 const 修饰，常量值在编译时就被确定，不能修改，如：

const x = "Hello";
const String y = "world";

而 final 变量可以在运行时赋值，但只能赋值一次，例如想确定程序启动时间值，可以声明为一个 final 变量，如：

final x = DateTime.now();

const 不仅能修饰变量，也可以修饰值，如：

List lst = const [1, 2, 3];
lst[0] = 999; // compile error

2.5. 类型

基本类似用小写开头，如 int, double, num, bool, 其中 num 是 int, double 的父类。其它类型以大写开头，如 String, List, Map。

2.5.1. 数字型

同 C 一样，int, double, num 都支持 +, -, *, /, %。数字型唯一特殊的操作符是 ~/，表示返回除法结果的整数部分，功能同 Python 中的 // 操作符，如：

int x = 3;
double y = 2.0;
x = x ~/ y;
print(x); // 1

同 C 中一样，dart 中 x = x + y 也可以缩写为 x += y，这种缩写同样适用于 -, *, /, % 和 ~/ 操作符，如 x = x ~/ y 可写为 x ~/= y。

也有 C 中类似的 v++, ++v, v--, --v 等前后缀操作符及三元条件表达式如： x = a ? b : c。

Dart 中还支持一种特有的二元条件表达式，如 x = a ?? b;，表示当 a 有值时（即不为 null 值，声明的变量未初始化时值默认为 null)，x 赋值为 a，否则赋值为 b。

2.5.2. 字符串型 String

同 Javascript 中类似，字符串即可以用单引号 ‘xxx‘，也可以用双引号 "xxx" 表示。字符串中若包含 ${val} 形式的变量引用，则生成的字符串结果中会自动用变量值进行替换，这是一种很方便的功能，如：

String name = "Haiiiiiyun";
String greeting = "Hello ${name}"; // Hello Haiiiiiyun
String greeting = "Hello $name"; // 也可省略 {}，直接用 $var

字符串与数字间可进行相互转换，如：

int i = 42;
double d = 4.2;
String si = i.toString(); // "42"
String sd = d.toString(); // "4.2";

int i2 = int.parse(si); // 42
double d2 = double.parse(sd); // 4.2

2.5.3. 布尔型 bool

只有 true 和 false 两个值，注意，在 if while 等条件判断表达式的值不能隐匿转换成 bool 类型值，这和一般的语言都不同，例如：

if (1) { // 
    print("true");
}

不能编译通过，因为 1 不能转换成 bool 型值 true。

2.5.4. 枚举型 Enum

类型 C，可用 enum 定义枚举类型，如： enum Week{ Mon, Tue, Wed, Thu, Fri, Sat, Sun };。

其每个值都有一个 index 值，如 Week.Mon.index 的值为 0，Week.Tue.index 值为 1，以此类推。枚举值适用于 switch 语句。

2.5.5. List

List 类似 Javascript 中的数组，它是有序的，因此有 indexOf 方法，操作有：

List lst = [‘a‘, ‘b‘, ‘c‘];
lst.add(‘d‘); // [‘a‘, ‘b‘, ‘c‘, ‘d‘]
lst.removeLast(); // [‘a‘, ‘b‘, ‘c‘]
print(lst.indexOf(‘a‘)); // 0

Set 和 Python 中的 Set 类似，是无序数组，且其中的元素不会重复：

Set chars = Set();
chars.addAll([ "a", "b", "c" ]);
chars.add("a"); // 还是 ["a", "b", "c"]
chars.remove("b"); // ["a", "c"]
chars.contains("a")); // true
chars.containsAll([ "a", "b" ])); // false

2.5.6. Map

类似 Javascript 中的 dict，操作有：

Map<String, String> countries = Map();
countries[‘India‘] = "Asia";
countries["Germany"] = "Asia"; // wrong
countries["France"] = "Europe";
countries["Brazil"] = "South America";

if (countries.containsKey("Germany")) {
    countries["Germany"] = "Europe"; // update
    print(countries); // {India: Asia, Germany: Europe, France: Europe, Brazil: South America}
}

countries.remove("Germany");
print(countries); // {India: Asia, France: Europe, Brazil: South America}

2.6. 类型测试和类型转换

用 is 关键字进行类型测试，用 as 关键字进行类型转换，如

// Pig 是 Animal 的子类

if(animal is Pig) {
    (animal as Pig).oink(); //叫声
}

2.7. 流程控制

if, else 和 C 中完全一样。条件表达式也可用 ||, && 和 ! 进行组合。

switch 也和 C 中一样。

2.8. 循环

while 和 do while 循环和 C 中完全一样。同时 continue 和 break 语句也一样使用。

2.8.1 for 循环

第一个 for 循环形式和 C 类型，如：

for (var i=0; i<10; i++){
    print(i);
}

第二个 for-in 形式适用于可迭代对象，如 List, Iterator 等：

List lst = [‘a‘, ‘b‘, ‘c‘];
for (var char in lst) {
    print(char);
}

2.9 异常处理

异常处理和 Java 类似。基类是 Error 和 Exception，若要捕获某种类型的异常，用 on <SpecificException> catch(e)，
若不关心捕获的异常类型，直接用 catch(e)，而 finally 段中的代码不管有没有异常捕获到最会最后执行，如：

try {
    somethingThatMightThrowAnException();
} on FormatException catch (fe) {
    print(fe);
} on Exception catch (e) {
    Print("Some other Exception: " + e);
} catch (u) {
    print("Unknown exception");
} finally {
    print("All done!");
}

3. 函数与对象

Dart 中所有变量都是对象，因此函数也是对象，其类型是 Function。

函数定义同 C 中类似，如：

int add(int a, int b)
{
    return a + b;
}

即定义函数时要指定函数返回值类型，及参数的类型。如果没有指定返回值类型，默认为 void。

类似 C， main(List<String> args) 函数是程序的入口函数。

3.1 命名函数参数

普通函数调用时，其参数值由其位置确定，如上面的函数调用：

int x = add(1, 2); // 3

命名函数参数在 {} 中指定，如：

int add2(int init, {int a, int b}){
    return init + a + b;
}

print(add2(1, b:2, a:1)); // 4

其中的命名参数值在调用时用形如 x:y 形式指定，并且参数位置与定义时的位置无关，但必须在普通位置函数值之后。

3.2. 参数默认值

可以指定命名参数的默认值，如：

int add3({int init=0, int a, int b}){
    return init+a+b;
}

print(add3(a:1, b:2)); // 3
print(add3(init:10, a:1, b:2)); // 13

3.3. 可选参数

将参数放在 [] 指定其为可选参数，在调用时可不用提供参数值，如：

String add4(int a, int b, [String c]){
    return "$c: ${a+b}";
}

main(){
    print(add(1,2));
    print(add2(1, a:1,b:2));
    print(add3(a:1, b:2));
    print(add3(init:10, a:1, b:2));

    print(add4(1,2)); // null: 3
    print(add4(1,2, "Sum")); // Sum: 3
}

3.4. 匿名函数

类似 Javascript 和 Java 中的匿名函数，创建的匿名函数可以赋值给 Function 的变量，之后该变量和普通的函数一样调用，如：

Function add5 = (int a, int b) {
    return a+b;
};

print(add5(1,2)); // 3

如果函数体如本例一样，只是一条 return 语句，则可以简写为 fat arrow 形式（和 Python lambda 函数类似)：

Function add6 = (int a, int b) => a+b;
print(add6(1,2)); // 3

3.5. 高阶函数

函数是对象，可以作为函数参数值传递。而能接受函数值作为参数的函数即为高阶函数。

例如：

Function add6 = (int a, int b) => a+b;

int operator(Function op_fun, int a, int b)
{
    return op_fun(a, b);
}

print(operator(add6, 1, 2)); //3

这里的 operator 函数即为高阶函数。

3.6. 闭包 Closure

闭包是一个特殊的函数，也叫闭包函数。其特点时：当定义闭包函数时，闭包函数将定义函数时其父作用域中的变量值都固定下来，从而当调用闭包函数时，使用的也是定义时的变量值。

这在函数里定义闭包函数时特别明显（函数体中可以定义函数），如：

Function adder(int step)
{
    return (a) => a + step;
}

var adder1 = adder(1);
print(adder1(1)); // 2

var adder10 = adder(10);
print(adder10(1)); //11

闭包函数 adder1 将 step 值固定为定义时的 1，而 adder10 将 step 值固定为 10。

4. 类与面向对象

同 Java 类似，类用 class 定义，如：

class Animal {
    int numLegs = 0;
    int numEyes = 0;

    Animal(int numLegs, int numEyes){
        this.numLegs = numLegs;
        this.numEyes = numEyes;
    }

    void eat() {
        print("Animals eat everything depending on what type it is.");
    }
}

var a1 = new Animal(4, 2);
var a2 = Animal(4, 2); // new 关键字可省略

创建类实例也用 new ClassName(arg)，其中的 new 关键字可省略，这样创建类实例和调用函数在形式上就一样了。

4.1 属性和方法

其中的 numLegs 和 numEyes 是属性，可以直接访问实例中的属性值，如：

var a1 = new Animal(4, 2);
a1.numLegs = 2;
print(a1.numLegs); //2

其中的 eat() 是方法，可以和函数调用一样调用类实例上的方法。

访问属性和方法时，如果对象为空，会抛出异常，类似 Typescript, Dart 中的 ?. 操作符用来访问对象属性时，如果对象为 null，则不访问，
从而避免了抛出异常：

var a1 = Animal(4, 2);
a1 = null;
print(a1?.numLegs); //不会抛出异常。

静态属性和静态方法都用 static 修改，它们是类级别的属性和方法，可以直接在类上访问：

class Circle {
    static const pi = 3.14;
    static void drawCicle() {
        //...
    }
}

print(Circle.pi); // 3.14
Circle.drawCicle();

4.2. 构造方法

类中和类名相同的方法是构造方法，构造方法可以有参数，例如本例中的构造方法，其功能只是设置类的各属性值，像这种构造方法在 Dart 中可以简写为：

class Animal {
    int numLegs;
    int numEyes;

    Animal(int this.numLegs, int this.numEyes);

    void eat() {
        print("Animals eat everything depending on what type it is.");
    }
}

可定义多个构造方法，方法名要么和类名 <ClassName> 相同，要么以 <ClassName>. 为前缀，例如：

class Animal {
    int numLegs = 0;
    int numEyes = 0;

    Animal(int this.numLegs, int this.numEyes); //构造方法

    Animal.namedConstructor(int this.numLegs, int this.numEyes) { //另一个构造方法
    }

    void eat() {
        print("Animals eat everything depending on what type it is.");
    }
}

4.2.1. 默认构造方法

和 C++ 类似，如果没有声明构造方法，编译器会自动生成一个无参数的默认构造方法，该默认构造方法也会调用父类的无参构造方法。

4.2.2. 构造方法不能继承

子类不能继承父类的构造方法。子类的构造方法通过 super 调用父类的构造方法，并且和 C++ 中类似，将这种父类调用放在初始化列表中，如：

class Cat extends Animal {
    Cat(): super(4,2) {
    }
}

初始化列表中的代码是最先执行的。

4.2.3. 重定向构造方法

一个构造方法通过初始化列表，只调用另一个构造方法，没有方法体，如：

class Animal {
    int numLegs = 0;
    int numEyes = 0;

    Animal(int this.numLegs, int this.numEyes); //构造方法

    Animal.cat(): this(4, 2); // 重定向构造方法

    void eat() {
        print("Animals eat everything depending on what type it is.");
    }
}

4.2.4. getter 和 setter

import ‘dart:math‘;

class Square {
    double width;

    
    Square(this.width);

    double get area => width * width;

    set area(inArea) => width = sqrt(inArea);
}

var s = Square(5);
print(s.area); // 25.0

s.area = 16;
print(s.width); // 4.0

用 get 关键字设置 getter, 用 set 关键字设置 setter。

4.3. 子类

和 Java 一样，生成子类的语法是 class SubClass extends SuperClass {}。
Dart 不支持多重继承，只能 extends 自一个父类。

4.4. 抽象类

类似 Java, 抽象类用 abstract 修饰，抽象类中可以只声明方法，也可以有默认的实现：

abstract class Shape {
    double area(); //只有声明

    void draw(){ //有默认实现体
        print("draw here");
    }
}

抽象类不能实例化。

4.4. 接口 interface

Dart 中类与接口不分，普通类和抽象类都是接口。类不能多重继承，但可以实现多个接口，用 implements 关键字，多个接口用 , 分隔，如：

abstract class Shape {
    double area(); //只有声明

    void draw(){ //有默认实现体
        print("draw here");
    }
}

class Circle implements Shape {

    @override
    double area(){
    }

    @override
    void draw(){ //有默认实现体
        print("draw here");
    }
}

如果用 implements 实现接口，则必须实现(重写)接口中的全部方法和属性，不管接口中有没有默认实现。

4.6. mixin

mixin 是实现代码复用的一种方式。

Dart 中类与mixin不分，普通类和抽象类都是mixin。类不能多重继承，但可以引入多个mixin，用 with 关键字，多个mixin用 , 分隔，如：

class Shape {
    double area() {
    }

    void draw(){
        print("draw here");
    }
}

class Circle with Shape {
}

var c = Circle();
c.draw();

同接口不同，子类无需实现 mixin 中已实现了的方法。

4.7. 特殊方法

4.7.1 call()

如果类中实现了 call 方法，则类实例可以像函数一样调用，而实际上执行的就是实例中的 call(...) 方法，如：

class CallableClassWithoutArgument {
    String output = "Callable class";

    void call() {
        print(output);
    }
}

class CallableClassWithArgument {
    call(String name) => print("$name");
}

var withoutArgument = CallableClassWithoutArgument();
withoutArgument(); // Callable class

var withArgument = CallableClassWithArgument();
print(withArgument("John Smith")); //  John Smith

4.7.2 操作符重载方法

Dart 类中可以重载以下操作符：<, >, <=, >=, -, +, /, ~/, *, %, |, ^, &, <<, >>, [], []=, ~, ==。

重载方法是在类中实现 operator 及操作符号为名的方法，例如：

class MyNumber {
    num val;
    num operator + (num n) => val * n;
    MyNumber(this.val);
}

MyNumber mn = MyNumber(5);
print(mn+2); // 10

这里，将 + 功能重载为乘法功能。

5. 包

每个 dart 文件都是一个包 package。

用 import ‘URL‘ 的形式导入其它包，其中的 URL 的形式为 schema:path， schema 的值有：

dart: Dart 内置的包，如 import ‘dart:math‘
package: 第三方包，如 import ‘package:flutter/material.dart‘
没有 schame部分：表示只导入当前项目中的相关包，如 import ‘NotesModel.dart‘

可以用 show 关键字限定只导入包中相关属性，如 import "NotesModel.dart" show NotesModel, notesModel;。
也可以用 hide 关键字限定只排除包中相关属性，其它属性都导入，如 import "NotesModel.dart" show NotesModel, notesModel;。

如果包中的属性名有冲突，可以用 as 关键字将导入的包重命名，如 import ‘dart:math‘ as math;。

资源

mryangjx

0 关注 0 粉丝 0 动态

关注关注

安科网

C 系程序员20分钟学会 Dart 语言

mryangjx

1. 概述

2. 应知就会

2.1. 语句结束符

2.2. 注释

2.3. 变量声明与类型

2.4. 常量和 final 值

2.5. 类型

2.5.1. 数字型

2.5.2. 字符串型 String

2.5.3. 布尔型 bool

2.5.4. 枚举型 Enum

2.5.5. List

2.5.6. Map

2.6. 类型测试和类型转换

2.7. 流程控制

2.8. 循环

2.8.1 for 循环

2.9 异常处理

3. 函数与对象

3.1 命名函数参数

3.2. 参数默认值

3.3. 可选参数

3.4. 匿名函数

3.5. 高阶函数

3.6. 闭包 Closure

4. 类与面向对象

4.1 属性和方法

4.2. 构造方法

4.2.1. 默认构造方法

4.2.2. 构造方法不能继承

4.2.3. 重定向构造方法

4.2.4. getter 和 setter

4.3. 子类

4.4. 抽象类

4.4. 接口 interface

4.6. mixin

4.7. 特殊方法

4.7.1 call()

4.7.2 操作符重载方法

5. 包

资源

mryangjx

mryangjx