Dart基础入门

Dart基础概念

数据类型

数值型(num)

即 64 位 int 和符合 IEEE 754 标准的 64 位

double。前者代表整数类型，而后者则是浮点数的抽象。

int

int i_ten = 1;
int i_hex = 0xEEADBEEF; 

double

double d_1 = 1.1;
double d_2 = 1.12e5;

布尔型

为了表示布尔值，Dart 使用了一种名为 bool 的类型。在 Dart 里，只有两个对象具有bool 类型：true 和 false，它们都是编译时常量。

Dart 是类型安全的，因此我们不能使用if(nonbooleanValue) 或**assert(nonbooleanValue)**之类的在 JavaScript 可以正常工作的代码，而应该显式地检查值。

如下所示，检查变量是否为 0，在 Dart 中需要显示地与 0 做比较：

// 检查是否为 0.
var number = 0;
assert(number == 0);
// assert(number); 错误

字符型

**Dart 的 String 由 UTF-16 的字符串组成。**和 JavaScript 一样，构造字符串字面量时既能使用单引号也能使用双引号，还能在字符串中嵌入变量或表达式：你可以使用 **${express}**把一个表达式的值放进字符串。而如果是一个标识符，你可以省略{}。

下面这段代码就是内嵌表达式的例子。我们把单词’cat’转成大写放入到变量 s1 的声明中：

var s = 'Gralves';
var s_upper_case = 'upperCase : ${s.toUpperCase()}'

对于多行字符串的构建，你可以通过三个单引号或三个双引号的方式声明，这与 Python 是一致的：

var multilineStr = """
第一行,
第二行
""";

集合

List与Map

其他编程语言中常见的数组和字典类型，在 Dart 中的对应实现是 List 和 Map，统称为集合类型。它们的声明和使用很简单，和 JavaScript 中的用法类似。

var arr1 = ["Tom", "Andy", "Jack"];
var arr2 = List.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) => print('${v}'));

var map1 = {"name": "Tom", 'sex': 'male'}; 
var map2 = new Map();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) => print('${k}: ${v}'));

容器里的元素也需要有类型，比如上述代码中 arr2 的类型是List，map2 的类型则为Map<String, String>。Dart 会自动根据上下文进行类型推断，所以你后续往容器内添加的元素也必须遵照这一类型。

如果编译器自动推断的类型不符合预期，我们当然可以在声明时显式地把类型标记出来，不仅可以让代码提示更友好一些，更重要的是可以让静态分析器帮忙检查字面量中的错误，解

除类型不匹配带来的安全隐患或是 Bug。以上述代码为例，如果往 arr2 集合中添加一个浮点数arr2.add(1.1)，尽管语义上合法，

但编译器会提示类型不匹配，从而导致编译失败。

和 Java 语言类似，在初始化集合实例对象时，你可以为它的类型添加约束，也可以用于后续判断集合类型。

var arr1 = <String>['Tom', 'Andy', 'Jack'];
var arr2 = new List<int>.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) => print('${v}'));
print(arr2 is List<int>); // true

var map1 = <String, String>{'name': 'Tom','sex': 'male',};
var map2 = new Map<String, String>();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) => print('${k}: ${v}')); 
print(map2 is Map<String, String>); // true

常量

• const

  • 标识变量再编译器就能确定的值

    const str = "constStr";
    

• final

  • 标识运行时可以确定的值

    int a = 10;
    int b = 1;
    final fNum = a/b;
    

---

函数(method/function)

函数是一段用来独立完成某个功能的代码,再Dart中,所有类型都是对象类型,函数也是对象,他的类型叫做Function,这意味着函数也可以被定义为变量,甚至可以被定义为参数传递给另一个函数

// 判断参数是否为0
bool isZero(int number){
	return number == 0 ;
}

// 用check函数判断整数是否为0
void printInfo (int number , Function check){
	print("$number is Zero: ${check(number)}");
}

Function f = isZero;
int x = 10;
int y = 0;
printInfo(x,f); // ==> 10 is Zero: false
printInfo(y,f); // ==> 0 is Zero: true

