xinyin025/CategoryResourceRepost
1
0
Fork 0
mirror of https://github.com/cheetahlou/CategoryResourceRepost.git synced 2025-11-16 14:13:46 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

mod

Browse Source
This commit is contained in:
louzefeng
2024-07-11 05:50:32 +00:00
parent bf99793fd0
commit d3828a7aee
6071 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
极客时间专栏/Flutter核心技术与实战/Dart语言基础/06 | 基础语法与类型变量：Dart是如何表示信息的？.md Normal file
View File

@@ -0,0 +1,198 @@
<audio id="audio" title="06 | 基础语法与类型变量：Dart是如何表示信息的？" controls="" preload="none"><source id="mp3" src="https://static001.geekbang.org/resource/audio/8f/ed/8ff65be9ccafd9ee7e4e4f05ae7dd2ed.mp3"></audio>
你好，我是陈航。
在专栏的第2篇预习文章“[Dart语言概览](https://time.geekbang.org/column/article/104071)”中，我们简单地认识了Dart这门优秀的程序语言。那么，Dart与其他语言究竟有什么不同呢？在已有其他编程语言经验的基础上，我又如何快速上手呢？
今天，我们就从编程语言中最重要的组成部分，也就是基础语法与类型变量出发，一起来学习Dart吧。
## Dart初体验
为了简单地体验一下Dart，我们打开浏览器，直接在[repl.it](https://repl.it/languages/dart) 新建一个main.dart文件就可以了（当然，你也可以在电脑安装Dart SDK，体验最新的语法）。
下面是一个基本的hello world示例，我声明了一个带int参数的函数，并通过字符串内嵌表达式的方式把这个参数打印出来：
```
printInteger(int a) {
print('Hello world, this is $a.');
}
main() {
var number = 2019;
printInteger(number);
}
```
然后，在编辑器中点击“run”按钮，命令行就会输出：
```
Hello world, this is 2019.
```
和绝大多数编译型语言一样，Dart要求以main函数作为执行的入口。
在知道了如何简单地运行Dart代码后，我们再来看一下Dart的基本变量类型。
## Dart的变量与类型
在Dart中，我们可以用var或者具体的类型来声明一个变量。当使用var定义变量时，表示类型是交由编译器推断决定的，当然你也可以用静态类型去定义变量，更清楚地跟编译器表达你的意图，这样编辑器和编译器就能使用这些静态类型，向你提供代码补全或编译警告的提示了。
在默认情况下，未初始化的变量的值都是null，因此我们不用担心无法判定一个传递过来的、未定义变量到底是undefined，还是烫烫烫而写一堆冗长的判断语句了。
Dart是类型安全的语言，并且所有类型都是对象类型，都继承自顶层类型Object，因此一切变量的值都是类的实例（即对象），甚至数字、布尔值、函数和null也都是继承自Object的对象。
Dart内置了一些基本类型，如 num、bool、String、List和Map，在不引入其他库的情况下可以使用它们去声明变量。下面，我将逐一和你介绍。
### num、bool与String
作为编程语言中最常用的类型，num、bool、String这三种基本类型被我放到了一起来介绍。
**Dart的数值类型num，只有两种子类**：即64位int和符合IEEE 754标准的64位double。前者代表整数类型，而后者则是浮点数的抽象。在正常情况下，它们的精度与取值范围就足够满足我们的诉求了。
```
int x = 1;
int hex = 0xEEADBEEF;
double y = 1.1;
double exponents = 1.13e5;
int roundY = y.round();
```
除了常见的基本运算符，比如+、-、*、/，以及位运算符外，你还能使用继承自num的 abs()、round()等方法，来实现求绝对值、取整的功能。
实际上，你打开官方文档或查看源码，就会发现这些常见的运算符也是继承自num：
<img src="https://static001.geekbang.org/resource/image/37/10/37958a8f0953edace700f29c0f820d10.png" alt="">
如果还有其他高级运算方法的需求num无法满足，你可以试用一下dart:math库。这个库提供了诸如三角函数、指数、对数、平方根等高级函数。
**为了表示布尔值，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 = 'cat';
var s1 = 'this is a uppercased string: ${s.toUpperCase()}';
```
为了获得内嵌对象的字符串，Dart会调用对象的**toString()**方法。而常见字符串的拼接，Dart则通过内置运算符“+”实现。比如，下面这条语句会如你所愿声明一个值为’Hello World!'的字符串：
```
var s2 = 'Hello' + ' ' + 'World!' ;
```
对于多行字符串的构建，你可以通过三个单引号或三个双引号的方式声明，这与Python是一致的：
```
var s3 = &quot;&quot;&quot;This is a
multi-line string.&quot;&quot;&quot;;
```
### List与Map
其他编程语言中常见的数组和字典类型，在Dart中的对应实现是List和Map，统称为集合类型。它们的声明和使用很简单，和JavaScript中的用法类似。
接下来，我们一起看一段代码示例。
- 在代码示例的前半部分，我们声明并初始化了两个List变量，在第二个变量中添加了一个新的元素后，调用其迭代方法依次打印出其内部元素；
- 在代码示例的后半部分，我们声明并初始化了两个Map变量，在第二个变量中添加了两个键值对后，同样调用其迭代方法依次打印出其内部元素。
```
var arr1 = [&quot;Tom&quot;, &quot;Andy&quot;, &quot;Jack&quot;];
var arr2 = List.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) =&gt; print('${v}'));
var map1 = {&quot;name&quot;: &quot;Tom&quot;, 'sex': 'male'};
var map2 = new Map();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) =&gt; print('${k}: ${v}'));
```
容器里的元素也需要有类型，比如上述代码中arr2的类型是**List&lt;int&gt;**，map2的类型则为**Map&lt;String, String&gt;**。Dart会自动根据上下文进行类型推断，所以你后续往容器内添加的元素也必须遵照这一类型。
如果编译器自动推断的类型不符合预期，我们当然可以在声明时显式地把类型标记出来，不仅可以让代码提示更友好一些，更重要的是可以让静态分析器帮忙检查字面量中的错误，解除类型不匹配带来的安全隐患或是Bug。
以上述代码为例，如果往arr2集合中添加一个浮点数**arr2.add(1.1)**，尽管语义上合法，但编译器会提示类型不匹配，从而导致编译失败。
和Java语言类似，在初始化集合实例对象时，你可以为它的类型添加约束，也可以用于后续判断集合类型。
下面的这段代码，在增加了类型约束后，语义是不是更清晰了？
```
var arr1 = &lt;String&gt;['Tom', 'Andy', 'Jack'];
var arr2 = new List&lt;int&gt;.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) =&gt; print('${v}'));
print(arr2 is List&lt;int&gt;); // true
var map1 = &lt;String, String&gt;{'name': 'Tom','sex': 'male',};
var map2 = new Map&lt;String, String&gt;();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) =&gt; print('${k}: ${v}'));
print(map2 is Map&lt;String, String&gt;); // true
```
### 常量定义
如果你想定义不可变的变量，则需要在定义变量前加上final或const关键字：
- const，表示变量在编译期间即能确定的值；
- final则不太一样，用它定义的变量可以在运行时确定值，而一旦确定后就不可再变。
声明const常量与final常量的典型例子，如下所示：
```
final name = 'Andy';
const count = 3;
var x = 70;
var y = 30;
final z = x / y;
```
可以看到，const适用于定义编译常量（字面量固定值）的场景，而final适用于定义运行时常量的场景。
## 总结
通过上面的介绍，相信你已经对Dart的基本语法和类型系统有了一个初步的印象。这些初步的印象，有助于你理解Dart语言设计的基本思路，在已有编程语言经验的基础上快速上手。
而对于流程控制语法：如**if-else、for**、**while**、**do-while**、**break/continue、switch-case、assert**，由于与其他编程语言类似，在这里我就不做一一介绍了，更多的Dart语言特性需要你在后续的使用过程中慢慢学习。在我们使用Dart的过程中，[官方文档](https://api.dartlang.org/stable/2.2.0/index.html)是我们最重要的学习参考资料。
恭喜你！你现在已经迈出了Dart语言学习的第一步。接下来，我们简单回顾一下今天的内容，以便加深记忆与理解：
- 在Dart中，所有类型都是对象类型，都继承自顶层类型Object，因此一切变量都是对象，数字、布尔值、函数和null也概莫能外；
- 未初始化变量的值都是null；
- 为变量指定类型，这样编辑器和编译器都能更好地理解你的意图。
## 思考题
对于集合类型List和Map，如何让其内部元素支持多种类型（比如，int、double）呢？又如何在遍历集合时，判断究竟是何种类型呢？
欢迎你在评论区给我留言分享你的观点，我会在下一篇文章中等待你！感谢你的收听，也欢迎你把这篇文章分享给更多的朋友一起阅读。

296
极客时间专栏/Flutter核心技术与实战/Dart语言基础/07 | 函数、类与运算符：Dart是如何处理信息的？.md Normal file
View File

@@ -0,0 +1,296 @@
<audio id="audio" title="07 | 函数、类与运算符：Dart是如何处理信息的？" controls="" preload="none"><source id="mp3" src="https://static001.geekbang.org/resource/audio/d9/e4/d9153ed46a16a27cd45bf149a2a020e4.mp3"></audio>
你好，我是陈航。
在上一篇文章中，我通过一个基本hello word的示例，带你体验了Dart的基础语法与类型变量，并与其他编程语言的特性进行对比，希望可以帮助你快速建立起对Dart的初步印象。
其实，编程语言虽然千差万别，但归根结底，它们的设计思想无非就是回答两个问题：
- 如何表示信息；
- 如何处理信息。
在上一篇文章中，我们已经解决了Dart如何表示信息的问题，今天这篇文章我就着重和你分享它是如何处理信息的。
作为一门真正面向对象的编程语言，Dart将处理信息的过程抽象为了对象，以结构化的方式将功能分解，而函数、类与运算符就是抽象中最重要的手段。
接下来，我就从函数、类与运算符的角度，来进一步和你讲述Dart面向对象设计的基本思路。
## 函数
函数是一段用来独立地完成某个功能的代码。我在上一篇文章中和你提到，在Dart中，所有类型都是对象类型，函数也是对象，它的类型叫作Function。这意味着函数也可以被定义为变量，甚至可以被定义为参数传递给另一个函数。
在下面这段代码示例中，我定义了一个判断整数是否为0的isZero函数，并把它传递了给另一个printInfo函数，完成格式化打印出判断结果的功能。
```
bool isZero(int number) { //判断整数是否为0
return number == 0;
}
void printInfo(int number,Function check) { //用check函数来判断整数是否为0
print(&quot;$number is Zero: ${check(number)}&quot;);
}
Function f = isZero;
int x = 10;
int y = 0;
printInfo(x,f); // 输出 10 is Zero: false
printInfo(y,f); // 输出 0 is Zero: true
```
如果函数体只有一行表达式，就比如上面示例中的isZero和printInfo函数，我们还可以像JavaScript语言那样用箭头函数来简化这个函数：
```
bool isZero(int number) =&gt; number == 0;
void printInfo(int number,Function check) =&gt; print(&quot;$number is Zero: ${check(number)}&quot;);
```
有时，一个函数中可能需要传递多个参数。那么，如何让这类函数的参数声明变得更加优雅、可维护，同时降低调用者的使用成本呢？
C++与Java的做法是，提供函数的重载，即提供同名但参数不同的函数。但**Dart认为重载会导致混乱，因此从设计之初就不支持重载，而是提供了可选命名参数和可选参数**。
具体方式是，在声明函数时：
- 给参数增加{}，以paramName: value的方式指定调用参数，也就是可选命名参数；
- 给参数增加[]，则意味着这些参数是可以忽略的，也就是可选参数。
在使用这两种方式定义函数时，我们还可以在参数未传递时设置默认值。我以一个只有两个参数的简单函数为例，来和你说明这两种方式的具体用法：
```
//要达到可选命名参数的用法，那就在定义函数的时候给参数加上 {}
void enable1Flags({bool bold, bool hidden}) =&gt; print(&quot;$bold , $hidden&quot;);
//定义可选命名参数时增加默认值
void enable2Flags({bool bold = true, bool hidden = false}) =&gt; print(&quot;$bold ,$hidden&quot;);
//可忽略的参数在函数定义时用[]符号指定
void enable3Flags(bool bold, [bool hidden]) =&gt; print(&quot;$bold ,$hidden&quot;);
//定义可忽略参数时增加默认值
void enable4Flags(bool bold, [bool hidden = false]) =&gt; print(&quot;$bold ,$hidden&quot;);
//可选命名参数函数调用
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中会大量用到可选命名参数的方式，你一定要记住它的用法。**
## 类
类是特定类型的数据和方法的集合，也是创建对象的模板。与其他语言一样，Dart为类概念提供了内置支持。
### 类的定义及初始化
Dart是面向对象的语言，每个对象都是一个类的实例，都继承自顶层类型Object。在Dart中，实例变量与实例方法、类变量与类方法的声明与Java类似，我就不再过多展开了。
值得一提的是，Dart中并没有public、protected、private这些关键字，我们只要在声明变量与方法时，在前面加上“_”即可作为private方法使用。如果不加“_”，则默认为public。不过，**“_”的限制范围并不是类访问级别的，而是库访问级别**。
接下来，我们以一个具体的案例看看**Dart是如何定义和使用类的。**
我在Point类中，定义了两个成员变量x和y，通过构造函数语法糖进行初始化，成员函数printInfo的作用是打印它们的信息；而类变量factor，则在声明时就已经赋好了默认值0，类函数printZValue会打印出它的信息。
```
class Point {
num x, y;
static num factor = 0;
//语法糖，等同于在函数体内：this.x = x;this.y = y;
Point(this.x,this.y);
void printInfo() =&gt; print('($x, $y)');
static void printZValue() =&gt; 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() =&gt; print('($x,$y,$z)');
}
var p = Point.bottom(100);
p.printInfo(); // 输出(100,0,0)
```
### 复用
在面向对象的编程语言中，将其他类的变量与方法纳入本类中进行复用的方式一般有两种：**继承父类和接口实现**。当然，在Dart也不例外。
在Dart中，你可以对同一个父类进行继承或接口实现：
- 继承父类意味着，子类由父类派生，会自动获取父类的成员变量和方法实现，子类可以根据需要覆写构造函数及父类方法；
- 接口实现则意味着，子类获取到的仅仅是接口的成员变量符号和方法符号，需要重新实现成员变量，以及方法的声明和初始化，否则编译器会报错。
接下来，我以一个例子和你说明**在Dart中继承和接口的差别**。
Vector通过继承Point的方式增加了成员变量，并覆写了printInfo的实现；而Coordinate，则通过接口实现的方式，覆写了Point的变量定义及函数实现：
```
class Point {
num x = 0, y = 0;
void printInfo() =&gt; print('($x,$y)');
}
//Vector继承自Point
class Vector extends Point{
num z = 0;
@override
void printInfo() =&gt; print('($x,$y,$z)'); //覆写了printInfo实现
}
//Coordinate是对Point的接口实现
class Coordinate implements Point {
num x = 0, y = 0; //成员变量需要重新声明
void printInfo() =&gt; print('($x,$y)'); //成员函数需要重新声明实现
}
var xxx = Vector();
xxx
..x = 1
..y = 2
..z = 3; //级联运算符，等同于xxx.x=1; xxx.y=2;xxx.z=3;
xxx.printInfo(); //输出(1,2,3)
var yyy = Coordinate();
yyy
..x = 1
..y = 2; //级联运算符，等同于yyy.x=1; yyy.y=2;
yyy.printInfo(); //输出(1,2)
print (yyy is Point); //true
print(yyy is Coordinate); //true
```
可以看出，子类Coordinate采用接口实现的方式，仅仅是获取到了父类Point的一个“空壳子”，只能从语义层面当成接口Point来用，但并不能复用Point的原有实现。那么，**我们是否能够找到方法去复用Point的对应方法实现呢？**
也许你很快就想到了，我可以让Coordinate继承Point，来复用其对应的方法。但，如果Coordinate还有其他的父类，我们又该如何处理呢？
其实，**除了继承和接口实现之外，Dart还提供了另一种机制来实现类的复用，即“混入”（Mixin）**。混入鼓励代码重用，可以被视为具有实现方法的接口。这样一来，不仅可以解决Dart缺少对多重继承的支持问题，还能够避免由于多重继承可能导致的歧义（菱形问题）。
>
备注：继承歧义，也叫菱形问题，是支持多继承的编程语言中一个相当棘手的问题。当B类和C类继承自A类，而D类继承自B类和C类时会产生歧义。如果A中有一个方法在B和C中已经覆写，而D没有覆写它，那么D继承的方法的版本是B类，还是C类的呢？
**要使用混入，只需要with关键字即可。**我们来试着改造Coordinate的实现，把类中的变量声明和函数实现全部删掉：
```
class Coordinate with Point {
}
var yyy = Coordinate();
print (yyy is Point); //true
print(yyy 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的值，否则返回b。在Java或者C++中，我们需要通过三元表达式(a != null)? a : b来实现这种情况。而在Dart中，这类代码可以简化为a ?? b。
**在Dart中，一切都是对象，就连运算符也是对象成员函数的一部分。**
对于系统的运算符，一般情况下只支持基本数据类型和标准库中提供的类型。而对于用户自定义的类，如果想支持基本操作，比如比较大小、相加相减等，则需要用户自己来定义关于这个运算符的具体实现。
**Dart提供了类似C++的运算符覆写机制**，使得我们不仅可以覆写方法，还可以覆写或者自定义运算符。
接下来，我们一起看一个Vector类中自定义“+”运算符和覆写"=="运算符的例子：
```
class Vector {
num x, y;
Vector(this.x, this.y);
// 自定义相加运算符，实现向量相加
Vector operator +(Vector v) =&gt; Vector(x + v.x, y + v.y);
// 覆写相等运算符，判断向量相等
bool operator == (dynamic v) =&gt; x == v.x &amp;&amp; y == v.y;
}
final x = Vector(3, 3);
final y = Vector(2, 2);
final z = Vector(1, 1);
print(x == (y + z)); // 输出true
```
operator是Dart的关键字，与运算符一起使用，表示一个类成员运算符函数。在理解时，我们应该把operator和运算符作为整体，看作是一个成员函数名。
## 总结
函数、类与运算符是Dart处理信息的抽象手段。从今天的学习中你可以发现，Dart面向对象的设计吸纳了其他编程语言的优点，表达和处理信息的方式既简单又简洁，但又不失强大。
通过这两篇文章的内容，相信你已经了解了Dart的基本设计思路，熟悉了在Flutter开发中常用的语法特性，也已经具备了快速上手实践的能力。
接下来，我们简单回顾一下今天的内容，以便加深记忆与理解。
首先，我们认识了函数。函数也是对象，可以被定义为变量，或者参数。Dart不支持函数重载，但提供了可选命名参数和可选参数的方式，从而解决了函数声明时需要传递多个参数的可维护性。
然后，我带你学习了类。类提供了数据和函数的抽象复用能力，可以通过继承（父类继承，接口实现）和非继承（Mixin）方式实现复用。在类的内部，关于成员变量，Dart提供了包括命名构造函数和初始化列表在内的两种初始化方式。
最后，需要注意的是，运算符也是对象成员函数的一部分，可以覆写或者自定义。
## 思考题
最后，请你思考以下两个问题。
1. 你是怎样理解父类继承，接口实现和混入的？我们应该在什么场景下使用它们？
1. 在父类继承的场景中，父类子类之间的构造函数执行顺序是怎样的？如果父类有多个构造函数，子类也有多个构造函数，如何从代码层面确保父类子类之间构造函数的正确调用？
```
class Point {
num x, y;
Point() : this.make(0,0);
Point.left(x) : this.make(x,0);
Point.right(y) : this.make(0,y);
Point.make(this.x, this.y);
void printInfo() =&gt; print('($x,$y)');
}
class Vector extends Point{
num z = 0;
/*5个构造函数
Vector
Vector.left;
Vector.middle
Vector.right
Vector.make
*/
@override
void printInfo() =&gt; print('($x,$y,$z)'); //覆写了printInfo实现
}
```
欢迎将你的答案留言告诉我，我们一起讨论。感谢你的收听，也欢迎你把这篇文章分享给更多的朋友一起阅读。

388
极客时间专栏/Flutter核心技术与实战/Dart语言基础/08 | 综合案例：掌握Dart核心特性.md Normal file
View File

@@ -0,0 +1,388 @@
<audio id="audio" title="08 | 综合案例：掌握Dart核心特性" controls="" preload="none"><source id="mp3" src="https://static001.geekbang.org/resource/audio/a5/b4/a59217af6d166c81eb955952c68988b4.mp3"></audio>
你好，我是陈航。
在前两篇文章中，我首先与你一起学习了Dart程序的基本结构和语法，认识了Dart语言世界的基本构成要素，也就是类型系统，以及它们是怎么表示信息的。然后，我带你学习了Dart面向对象设计的基本思路，知道了函数、类与运算符这些其他编程语言中常见的概念，在Dart中的差异及典型用法，理解了Dart是怎么处理信息的。
可以看到，Dart吸纳了其他编程语言的优点，在关于如何表达以及处理信息上，既简单又简洁，而且又不失强大。俗话说，纸上得来终觉浅，绝知此事要躬行。那么今天，我就用一个综合案例，把前面学习的关于Dart的零散知识串起来，希望你可以动手试验一下这个案例，借此掌握如何用Dart编程。
有了前面学习的知识点，再加上今天的综合案例练习，我认为你已经掌握了Dart最常用的80%的特性，可以在基本没有语言障碍的情况下去使用Flutter了。至于剩下的那20%的特性，因为使用较少，所以我不会在本专栏做重点讲解。如果你对这部分内容感兴趣的话，可以访问[官方文档](https://dart.dev/tutorials)去做进一步了解。
此外，关于Dart中的异步和并发，我会在后面的第23篇文章“单线程模型怎么保证UI运行流畅？”中进行深入介绍。
## 案例介绍
今天，我选择的案例是，先用Dart写一段购物车程序，但先不使用Dart独有的特性。然后，我们再以这段程序为起点，逐步加入Dart语言特性，将其改造为一个符合Dart设计思想的程序。你可以在这个改造过程中，进一步体会到Dart的魅力所在。
首先，我们来看看在不使用任何Dart语法特性的情况下，一个有着基本功能的购物车程序长什么样子。
```
//定义商品Item类
class Item {
double price;
String name;
Item(name, price) {
this.name = name;
this.price = price;
}
}
//定义购物车类
class ShoppingCart {
String name;
DateTime date;
String code;
List&lt;Item&gt; bookings;
price() {
double sum = 0.0;
for(var i in bookings) {
sum += i.price;
}
return sum;
}
ShoppingCart(name, code) {
this.name = name;
this.code = code;
this.date = DateTime.now();
}
getInfo() {
return '购物车信息:' +
'\n-----------------------------' +
'\n用户名: ' + name+
'\n优惠码: ' + code +
'\n总价: ' + price().toString() +
'\n日期: ' + date.toString() +
'\n-----------------------------';
}
}
void main() {
ShoppingCart sc = ShoppingCart('张三', '123456');
sc.bookings = [Item('苹果',10.0), Item('鸭梨',20.0)];
print(sc.getInfo());
}
```
在这段程序中，我定义了商品Item类，以及购物车ShoppingCart类。它们分别包含了一个初始化构造方法，将main函数传入的参数信息赋值给对象内部属性。而购物车的基本信息，则通过ShoppingCart类中的getInfo方法输出。在这个方法中，我采用字符串拼接的方式，将各类信息进行格式化组合后，返回给调用者。
运行这段程序，不出意外，购物车对象sc包括的用户名、优惠码、总价与日期在内的基本信息都会被打印到命令行中。
```
购物车信息:
-----------------------------
用户名: 张三
优惠码: 123456
总价: 30.0
日期: 2019-06-01 17:17:57.004645
-----------------------------
```
这段程序的功能非常简单：我们初始化了一个购物车对象，然后给购物车对象进行加购操作，最后打印出基本信息。可以看到，在不使用Dart语法任何特性的情况下，这段代码与Java、C++甚至JavaScript没有明显的语法差异。
在关于如何表达以及处理信息上，Dart保持了既简单又简洁的风格。那接下来，**我们就先从表达信息入手，看看Dart是如何优化这段代码的。**
## 类抽象改造
我们先来看看Item类与ShoppingCart类的初始化部分。它们在构造函数中的初始化工作，仅仅是将main函数传入的参数进行属性赋值。
在其他编程语言中，在构造函数的函数体内，将初始化参数赋值给实例变量的方式非常常见。而在Dart里，我们可以利用语法糖以及初始化列表，来简化这样的赋值过程，从而直接省去构造函数的函数体：
```
class Item {
double price;
String name;
Item(this.name, this.price);
}
class ShoppingCart {
String name;
DateTime date;
String code;
List&lt;Item&gt; bookings;
price() {...}
//删掉了构造函数函数体
ShoppingCart(this.name, this.code) : date = DateTime.now();
...
}
```
这一下就省去了7行代码！通过这次改造，我们有两个新的发现：
- 首先，Item类与ShoppingCart类中都有一个name属性，在Item中表示商品名称，在ShoppingCart中则表示用户名；
- 然后，Item类中有一个price属性，ShoppingCart中有一个price方法，它们都表示当前的价格。
考虑到name属性与price属性（方法）的名称与类型完全一致，在信息表达上的作用也几乎一致，因此我可以在这两个类的基础上，再抽象出一个新的基类Meta，用于存放price属性与name属性。
同时，考虑到在ShoppingCart类中，price属性仅用做计算购物车中商品的价格（而不是像Item类那样用于数据存取），因此在继承了Meta类后，我改写了ShoppingCart类中price属性的get方法：
```
class Meta {
double price;
String name;
Meta(this.name, this.price);
}
class Item extends Meta{
Item(name, price) : super(name, price);
}
class ShoppingCart extends Meta{
DateTime date;
String code;
List&lt;Item&gt; bookings;
double get price {...}
ShoppingCart(name, this.code) : date = DateTime.now(),super(name,0);
getInfo() {...}
}
```
通过这次类抽象改造，程序中各个类的依赖关系变得更加清晰了。不过，目前这段程序中还有两个冗长的方法显得格格不入，即ShoppingCart类中计算价格的price属性get方法，以及提供购物车基本信息的getInfo方法。接下来，我们分别来改造这两个方法。
## 方法改造
我们先看看price属性的get方法：
```
double get price {
double sum = 0.0;
for(var i in bookings) {
sum += i.price;
}
return sum;
}
```
在这个方法里，我采用了其他语言常见的求和算法，依次遍历bookings列表中的Item对象，累积相加求和。
而在Dart中，这样的求和运算我们只需重载Item类的“+”运算符，并通过对列表对象进行归纳合并操作即可实现（你可以想象成，把购物车中的所有商品都合并成了一个商品套餐对象）。
另外，由于函数体只有一行，所以我们可以使用Dart的箭头函数来进一步简化实现函数：
```
class Item extends Meta{
...
//重载了+运算符，合并商品为套餐商品
Item operator+(Item item) =&gt; Item(name + item.name, price + item.price);
}
class ShoppingCart extends Meta{
...
//把迭代求和改写为归纳合并
double get price =&gt; bookings.reduce((value, element) =&gt; value + element).price;
...
getInfo() {...}
}
```
可以看到，这段代码又简洁了很多！接下来，我们再看看getInfo方法如何优化。
在getInfo方法中，我们将ShoppingCart类的基本信息通过字符串拼接的方式，进行格式化组合，这在其他编程语言中非常常见。而在Dart中，我们可以通过对字符串插入变量或表达式，并使用多行字符串声明的方式，来完全抛弃不优雅的字符串拼接，实现字符串格式化组合。
```
getInfo () =&gt; '''
购物车信息:
-----------------------------
用户名: $name
优惠码: $code
总价: $price
Date: $date
-----------------------------
''';
```
在去掉了多余的字符串转义和拼接代码后，getInfo方法看着就清晰多了。
在优化完了ShoppingCart类与Item类的内部实现后，我们再来看看main函数，从调用方的角度去分析程序还能在哪些方面做优化。
## 对象初始化方式的优化
在main函数中，我们使用
```
ShoppingCart sc = ShoppingCart('张三', '123456') ;
```
初始化了一个使用‘123456’优惠码、名为‘张三’的用户所使用的购物车对象。而这段初始化方法的调用，我们可以从两个方面优化：
- 首先，在对ShoppingCart的构造函数进行了大量简写后，我们希望能够提供给调用者更明确的初始化方法调用方式，让调用者以“参数名:参数键值对”的方式指定调用参数，让调用者明确传递的初始化参数的意义。在Dart中，这样的需求，我们在声明函数时，可以通过给参数增加{}实现。
- 其次，对一个购物车对象来说，一定会有一个有用户名，但不一定有优惠码的用户。因此，对于购物车对象的初始化，我们还需要提供一个不含优惠码的初始化方法，并且需要确定多个初始化方法与父类的初始化方法之间的正确调用顺序。
按照这样的思路，我们开始对ShoppingCart进行改造。
需要注意的是，由于优惠码可以为空，我们还需要对getInfo方法进行兼容处理。在这里，我用到了a??b运算符，这个运算符能够大量简化在其他语言中三元表达式(a != null)? a : b的写法：
```
class ShoppingCart extends Meta{
...
//默认初始化方法，转发到withCode里
ShoppingCart({name}) : this.withCode(name:name, code:null);
//withCode初始化方法，使用语法糖和初始化列表进行赋值，并调用父类初始化方法
ShoppingCart.withCode({name, this.code}) : date = DateTime.now(), super(name,0);
//??运算符表示为code不为null，则用原值，否则使用默认值&quot;没有&quot;
getInfo () =&gt; '''
购物车信息:
-----------------------------
用户名: $name
优惠码: ${code??&quot;没有&quot;}
总价: $price
Date: $date
-----------------------------
''';
}
void main() {
ShoppingCart sc = ShoppingCart.withCode(name:'张三', code:'123456');
sc.bookings = [Item('苹果',10.0), Item('鸭梨',20.0)];
print(sc.getInfo());
ShoppingCart sc2 = ShoppingCart(name:'李四');
sc2.bookings = [Item('香蕉',15.0), Item('西瓜',40.0)];
print(sc2.getInfo());
}
```
运行这段程序，张三和李四的购物车信息都会被打印到命令行中：
```
购物车信息:
-----------------------------
用户名: 张三
优惠码: 123456
总价: 30.0
Date: 2019-06-01 19:59:30.443817
-----------------------------
购物车信息:
-----------------------------
用户名: 李四
优惠码: 没有
总价: 55.0
Date: 2019-06-01 19:59:30.451747
-----------------------------
```
关于购物车信息的打印，我们是通过在main函数中获取到购物车对象的信息后，使用全局的print函数打印的，我们希望把打印信息的行为封装到ShoppingCart类中。而对于打印信息的行为而言，这是一个非常通用的功能，不止ShoppingCart类需要，Item对象也可能需要。
因此，我们需要把打印信息的能力单独封装成一个单独的类PrintHelper。但，ShoppingCart类本身已经继承自Meta类，考虑到Dart并不支持多继承，我们怎样才能实现PrintHelper类的复用呢？
这就用到了我在上一篇文章中提到的“混入”（Mixin），相信你还记得只要在使用时加上with关键字即可。
我们来试着增加PrintHelper类，并调整ShoppingCart的声明：
```
abstract class PrintHelper {
printInfo() =&gt; print(getInfo());
getInfo();
}
class ShoppingCart extends Meta with PrintHelper{
...
}
```
经过Mixin的改造，我们终于把所有购物车的行为都封装到ShoppingCart内部了。而对于调用方而言，还可以使用级联运算符“..”，在同一个对象上连续调用多个函数以及访问成员变量。使用级联操作符可以避免创建临时变量，让代码看起来更流畅：
```
void main() {
ShoppingCart.withCode(name:'张三', code:'123456')
..bookings = [Item('苹果',10.0), Item('鸭梨',20.0)]
..printInfo();
ShoppingCart(name:'李四')
..bookings = [Item('香蕉',15.0), Item('西瓜',40.0)]
..printInfo();
}
```
很好！通过Dart独有的语法特性，我们终于把这段购物车代码改造成了简洁、直接而又强大的Dart风格程序。
## 总结
这就是今天分享的全部内容了。在今天，我们以一个与Java、C++甚至JavaScript没有明显语法差异的购物车雏形为起步，逐步将它改造成了一个符合Dart设计思想的程序。
首先，我们使用构造函数语法糖及初始化列表，简化了成员变量的赋值过程。然后，我们重载了“+”运算符，并采用归纳合并的方式实现了价格计算，并且使用多行字符串和内嵌表达式的方式，省去了无谓的字符串拼接。最后，我们重新梳理了类之间的继承关系，通过mixin、多构造函数，可选命名参数等手段，优化了对象初始化调用方式。
下面是今天购物车综合案例的完整代码，希望你在IDE中多多练习，体会这次的改造过程，从而对Dart那些使代码变得更简洁、直接而强大的关键语法特性产生更深刻的印象。同时，改造前后的代码，你也可以在GitHub的[Dart_Sample](https://github.com/cyndibaby905/08_Dart_Sample)中找到：
```
class Meta {
double price;
String name;
//成员变量初始化语法糖
Meta(this.name, this.price);
}
class Item extends Meta{
Item(name, price) : super(name, price);
//重载+运算符，将商品对象合并为套餐商品
Item operator+(Item item) =&gt; Item(name + item.name, price + item.price);
}
abstract class PrintHelper {
printInfo() =&gt; print(getInfo());
getInfo();
}
//with表示以非继承的方式复用了另一个类的成员变量及函数
class ShoppingCart extends Meta with PrintHelper{
DateTime date;
String code;
List&lt;Item&gt; bookings;
//以归纳合并方式求和
double get price =&gt; bookings.reduce((value, element) =&gt; value + element).price;
//默认初始化函数，转发至withCode函数
ShoppingCart({name}) : this.withCode(name:name, code:null);
//withCode初始化方法，使用语法糖和初始化列表进行赋值，并调用父类初始化方法
ShoppingCart.withCode({name, this.code}) : date = DateTime.now(), super(name,0);
//??运算符表示为code不为null，则用原值，否则使用默认值&quot;没有&quot;
@override
getInfo() =&gt; '''
购物车信息:
-----------------------------
用户名: $name
优惠码: ${code??&quot;没有&quot;}
总价: $price
Date: $date
-----------------------------
''';
}
void main() {
ShoppingCart.withCode(name:'张三', code:'123456')
..bookings = [Item('苹果',10.0), Item('鸭梨',20.0)]
..printInfo();
ShoppingCart(name:'李四')
..bookings = [Item('香蕉',15.0), Item('西瓜',40.0)]
..printInfo();
}
```
## 思考题
请你扩展购物车程序的实现，使得我们的购物车可以支持：
1. 商品数量属性；
1. 购物车信息增加商品列表信息（包括商品名称，数量及单价）输出，实现小票的基本功能。
欢迎你在评论区给我留言分享你的观点，我会在下一篇文章中等待你！感谢你的收听，也欢迎你把这篇文章分享给更多的朋友一起阅读。