有时,一个函数可能需要传递多重参数, 再C++与Java中的做法是提供方法重载,但Dart认为重载会导致混乱,因此设计之初就不支持重载,而是提供了可选命名参数和可选参数

具体方法是在声明函数时:

• 给参数增加{},以paramName:value的方式指定调用参数,也就是可选命名参数.
• 给参数增加[],则意味着这些参数是可以忽略的,也就是可选参数

在使用这两种方式定义函数时，我们还可以在参数未传递时设置默认值。我以一个只有两个参数的简单函数为例，来和你说明这两种方式的具体用法：

// 要达到可选命名参数的用法，那就在定义函数的时候给参数加上 {}
void enable1Flags({bool bold, bool hidden}) => print("$bold , $hidden");
// 定义可选命名参数时增加默认值
void enable2Flags({bool bold = true, bool hidden = false}) => print("$bold ,$hidden");
// 可忽略的参数在函数定义时用 [] 符号指定
void enable3Flags(bool bold, [bool hidden]) => print("$bold ,$hidden");

// 定义可忽略参数时增加默认值
void enable4Flags(bool bold, [bool hidden = false]) => print("$bold ,$hidden");

// 可选命名参数函数调用
enable1Flags(bold: true, hidden: false); //true, false
enable1Flags(bold: true); //true, null
enable2Flags(bold: false); //false, false

// 可忽略参数函数调用
enable3Flags(true, false); //true, false
enable3Flags(true,); //true, null
enable4Flags(true); //true, false
enable4Flags(true,true); // true, true

在 Flutter 中会大量用到可选命名参数的方式

---

类(class)

类是特定类型的数据和方法的集合，也是创建对象的模板。与其他语言一样，Dart 为类概念提供了内置支持。

类的定义及初始化

Dart 是面向对象的语言，每个对象都是一个类的实例，都继承自顶层类型 Object。在Dart 中，实例变量与实例方法、类变量与类方法的声明与 Java 类似.

Dart 中并没有 public、protected、private 这些关键字，我们只要在声明变量与方法时，在前面加上“_”即可作为 private 方法使用。如果不加“_”，则默认为public。不过，“_”的限制范围并不是类访问级别的，而是库访问级别。

class Point {
	num x, y;
	static num factor = 0;
	// 语法糖，等同于在函数体内：this.x = x;this.y = y;
	Point(this.x,this.y);
	void printInfo() => print('($x, $y)');
	static void printZValue() => print('$factor');
}

var p = new Point(100,200); // new 关键字可以省略
p.printInfo(); // 输出 (100, 200);
Point.factor = 10;
Point.printZValue(); // 输出 10

有时候类的实例化需要根据参数提供多种初始化方式。除了可选命名参数和可选参数之外，Dart 还提供了命名构造函数的方式，使得类的实例化过程语义更清晰。

此外，与 C++ 类似，Dart 支持初始化列表。在构造函数的函数体真正执行之前，你还有机会给实例变量赋值，甚至重定向至另一个构造函数。

如下面实例所示，Point 类中有两个构造函数 Point.bottom 与 Point，其中：Point.bottom 将其成员变量的初始化重定向到了 Point 中，而 Point 则在初始化列表中为z 赋上了默认值 0。

class Point {
	num x, y, z;
	Point(this.x, this.y) : z = 0; // 初始化变量 z
	Point.bottom(num x) : this(x, 0); // 重定向构造函数
	void printInfo() => print('($x,$y,$z)');
} 

var p = Point.bottom(100);
p.printInfo(); // 输出 (100,0,0)

复用

在面向对象的编程语言中，将其他类的变量与方法纳入本类中进行复用的方式一般有两种：

继承父类和接口实现。

在 Dart 中，你可以对同一个父类进行继承或接口实现：

• 继承父类意味着,子类由父类派生,会自动获取父类的成员变量和方法实现,子类可以根据需要覆写构造函数及父类方法
• 接口实现则意味着,子类获取到的仅仅是接口的成员变量符号和方法符号,需要重新实现成员变量,以及方法的声明和初始化,否则编译器会报错

class Point {
  num x = 0,y = 0;
  void printInfo() => print('($x,$y)');
}

// Vector继承自Point
class Vector extends Point {
  num z = 0;
  @override
  void printInfo() =>  print('($x,$y,$z)');
}

// Coordinate 是对Point的实现
class Coordinate implements Point {
  // 成员变量需要重新声明
  num x = 0 ,y = 0;
  // 成员函数需要重新声明实现
  void printInfo() => print('($x,$y)');

  Coordinate(this.x,this.y);
}

void main(){
  var vector = new Vector();
  vector
    ..x=1
    ..y=2
    ..z=3;  // 级联运算符，等同于 xxx.x=1; xxx.y=2;xxx.z=3;
  vector.printInfo();
  // ----------------------------------
  var coordinate = new Coordinate(10,20);
  coordinate.printInfo();
}

除了继承和接口实现之外，Dart 还提供了另一种机制来实现类的复用，即“混入”（Mixin）。混入鼓励代码重用，可以被视为具有实现方法的接口。这样一来，不仅可以解决 Dart 缺少对多重继承的支持问题，还能够避免由于多重继承可能导致的歧义[^ 1]（菱形问题）。

**要使用混入，只需要 with 关键字即可。**我们来试着改造 Coordinate 的实现，把类中的变量声明和函数实现全部删掉：

class Coordinate with Point { }

void main(){
  var coordinate = new Coordinate();
  coordinate.printInfo();
  print(coordinate is Point); // true
  print(coordinate is Coordinate); //true
}

---

运算符

Dart 和绝大部分编程语言的运算符一样，所以你可以用熟悉的方式去执行程序代码运算。

不过，Dart 多了几个额外的运算符，用于简化处理变量实例缺失（即 null）的情况。

?. 运算符

假设 Point 类有 printInfo() 方法，p 是 Point 的一个可能为 null 的实例。那么，p 调用成员方法的安全代码，可以简化为 p?.printInfo() ，表示 p 为 null 的时候跳过，避免抛出异常。

??= 运算符

如果 a 为 null，则给 a 赋值 value，否则跳过。这种用默认值兜底的赋值语句在 Dart 中我们可以用 a ??= value 表示。

?? 运算符

如果 a 为 null，则给 a 赋值 value，否则跳过。这种用默认值兜底的赋值语句在 Dart 中我们可以用 a ??= value 表示。**??**运算符：如果 a 不为 null，返回 a 的值，否则返回 b。在 Java 或者 C++ 中，我们需要通过三元表达式 (a != null)? a : b 来实现这种情况。而在 Dart 中，这类代码可以简化为 a ?? b。

---

在 Dart 中，一切都是对象，就连运算符也是对象成员函数的一部分。

对于系统的运算符，一般情况下只支持基本数据类型和标准库中提供的类型。而对于用户自定义的类，如果想支持基本操作，比如比较大小、相加相减等，则需要用户自己来定义关于这个运算符的具体实现。

Dart 提供了类似 C++ 的运算符覆写机制，使得我们不仅可以覆写方法，还可以覆写或者自定义运算符。

class Vector{
  num x, y;
  Vector(this.x,this.y);
  // 自定义加号运算符,实现向量相加
  Vector operator +(Vector v) => Vector(x+v.x,y+v.y);
  // 覆盖相等运算符,判断向量相等
  bool operator == (dynamic v) => x==v.x&&y==v.y;
}


void main(){ 
  final x = Vector(3,3);
  final y = Vector(2,2);
  final z = Vector(1,1);
  print(x==(y+z));
}

[^ 1]: 继承歧义，也叫菱形问题，是支持多继承的编程语言中一个相当棘手的问题。当 B 类和 C 类继承自 A 类，而 D 类继承自 B 类和 C 类时会产生歧义。如果 A 中有一个方法在 B 和 C 中已经覆写，而 D 没有覆写它，那么 D继承的方法的版本是 B 类，还是 C 类的呢?