创建用户，专门用来实现数据复制

create user replica with replication login password 'replication';

检查postgresql.conf配置文件

wal_level = replica

检查pg_hba.conf权限配置文件

建议在最后追加一行host replication replica all md5，其中all也可以替换为从库所处机器的ip地址，比如192.168.0.10/32

生成备份库

 pg_basebackup -h 192.168.0.21 -p 54321 -U replica -R -P -v -C --slot=pgstandby1 -D /Users/liurui/pg2

• -R 说明会创建standby.signal文件，以及补充postgresql.auto.conf的内容
• -P 显示备份进度
• -v 显示更加详细信息
• -C 同时创建复制槽
• --slot 指定复制槽的名字（一个备库一个名字）
• -D 生成备库的路径

复制槽的好处
主库的事务日志一直处于滚动消耗的状态，如果备库下线，随着主库频繁的数据变动，可能就会存在当备库重新上线后，已经找不到之前没有拉取的事务日志的情况（被主库回收掉了）。
但是有了复制槽，主库就会为复制槽保留它没有消费的日志，等待它上线后进行消费。当然代价是对磁盘的消耗，不过只要备库不是永久丢失，磁盘消耗对于大部分场景来说不是问题。
但是如果备库永久丢失了，要记得删除主库中对应的复制槽。删除复制槽的语句为select pg_drop_replication_slot('pgstandby1');

注意
备库的操作系统环境最好与主库一致，如果一个是Windows一个是Linux，几乎一定会遇到字符集不一致的问题，导致备库无法启动。

启动备库

pg_ctl -D /Users/liurui/pg2 start

验证流复制可用性

• 在主库进行数据变动，在备库可进行观察
• 在主库执行select * from pg_replication_slots;能够观察到复制槽
• 在主库执行select * from pg_stat_replication;可以观察到备库连接情况，只有备库上线的情况下，该查询才会返回数据
• 顺便说一下，从库的数据目录会生成名为postgresql.auto.conf的文件（对应上面的-R参数），里面存放了主库的连接信息，感兴趣的小伙伴可以观察看看，但是这个文件不建议手动编辑。
• 注意，这样创建的备库其实叫异步备库，极端情况下，备库的数据跟主库比是有一定延迟的，如果需要无延迟的备库，就需要启动同步模式，当然它会牺牲更多的性能，也要付出更高的运维成本，本文并不涉及同步模式的介绍。

如何获得指定延迟时间的备库（可选）

大部分情况下，备库与主库保持一致是我们需要的。但是有时候，我们也需要的也一个比主库有延迟的备库，比如延迟三十分钟，也就意味着，当主库的数据被不小心删除后，三十分钟内，我们都可以在备库里找到。此时需要在备库配置：

recovery_min_apply_delay = 30min

手动把备库提升为主库

备库平时只能作为只读数据库使用，因为可写数据是主库才有的特权。但是一旦主库挂掉，并且已知备库的数据足够完整的情况下，我们可以迅速把备库提升为主库。只要找到备库的文件路径，把里面的standby.signal文件删除即可。顺便说一下，这个文件是没有内容的，它是一个空文件，通过这个文件的存在来表明自己是个备库，所以删掉或者重命名该文件，都能把这个备库提升为主库。当然，别忘了删除该文件后，重启备库才能生效。

补充：在docker环境下生成备库

1. 像平常在docker使用一样，启动一个数据库，当然要注意该备库的版本与主库保持一致。一个典型的yml文件如下：

   version: '3'
   services:
    postgres15-bak:
     image: postgres:15.1
     ports:
      - 34325:5432
     volumes:
      - /root/docker/volume/postgres15:/var/lib/postgresql/data
   

2. 使用docker-compose启动该镜像后，再通过docker exec进入它

3. 切换用户：su postgres

4. 进入postgres拥有权限的路径：cd /var/lib/postgresql/data

5. 生成备库：pg_basebackup -h 192.168.0.21 -p 54321 -U replica -R -P -v -C --slot=pgstandby1 -D ./bak 此时备库路径就在/var/lib/postgresql/data/bak下

6. 退出docker，回到宿主机，并关闭刚刚使用的docker镜像

7. 在宿主机把刚才镜像映射的文件夹调整一下，以上面的yml文件为例，就应该先把/root/docker/volume/postgres15/bak文件夹拷贝出来，再把/root/docker/volume/postgres15文件夹删除掉，之后把刚拷贝出来的bak文件夹还原为/root/docker/volume/postgres15，此时该镜像映射的文件夹就是我们新产生的从库备份了。

8. 启动上面的docker镜像。则从库已经接入主库。

而把具体类型看作一枚银币的其中一面，那么另外一面就应该是“非具体类型”，或者说是泛化类型，简称范型。

不过你也不要误会，所谓泛化类型，并不是要抹除具体类型存在的意义。而是说，对于某些数据的类型，可以从编写代码阶段的明确延迟到运行阶段再明确。

这么说可能有些抽象，我们来看下苹果官方文档给出的例子：

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

这个函数的功能是交换两个Int值，同理如果想交换两个String，我们还得再写个函数：

func swapTwoStrings(_ a: inout String, _ b: inout String) {
    let temporaryA = a
    a = b
    b = temporaryA
}

以此类推，如果要交换两个Double类型还得继续写。并且你会发现，这些函数内部的逻辑就是一模一样的，唯一的区别就是接受参数的类型不同。

那么，如果我们不把参数的类型硬编码，而是也通过参数传递给函数，这样不就可以抽象出来更高级的函数代码了么？

上面这个问题的解决方案就是——泛型，我们先来看通过泛型改进过后的代码：

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

其实函数内部的逻辑代码我们一行没改，变化还是发生在函数的声明部分。这里参数a、b的类型，从之前我们熟悉的类型改成了T，需要注意的是T并不是一个类型，而是一种占位符，本质上来说它也是个参数。就像a是个占位符，也是个参数一样。

但是T参数又很特殊，它用来约定了参数a、b的类型，可以说成是参数的参数。那么既然是参数，就得需要调用者进行参数指定吧，我们是否需要明确传递参数T呢？比如这样：

var x = 1
var y = 2

swapTwoValues<Int>(&x, &y)

遗憾的是我们会收到一行报错：

error: cannot explicitly specialize a generic function

想想也是，既然我们传递a、b的值确定了，那这俩参数的Int类型也确定了，所以完全没有必要多此一举再去给T传递参数，直接简简单单这样就可以了：

swapTwoValues(&x, &y)

不过，如果当泛型作用于struct或者class时，情况就不一样了。

在计算机领域中，有一种被称作栈（Stack）的数据结构，想象一下，你桌子上有一摞书，也就是一本压着一本摆放的。显而易见，最下面那本书是你最早放置的，而最上面一本书是你最后放置的。如果你想把第一本书，也就是最下面那本书找出来，你不得不从上开始把书一本一本的拿走（假设你每次只能操纵一本书的话）。这里描述的场景就是栈，用代码模拟的话，可以这样写：

struct IntStack {
    var items: [Int] = []
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }
}

我们构造了一个IntStack用来存储Int类型的栈，它提供两个方法：push负责把数放进栈，pop负责把栈顶（也就是最上面/最后一个）取出来。

跟之前举的例子类似，如果你需要另外一个StringStack来存储String类型的栈的时候，你不得不复制大部分的代码，像下面这样：

struct StringStack {
    var items: [String] = []
    mutating func push(_ item: String) {
        items.append(item)
    }
    mutating func pop() -> String {
        return items.removeLast()
    }
}

仔细观察IntStack于StringStack代码的些许不同，不难发现问题还是出在类型上，如果Stack关注内容的类型是非硬编码的，而是通过某种手段动态指定的，那么一切的问题将迎刃而解。展现泛型威力的时候又到了：

struct Stack<T> {
    var items: [T] = []
    mutating func push(_ item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
}

这样我们就拥有了一个不拘泥于一个具体类型的Stack，如果你需要它存储String，只需要像下面这样：

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")

这里你应该发现了，参数T需要我们在实例化Stack的时候指定，并且一旦指定之后，Stack内部就已经明确了T的类型。如果我们尝试push一个Int类型的数据的话，就会收到报错：

error: cannot convert value of type 'Int' to expected argument type 'String'

讲到这，泛型的概念你应该理解的差不多了，不论是从函数调用还是从类/结构体的使用角度来看，都可以分为调用者于被调用者，而泛型的价值就是在于让调用者有更大的施展空间，也可以理解为被调用者让出了一部分权利供调用者自己发挥。

但这种权利的让渡也是有限度的，有时候被调用者虽然不再关心具体的类型，但是却希望这些类型能够局限在一个范围内，而不是完全放任自流。请看下面的例子：

func anyCommonElements<T>(_ lhs: T, _ rhs: T) -> Bool
where T:Sequence, T.Element: Equatable
{
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}

anyCommonElements([1, 2, 3], [3])

这应该算是一个比较复杂的例子了，anyCommonElements可以实现对两个序列是否相交的比较。核心逻辑就是对两个序列进行嵌套循环遍历，一旦发现元素相同，立刻return true进行返回。这个逻辑倒是不难理解，但是其针对泛型的应用，还是值得分析一下。

首先，我们是要运算的参数类型只能是支持遍历的序列，而不能是其他。所以我们要限制T泛型可用类型的范围，必须是遵循Sequence协议的。同时，既然是要比较两个序列，那么序列中的元素必须是可比较的，也就是T.Element: Equatable要求的T中元素必须满足协议Equatable。

你可能会好奇，我是怎么知道T里面有个Element的。其实查看下Sequence的文档就会发现，Sequence的声明也用到了泛型，就是下面这句：

protocol Sequence<Element>

所以Element的出处不是别的神秘物体，正是我们今天学的泛型的一种官方应用。

此时回头看上面的where T:Sequence, T.Element: Equatable语句应该清晰了，通过where我们可以对函数声明的泛型追加一些限制条件。对于T:Sequence这样直接作用于T的条件，除了写在where处，也是可以在声明T的地方设置的。所以上面方法的声明等价于下面这种写法：

func anyCommonElements<T:Sequence>(_ lhs: T, _ rhs: T) -> Bool
where T.Element: Equatable

至此，anyCommonElements可以很好的比较同一种类型的两个序列是否有交集了，像下面这样的调用都会返回true：

anyCommonElements([1,2,3], [2])
anyCommonElements(1...3, 2...2)

但是有个问题，如果我们把上面的参数交叉一下，比如像下面这样：

anyCommonElements(1...3, [2])

就会得到一个报错：

error: cannot convert value of type '[Int]' to expected argument type 'ClosedRange'

可以看出，此时函数接收到的两个参数不是同一个类型，因而报错。一个好的改进思路是，我们不再要求两个参数同属一个类型，而是允许它们各自不同，但是只需要满足Sequence即可。同时，即使两个序列的类型不同，也要保证它们内部存储的元素类型必须是相同的，不然无法直接比较。改进后的代码如下：

func anyCommonElements<T:Sequence, U:Sequence>(_ lhs: T, _ rhs: U) -> Bool
where T.Element: Equatable, T.Element == U.Element
{
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
   return false
}
anyCommonElements(1...3, [3])

至此关于泛型的基本用法就讲完了。作为本系列教程的第十讲，这里我有一个好消息和一个坏消息要告诉大家：

• 好消息是有了这十讲的技术铺垫，从语言语法层面上来说你已经具备动手进行App开发的基础了。
• 坏消息是短短十期所能阐述的知识也只能算是九牛一毛，还有很多概念我们尚未提到，留待你继续探索喽。

如果你想了解更多关于App开发的相关知识，可以关注我整理这篇帖子：从0打造一款App并上架苹果App Store我的经历与总结。

好了，关于Swift语法方面的介绍到这里就结束了，也是时候给大家说声青山不改，绿水长流，有缘江湖再见了。期待下次的重逢，也期待能在App Store里看到你提交的应用😃。

参考资料：

• https://docs.swift.org/swift-book/LanguageGuide/Generics.html
• https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

往期回顾：

• Swift 初体验（1）
• Swift 初体验（2）- 久仰大名 switch
• Swift 初体验（3）- 函数和闭包
• Swift 初体验（4）- 对象与类
• Swift 初体验（5）- 枚举
• Swift 初体验（6）- 结构体 Struct
• Swift 初体验（7）- Protocols
• Swift 初体验（8）- Extension
• Swift 初体验（9）- 错误处理

但是包括我在内的很多人，在初学编程的时候，都对错误处理的概念感到有些无所适从，并不是学不会，而是不太容易理解它存在的价值。今天咱们就来念叨下错误处理背后隐含的编程哲学问题，不过在探讨形而上的问题之前，咱们先来看看形而下的问题，到底错误处理长什么样。

想象这样一种场景，考试不及格（成绩小于60分）属于一种错误，我们可以这样定义：

struct 不及格:Error{}

这里我们定义了一个结构体，并且大大方方给它起了中文名（这样当然也是可以的，不用担心程序会报错，只是外国人不太容易看懂罢了。），同时让这个结构体实现了Error协议。这样我们就拥有了一个错误，你就可以在需要它的时候让他登场了，而“登场”就需要一个特殊的操作——throw。

比如我们有一个设置成绩的函数：

func setScore(_ score:Int) throws {
    if score < 60{
        throw 不及格()
    }
        
    print(score)
}

注意上面函数的声明处有个throws，就是为了通知要调用这个函数的代码，告诉大家“我的逻辑有风险，调用我须谨慎”。所以调用函数的代码就得加个try，像下面这样：

try setScore(90)
try setScore(0)

而如果你真的关心函数调用如果出现异常，会出现怎样的异常的话，代码还要写得再丰富些才好：

do {
    try setScore(0)
} catch is 不及格{
    print("成绩不及格")
}

上面的代码相信你都能看懂，只是可能会觉得有点奇怪，绕这么个大圈子，就是想知道成绩是不是不及格，这样的意义在哪呢？别着急，让我们丰富下我们的示例。首先我们定义一个学生：

struct Student{
    let name:String
    let score:Int
    
    init (name:String, score:Int){
        self.name = name
        self.score = score
    }
}

let 张三 = Student(name: "张三", score: 60)

这个Student有两个常量，分别存储了姓名、成绩。这次我们不关心他是不是考试及格了，我们关心这个Student的两个关键常量是否合法，比如姓名的字数应大于1，成绩不能小于0。

这次我们用enum定义错误会比之前用struct更加实用，在生产环境大家也多倾向于用enum来承载Error。

enum StudentParamError:Error{
    case nameTooShort //姓名太短
    case nameTooLong //姓名太长
    case scoreIsNegative //得分是负数
    case scoreOver100 //得分大于100
}

现在我们改进下Student的构造函数（init）：

init (name:String, score:Int) throws{
    if name.count <= 1 {
        throw StudentParamError.nameTooShort
    }
    
    if name.count > 4 {
        throw StudentParamError.nameTooLong
    }
    
    if score < 0 {
        throw StudentParamError.scoreIsNegative
    }

    if score > 100 {
        throw StudentParamError.scoreOver100
    }

    self.name = name
    self.score = score
}

这样我们以后就可以安全的创建Student了，因为万一提供给它的参数有问题，它都可以自我审查，有问题及时抛出，而不需要我们在外围代码进行额外判断了。当然如果你关心Student创建失败的原因，还是要用上面介绍方法去对错误进行catch比较：

var zhangsan:Student?

do{
    zhangsan = try Student(name: "张三", score: 101)
}catch StudentParamError.nameTooShort{
    print("姓名太短")
}catch StudentParamError.nameTooLong{
    print("姓名太长")
}catch StudentParamError.scoreOver100{
    print("成绩大于100")
}catch StudentParamError.scoreIsNegative{
    print("成绩是负数")
}catch{
    print("其他未知问题")
}

或者你只关心宏观上是不是参数问题导致的，可以把上面的代码简化一下：

var zhangsan:Student?

do{
    zhangsan = try Student(name: "张三", score: 101)
}catch is StudentParamError{
    print("参数有误")
}catch{
    print("其他未知问题")
}

当然，还有一种情况也是最常见的情况，我不关心具体错误，我现在就要张三现在出来，立刻、马上：

let zhangsan = try? Student(name: "张三", score: 101)

此时zhangsan的类型就变成可选类型了。如果参数有误或者其他什么原因，构造张三的过程中报错了，那么你将得到一个nil，否则就会把一个完完整整的张三交到你手上。

错误处理是有一种传递机制在里面的，在一个函数内部调用其他有潜在风险的代码，你将有两种选择，一种是我不处理错误，我只传递风险，就像下面的代码：

func hello() throws{
    let zhangsan = try Student(name: "张三", score: 101)
    print("\(zhangsan.name)，你好")
}

另一种就是我会把风险扼杀在摇篮里，不去打扰调用我的人：

func hello() {
    let zhangsan = try? Student(name: "张三", score: 101)
    if let zhangsan = zhangsan{
        print("\(zhangsan.name)，你好")
    }
}

你能猜到这两种写法对调用者来说最大的区别是什么么？答案是：try hello()与hello()。因为前者并没有规避风险，所以hello函数也是用throws标记了的，因而要调用它的地方，必须加上try以示对风险的重视。而后者的hello函数就很普通，因此也就可以被普普通通的调用。

关于错误处理的基本用法就先演示到这里了。下面请大家思考一个问题，是不是只要我的程序能在理想化的情况下运行，每一步都不出错，那么我就可以完全不需要错误处理了呢？单就这个问题来说，答案是：对，是这么回事，如果一切顺利，其实错误处理的机制没有任何价值。 那么为什么各种语言都要在错误处理费心设计、健全机制呢？

这就牵扯出来一个重要的编程哲学问题，面向失败编程。这句话显然不是要劝我们写会运行失败的程序，而是在任何时候，编程都要考虑潜在导致失败的风险，要能捕捉这些风险，控制这些风险。就像优秀的棋手，每下一步棋，不光要思考之后怎样组织进攻，更要思考如何放手，而不至使自己陷入被动的境地。

那么为什么编程一定要考虑这些风险呢？这些风险就这么普遍么？如果你还有这样的疑问，说明你还没有认识到计算机世界以及人类世界的复杂。我们编写的程序，都是跑在计算机（此处把手机等各种智能设备、物联网设备类比为广义的计算机），最终被人或者其他计算机使用的。

这里面先说人，就是极为不靠谱的，他们不会按照你的设想操作你的程序，如果没有限制，他们会在输入窗口输入各种匪夷所思的内容，甚至有些邪恶的小伙伴会专门输入恶意的内容，期待看到你程序崩溃的样子。

然后再说机器，它们虽然没有情感，没有道德层面的好坏之分，但是它们也是不能太相信的存在。毕竟一部计算机由各种配件组成，而每一个配件都有坏掉的风险，比如当你尝试在有坏道的磁盘上读写文件，就会有文件丢失的风险。更何况把计算机链接在一起的网线，也是极为脆弱，相信你一定在新闻里看到过网线被挖断导致网络设施瘫痪的故事。

而业界频频提及的分布式应用，更是要把不靠谱的计算机用不靠谱的网络组成在一起提供程序功能，可想而知，如果放任自流，那么它出问题的概率更是提高了不知道多少倍。

所以如果认真观察，你就会发现，越是优秀的公司，越是优秀的技术方案，越是在对抗风险上不遗余力，甚至他们的软件产品的重要卖点都离不开对抗风险。所以控制风险，是写在每个程序基因里的，也是根植于每个程序员内心之中的。而错误处理，就是这种设计哲学的最直观表达，是每个程序员都要熟悉，并且赖以生存的基石。

参考资料：

• https://docs.swift.org/swift-book/LanguageGuide/ErrorHandling.html
• https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

往期回顾：

• Swift 初体验（1）
• Swift 初体验（2）- 久仰大名 switch
• Swift 初体验（3）- 函数和闭包
• Swift 初体验（4）- 对象与类
• Swift 初体验（5）- 枚举
• Swift 初体验（6）- 结构体 Struct
• Swift 初体验（7）- Protocols
• Swift 初体验（8）- Extension

这个时候，就该我们今天的主角Extension出场了。有了Extension我们就可以对已经存在的struct或者class拓展功能了。比如，我们想判断一个整数是不是奇数，通常简单的做法是这样：

func isOdd(num:Int) -> Bool{
    return num%2 != 0
}

print(isOdd(num: 4))
print(isOdd(num: 5))

但是如果有了Extension，我们就可以把isOdd函数直接写到Int里了，至少用起来是这样的。

extension Int {
    func isOdd() -> Bool{
        return self%2 != 0
    }
}


print(4.isOdd())
print(5.isOdd())

明显上面的写法在最终调用时更加符合直觉，也更优雅。

考虑到extension中也可以扩展计算属性（Computed Properties），我们还可以再进一步：

extension Int {
    var isOdd:Bool {
        return self%2 != 0
    }   
}

print(4.isOdd)
print(5.isOdd)

extension不光可以扩展普通的函数，也可以扩展构造函数。比如下面这个例子：

import Foundation

extension Date{
    init (_ str:String){
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyyy-MM-dd"
        
        let target = dateFormatter.date(from: String(str))!
        self.init(timeIntervalSince1970: target.timeIntervalSince1970)
    }
}


var aDate = Date("2022-06-01")

print(aDate)

在上面的例子中，我们给Date增加了一个新的构造函数，可以传入形如yyyy-MM-dd的字符串构建一个Date。

除了普通函数、计算属性以及构造函数。还有一种能够扮演逻辑功能的特殊语法我们之前还没有讲过，就是Subscripts（下标）。我们最常遇到的场景就是数组，你应该已经接触过了，比如这样：

var nums = [1,2,3,4,5]
print(nums[0])

除了数组之外，即使是struct或者class，只要源码在自己手上，都可以很容易的通过添加subscript获得对下标的支持，以达到类似于数组的使用效果。但是当源码不掌握在自己手里的时候，我们就可以借助extension对现有的struct及class进行改造了。比如下面这段代码：

var str:String = "abc"
print(str[0])

我们期望程序返回a，但事实上程序会报错。这时我们就可以通过extension自己实现对String功能的增强了：

extension String {
    subscript(digitIndex: Int) -> String {
        if digitIndex < 0 || digitIndex >= self.count{
            return ""
        }
        
        let arr = self.map{String($0)}
        return arr[digitIndex]
    }
}

print("abc"[0])

有了上面的代码，我们就可以把String当成Array一样，优雅地通过下标的方式获取到对应位置的单个字符串了。如果我们传入的下标不在支持的范围内，那程序就返回一个""（空字符串）。

extension可以跟我们上次讲的protocol结合在一起使用，比如这样：

protocol Hello {
   func say()
}

extension Int:Hello{
    func say() {
        print("Hello, \(self)")
    }
}

4.say()

有了这样的特性，我们就可以让别人写的struct或者class遵照我们定义的protocol行事了。

最后再说一下，extension除了可以拓展功能外，可以拓展静态属性，一个常见的场景是在使用SwiftUI时，需要对一些公共的颜色进行预知，方便之后的使用。那么就可以这样：

import SwiftUI

extension Color {
    static  var background = Color("background")
    static  var separator = Color("separator")
    static  var textColor = Color("text_color")
}

这样我们在编写UI代码时就可以优雅地访问颜色了：

var body: some View {
    VStack{
        Text("hello")
            .foregroundColor(.textColor)
        Color.separator.frame(width:100, height:2)
    }
    .background(.background)
}

参考资料：

• https://docs.swift.org/swift-book/LanguageGuide/Extensions.html
• https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

往期回顾：

• Swift 初体验（1）
• Swift 初体验（2）- 久仰大名 switch
• Swift 初体验（3）- 函数和闭包
• Swift 初体验（4）- 对象与类
• Swift 初体验（5）- 枚举
• Swift 初体验（6）- 结构体 Struct
• Swift 初体验（7）- Protocols

protocol Staff{
    func work()
}

class Programmer:Staff{
    func work() {
        print("我在写代码")
    }
}


class Designer:Staff{
    func work() {
        print("我在搞设计")
    }
}

let 张三 = Programmer()
let 李四 = Designer()

张三.work()
李四.work()

除了开头三行定义protocol的代码，其他的我们之前都用过或者见过类似的。即使不运行代码，你应该也能猜到最后程序的输出内容。可能引起费解的应该是定义Programmer的Programmer:Staff以及Designer:Staff这段，因为我们之前介绍过，如果需要一个类继承另外一个类，就是需要用:做连接的。但是此刻，显然我们不是在做继承，因为前面那个叫Staff就不是class，当然也不能当作父类。Staff前面的关键字亮明了身份，它就是我们今天要介绍的protocol。

protocol可以用来规定一组行为，它自己并不告诉我们这些行为具体该怎么做，但是它可以用来约定其他人，要求这些其他人必须把这些事情做到位，这就是protocol的主要用途。

结合上面的例子已经很好理解了。工作需要有职工 Staff，他们的主要能力就是工作 work，但是不同的工种有不同的work内容。所以Programmer、Designer都有不同的work函数的具体实现（例子中就是打印一句话）。因为Programmer、Designer都被Staff约束着，你就可以想象，存在一位老板，他会口头禅就是：“我管你是什么工种，来我这就得给我干活”。

此时，如果我们再创造一个类ProductManager，它也通过:Staff受到约束，但是它就不干活，我们来看看会怎样。

如上图，我们没有在ProductManager里提供work函数，此时编译器就会报错了，告诉我们这个ProductManager违背了Staff的约定。

protocol不光可以约定别人的函数，也可以约定别人的属性。接着我们的例子说，老板对每位员工都一视同仁，管你是中国人还是外国人，都必须有个工号（jobNumber），这就可以用protocol来实现。

但是如果我们贸然对Staff增加一个变量是不行的，就会收到编译器给出的报错，如上图。同时，编译器也给出了一个提示帮我们改进代码，改进过后的代码如下：

protocol Staff{
    var jobNumber:String{get set}
    func work()
}

当你改完Staff之后，之前的Programmer、Designer也会同时跟着报错，因为编译器检查到它俩已经不在满足之前的约定了，也得与时俱进才行。这个时候，你只要在Programmer、Designer中追加属性var jobNumber: String就可以了。但是因为它俩毕竟是class，但是你声明了一个不为空的变量，又没有构造函数来初始化数据，肯定是说不过去的，编译器还是不愿意放过你，所以你会看到下面的报错：

如果你没有忘记之前我们讲过的init方法的话，想修复这个问题其实很容易，最终Programmer代码如下：

class Programmer:Staff{
    var jobNumber: String
        
    init(jobNumber:String){
        self.jobNumber = jobNumber
    }

    func work() {
        print("我在写代码")
    }
}

那么创建一个程序员的代码也得稍加变动，还以张三为例的话，就得这样写了：

let 张三 = Programmer(jobNumber: "001")

这里留个小小的思考题给你，如果我想在张三.work()时输出我是工号：001，我在写代码，该怎么修改代码呢？

在前面的例子中，我们展示了protocol是如何作用于class的，但其实它也可以作用于struct和enum，主要用法差不多，但是有一点是值得注意的，因为struct、enum毕竟是值类型，默认不具备自己修改自己的能力，在一些特殊场景下还是要注意的。

下面我们就来看一下稍微特殊点的场景，回到前面的Staff的例子，我们再给它加一个属性薪资 salary，以及追加一个函数涨薪 salaryIncrease，调整过的Staff如下：

protocol Staff{
    var salary:Float{get}
    var jobNumber:String{get set}
    
    func work()
    func salaryIncrease(ratio:Float)
}

有一点注意的是，我们并没给salary``set的机会，因为薪资嘛，岂能让别人说改就改，只有老板通过salaryIncrease才能对员工变动薪资。同时，salaryIncrease的参数我们设计为一个比例值，如果该值为0.1的话，就是涨薪10%的意思。下面我们来优化Programmer，最终代码如下：

class Programmer:Staff{
    var salary: Float
    var jobNumber: String
        
    init(jobNumber:String, salary:Float){
        self.jobNumber = jobNumber
        self.salary = salary
    }

    func work() {
        print("我是工号：\(jobNumber)，我在写代码")
    }
    
    func salaryIncrease(ratio: Float) {
        self.salary = self.salary + self.salary*ratio
    }
    
}

上面的代码是基于class的，当我们把关键字class改成struct的时候，它就变成结构体了。但是同时，我们会收到一个报错：

也就是前面提到的struct默认不能自己改自己的问题。此时你需要声明这个方法是mutating的，从而获得可修改自己的能力。

mutating func salaryIncrease(ratio: Float) {
    self.salary = self.salary + self.salary*ratio
}

当然这样改了之后，protocol那边也得要改，最终Staff代码如下：

protocol Staff{
    var salary:Float{get}
    var jobNumber:String{get set}
    
    func work()
    mutating func salaryIncrease(ratio:Float)
}

这样改动之后，如果我们真的想给张三加薪的话，就可以通过下面的代码实现：

var 张三 = Programmer(jobNumber: "001",salary: 1000)
print(张三.salary) //1000.0
张三.salaryIncrease(ratio: 0.1)
print(张三.salary) //1100.0

顺便说一下，因为class也可以实现protocol，但是约定方法的关键字mutating是不适用class的，那么这样含有mutating的protocol还能用来约定class么？

答案是可以的，但是要注意的是，虽然protocol中的函数是有mutating作为修饰，但是在class中，要把mutating关键字删除就行了。说起来有点绕，这里我们分别用Programmer作为class、Designer作为struct来给大家演示一下，最终代码如下：

protocol Staff{
    var salary:Float{get}
    var jobNumber:String{get set}
    
    func work()
    mutating func salaryIncrease(ratio:Float)
}

class Programmer:Staff{
    var salary: Float
    var jobNumber: String
        
    init(jobNumber:String, salary:Float){
        self.jobNumber = jobNumber
        self.salary = salary
    }

    func work() {
        print("我是工号：\(jobNumber)，我在写代码，我的薪资是\(salary)")
    }
    
    func salaryIncrease(ratio: Float) {
        self.salary = self.salary + self.salary*ratio
    }
    
}

struct Designer:Staff{
    var salary: Float
    var jobNumber: String
        
    init(jobNumber:String, salary:Float){
        self.jobNumber = jobNumber
        self.salary = salary
    }

    func work() {
        print("我是工号：\(jobNumber)，我在搞设计，我的薪资是\(salary)")
    }
    
    mutating func salaryIncrease(ratio: Float) {
        self.salary = self.salary + self.salary*ratio
    }
    
}


let 张三 = Programmer(jobNumber: "001",salary: 1000)
张三.salaryIncrease(ratio: 0.1)
张三.work()



var 李四 = Designer(jobNumber: "002",salary: 1000)
李四.salaryIncrease(ratio: 0.15)
李四.work()

得到的输出结果会是：

我是工号：001，我在写代码，我的薪资是1100.0
我是工号：002，我在搞设计，我的薪资是1150.0

上面的代码中还有个小细节，张三我们用let声明，而李四却用的var，这可不是笔误，你能参透其中的原因么？

最后还要强调的是，用:去约定protocol是可以同时实现多个的，但是继承父类，只能继承一个，它们都是用唯一的:来做连接的。如果存在既要继承class又要实现protocol的情况，应该把父类放在紧随:之后，如图：

参考资料：

• https://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html
• https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

往期回顾：

• Swift 初体验（1）
• Swift 初体验（2）- 久仰大名 switch
• Swift 初体验（3）- 函数和闭包
• Swift 初体验（4）- 对象与类
• Swift 初体验（5）- 枚举
• Swift 初体验（6）- 结构体 Struct

今天我们就来看看struct，相信通过今天对结构体的学习，不仅能帮你更好地掌握Swift，即使以后遇到其他语言的相关概念，你也可以触类旁通，了然于胸。

先来看一段简单的结构体代码，就用我们在第四讲接触过的案例。

struct Shape {
    var numberOfSides = 0
    
    init() {
       print("i am here")
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

var shape = Shape()

这段代码几乎与我们之前写的一模一样，唯一的区别，就是把定义类的class关键字改成了定义结构体的struct关键字。所以从共性上来说，类和结构体是很相似的。它们都可以定义属性和函数。那么struct到底与class有什么区别呢？要理解这个问题，我们必须搞懂什么是值传递，什么是引用传递。下面我们来看一些简单的代码：

var a = [1,2,3]
var b = a

第一行定义一个变量a，并设置其值一系列数字组成的数组，第二行定义了变量b，并把a传递给b`。继续：

a.append(4)

print(a)
print(b)

此时我们把数组a追加一个数字4，然后再打印a、b两个变量的值，你觉得会是多少呢？动手试一下你就知道：

如图，b与a的内容不再相同，也就是说b的值不受a变化的影响。像这样，只是在var b = a的时候，发生了一次a值到b值的传递，之后它俩天各一方再无瓜葛，中间的那次=号赋值就是值传递。

与值传递相反的就是引用传递，这个必须借助class才能演示，我们来看下面的代码：

class Circle{
    var radius:Int
    
    init (_ r:Int){
        self.radius = r
    }
}

我们定义了一个类，用来描述一个圆形，它有唯一的一个属性radius（半径），同时我们可以用构造方法直接提供半径的大小。下面我们定义一个圆形：

var a = Circle(1)
print(a.radius)

显而易见，上面的代码会输出1。那么我们故技重施，在准备个b，然后去修改a的半径，代码如下：

var b = a
a.radius = 2

print(a.radius)
print(b.radius)

大家觉得输出会是什么呢？建议动手实验一下，其实我们得到的输出是：

对，此时a与b的半径都是2了，也就是说，改变a，也就意味着b的改变，反过来也是一样的，比如我们继续执行：

b.radius = 3
print(a.radius)
print(b.radius)

这样之后输出也都是3，其实此时已经不需要再纠结是a影响了b还是b影响了a，因为**a就是b、b就是a**，而之所以有这样的结果，就发生在那行var b = a，关键就在于，这个=赋值实现的是引用传递。

简单总结下值传递和引用传递的区别，值传递就是值复制传递，先复制一份再传递；引用传递就是值共享传递，传递是引用，而共享的是值。那么什么是引用，引用和值到底有什么关系呢？

这里给大家举个例子，你想邀请朋友来你家玩，你家这个物理意义上的一个具体空间就是一个值。而你为了能让朋友找到你家，你抄了好多小纸条，纸条上写清楚了你家的具体地址。这一张张小纸条，就是引用，把小纸条分给你朋友的过程就是引用传递。

现在关于=起到的两种传递效果大家应该很清楚了。那么什么时候发生的是值传递？什么时候发生的是引用传递呢？其实非常简单，如果是class所制造的各种对象，那么传递就是引用传递，反之就是值传递。

除了值传递和引用传递的区别，struct与class最大的区别就是前者无法享受后者的继承特性。

理解了这些区别之后，真遇到开发的具体场景，你可能还会有疑惑，针对某一个具体场景，到底该选择struct还是class呢？一个简单的技巧告诉大家，就是优先考虑struct，当struct无法满足需求的时候，再用class来替换。因为从struct改成class很容易，只要替换一个关键字就行，但是反之往往会遇到困难。当然如果你真这么操作了，也别忘了前文提到的值传递和引用传递的区别，相关的代码也应检查一下。

参考资料：

• https://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html
• https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

往期回顾：

• Swift 初体验（1）
• Swift 初体验（2）- 久仰大名 switch
• Swift 初体验（3）- 函数和闭包
• Swift 初体验（4）- 对象与类
• Swift 初体验（5）- 枚举

在Swift中，最简单的定义枚举的方式如下：

enum Gender {
    case male
    case female
    case other
}

这里我们通过enum关键字定义了名为Gender的枚举，用来约束性别的几种可能，这些可能性通过case来逐条声明。其实这三条case也可以合并成一行书写，像下面这样，也是可以的：

enum Gender {
    case male , female , other
}

定义完枚举类型后，我们来演示下怎么使用它。想象定义一个类，用来描述人类，它包含两个基本字段：age、gender，分别代表年龄和性别。其中age的类型显而易见，而gender的类型，就用我们前面定义的枚举即可，请看下面的代码：

class People {
    var age:Int
    var gender:Gender
    
    init(age:Int, gender:Gender){
        self.age = age
        self.gender = gender
    }
}

let aGirl = People(age:8, gender:.female)

在上面代码的最后一行，我们定义了一位8岁的女性，所以她是为小女孩，下面我们尝试在People类里让她开口说话。定义一个sayHello方法，它可以判断自己的性别，然后给出不同的反馈。这里涉及到的知识点，就是对枚举类型的判断。具体请看下面的代码：

    func sayHello()->String{
        switch gender{
        case .male:
            return "I am a boy."
        case .female:
            return "I am a girl."
        case .other:
            return "Hello."
        }
    }

当上面的方法被定义到People中后，我们就可以这样测试一下效果：

let aGirl = People(age:10, gender:.female)
print(aGirl.sayHello())

这里面要强调一点，枚举一旦参与switch语句判断，它的每一项都要接受比较。比如上面的场景，如果我想说，.other的情况我不关心，那么如果我删除了它，而使代码成为这样的话：

    func sayHello()->String{
        switch gender{
        case .male:
            return "I am a boy"
        case .female:
            return "I am a girl"
    }

很遗憾，我们收到一个Switch must be exhaustive编译错误，提醒我们要判断完整。如果你实在需要省略部分case的选项的话，可以引入default，来匹配你不关心的选项，比如这样：

    func sayHello()->String{
        switch gender{
        case .female:
            return "I am a girl."
        default:
            return "Hello."
        }
    }

枚举除了和switch语句走得比较近之外，还经常参与迭代，也就是和for循环关系同样紧密。如果想用for循环遍历枚举的每一项的话，我们需要声明该枚举支持迭代，声明的方式非常简单，需要在类名后用:跟随CaseIterable，代码如下：

enum Gender : CaseIterable{
    case male , female , other
}

我们在之前介绍过，如果用类与类的继承关系，会用到:跟随它要继承的父类。而在上面的用法中，并不是在继承父类，属于比较特殊的情况，这个我们以后再详细介绍。话说回来，只要我们追加了魔法般的CaseIterable之后，我们就可以很方便的对枚举进行迭代了。

for gender in Gender.allCases{
    print(gender)
}

输出的结果为：

male
female
other

这里不要疑惑，虽然打印到控制台的内容是字符串。但是本质上for循环体内的gender对应的还是Gender类型，这跟People定义的gender变量类型是完全相同的。如果你想验证一下的话，可以用下面的代码：

for gender in Gender.allCases{
    print(type(of:gender))
}

print(type(of: aGirl.gender))

所以type函数可以帮我们确定一个参数的类型。那么上面神奇的Gender.allCases，咱们也可以观察下。

print(type(of: Gender.allCases))

你将得到结果Array<Gender>，所以它就是个Array，你可以像把玩其他数组一样把玩Gender.allCases，比如这样print(Gender.allCases.count)可以打印该枚举的大小。

其实有了switch，有了for，我们就能对枚举做很多事了。但是某些情况下，可能还是有点力不从心。比如我们尝试构造一个星期的枚举。

enum Week{
    case monday , tuesday , wednesday , thursday , friday , saturday , sunday
}

如果我想判断周末是不是到了，诚然可以去跟.saturday、.sunday分别比较一下，也不是不行。但是如果能直接判断一个index>5，那不是很容易么？这就牵扯到枚举类型原始值的概念。在这里，我希望一个星期的每一天，都能对应一个整型数字，所以需要这样写：

enum Week : Int{ // <--注意这里
    case monday , tuesday , wednesday , thursday , friday , saturday , sunday
}

这样我们的每个枚举就拥有了原始值(rawValue)，以.monday为例，可以这么访问print(Week.monday.rawValue)，略显尴尬的是，看到的结果是0。这也可以理解，计算机世界里，牵扯到计数一般都是从0开始走的。所以我们需要手动给monday分配1，也非常简单，就像这样：

enum Week : Int{
    case monday = 1 , tuesday , wednesday , thursday , friday , saturday , sunday
}

如果你想事无巨细地把枚举里的每个元素都分配一个原始值当然是可以的，但其实swift已经很聪明的帮你把枚举中的后续元素以1为起点，逐个的修正好了。想验证的话，我们可以通过前面的for循环，同时别忘了，要在枚举命名处的:后面追加CaseIterable。最后的代码如下：

enum Week : Int , CaseIterable{
    case monday = 1 , tuesday , wednesday , thursday , friday , saturday , sunday
}

for week in Week.allCases{
    print(week.rawValue)
}

有了原始值的支持，我们获取一个具体的枚举元素就可以用另外一个方式了。比如：

print(Week(rawValue: 7) == Week.sunday)

返回的就是true，足以证明通过原始值拿到的枚举与直接点出来的枚举是一回事。你可能会有疑问，没有原始值的枚举明明也可以工作的不错，那么原始值的加入到底能带来什么呢？想象一下，你的业务是跟一个关系型数据库(SQL)打交道的，最终存储在数据库里的数据都是符合数据库标准的，如果你尝试把Week.sunday存进去的话，你甚至不知道该给这个数据列定义什么类型。而有原始值的支持，你就可以在数据库支持的类型与Swift的枚举类型中做优雅的转换工作了。

还有一点需要注意的是，在上面的例子中，我把原始值的类型定义为Int，只是觉得它正好满足星期几的这种需求。如果你的业务有其他场景，完全可以用其他类型表示原始值。比如下面这个例子：

enum ASCIIControlCharacter: Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}

在前面的例子中，我们都在用枚举表示某种定数，比如从星期一到星期天，不外乎7种情况。但其实swift的枚举设计得更为强大，可以存储变幻多端的数据，请看下面的代码：

enum ServerResponse {
    case ok(String)
    case failure(Int , String)
}

let success = ServerResponse.ok("hello world")
let failure = ServerResponse.failure(502,"Bad Gateway")

switch failure {
case let .ok(context):
    print("Response is \(context)")
case let .failure(stateCode , message):
    print("Failure... \(stateCode)  \(message)")
}

这里的描述的场景是服务器HTTP返回的数据。如果成功的话，就是ok，并提供服务器返回的内容；如果失败的话，要提供一个状态码，以及错误的详细信息。你可以通过替换上面代码中的switch failure为switch success观察不同的输出效果。

上面的演示只是枚举能力的冰山一角，更多高阶的功能就等待你自己去探索发觉了。

参考资料：

• https://docs.swift.org/swift-book/LanguageGuide/Enumerations.html
• https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

往期回顾：

• Swift 初体验（1）
• Swift 初体验（2）- 久仰大名 switch
• Swift 初体验（3）- 函数和闭包
• Swift 初体验（4）- 对象与类

一个简单的class声明如下：

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

好像并没有什么特别的，一个class关键字后面跟上你想要的名字，再用花括号紧随其后包裹一个区域。在这个区域内，你就可以填上前几节课教的常量、变量与方法了。

上面的代码，仅仅是声明了一个class，如果像使用它，还需要造个对象出来，也就是创建一个该class的实例，一个简单的例子如下：

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
print(shapeDescription)

在第一行，我们创建了一个叫shape的实例，它拥有的变量及函数就是我们在Shape这个class声明的。一个class可以有千千万万个实例，但是每一个实例都享受它自己的特殊性，在这个例子里，就是numberOfSides变量了。为了让shape这个独一无二的对象（实例）拥有它自己的特殊的numberOfSides内容（数字7），就有了上面代码的第二行。

如果我们回过头来审视第一行代码——Shape()，会发现这种写法与函数调用基本没啥区别，只是目前调用这个函数时没有提供任何参数罢了。那么有没有一种可能，在创建对象实例的时候，我们能传点参数进去。用上面的代码举例子，就是我们把原本两行的代码：

var shape = Shape()
shape.numberOfSides = 7

精简成：

var shape = Shape(numberOfSides: 7)

这其实是一种很常见的需求，只需要我们在Shape类里面多提供一个方法，最终的Shape代码如下：

class Shape {
    var numberOfSides = 0
    
    init(numberOfSides : Int) {
       self.numberOfSides = numberOfSides
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

其中init函数就是我们刚刚追加的，这种函数会在对象被构造出来的时候执行，所以这种特殊的函数就叫构造函数。至于函数代码段中的那个self，见文知意，就是说的是实例的自身。self.numberOfSides = numberOfSides的意思就是把函数接收到的参数numberOfSides内容赋值给self.numberOfSides，也就是本实例的变量numberOfSides。还应注意的是，与上节课我们介绍的函数使用类似，如果我们在声明init函数参数的时候前面加个_，就像下面这样：

init(_ numberOfSides : Int) {
   self.numberOfSides = numberOfSides
}

那么我们就可以在创建Shape实例时，省略参数的名字，像这样：

var shape = Shape(7)

话说回来，如果你只想在对象被实例化的时候做点什么小动作，但是并不一定需要接收什么参数，其实你可以使用无参数的init函数，比如下面这段代码，我们就只是在shape生成时打印了一句话而已。

class Shape {
    var numberOfSides = 0
    
    init() {
       print("i am here")
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

var shape = Shape()

既然init是用来解决对象创建时做点什么的问题，那么对象销毁时，是不是也会有做点什么的需求呢？如果有这样的需求，代码要写在什么地方呢？答案就是deinit。与init一样，他们都是可选的，只在你需要的时候，可以召唤他们。但是与init不同的是，deinit不会接受任何参数，因而它不是一个正儿八经的函数。如果需要在Shape对象销毁时打印一句话，我们可以这样写：

class Shape {
    var numberOfSides = 0
    
    init() {
       print("i am here")
    }

    deinit {
        print("deinit")
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

想测试上面的deinit，我们就必须想办法销毁一个对象。最简单的办法就是把一个原本存储了对象的变量设置成nil，就像下面这样：

var shape:Shape? = Shape()
shape = nil

如果你对第一行代码中?感到疑惑，建议再回顾下本系列文章的第一篇。

面向对象的一个明显优势就是可以通过类的继承来组织类与类之间的关系，从而大幅减少代码重复率提升代码的可维护性。请看下面的例子：

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
       self.name = name
    }
    
    func simpleDescription() -> String {
       return "A shape with \(numberOfSides) sides."
    }
}

我们这里准备了一个叫NamedShape的类，它用来存储各种形状，通过init函数，我们要求创建形状的时候，需要给具体的形状起个名字。同时我们的形状也拥有numberOfSides变量，用来记录具体形状拥有的边的数量。

有了NamedShape，当我们考虑创建正方形（Square）这种形状的时候，就会发现正方形本质上也是一种形状，它跟NamedShape有很多共通之处，只是numberOfSides是已被确定的值，应该填入4。来看下面的代码：

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }

    func area() -> Double {
        return sideLength * sideLength
    }

    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)."
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

在代码第一行，声明Square类的时候，我们通过:，明确了Square对NamedShape继承关系。然后Square就拥有了NamedShape已拥有的一切。比如numberOfSides = 4中的numberOfSides就是原本属于NamedShape的变量。而super.init(name: name)其实就是在子类中调用了其父类的init构造函数。因为init这个函数，子类也有，父类也有，所以当子类调用父类的函数时，需要提供super.，用来明确要调用的函数是属于父类的。不光构造方法，如果是要调用父类的其他方法，也是同样的道理，都需要用super.明确。甚至那句numberOfSides = 4也可以写成super.numberOfSides = 4，道理也是一样的。

还应注意的是simpleDescription函数，这里我们在func之前追加了关键字override，是因为NamedShape的simpleDescription函数功能不满足需求，我们想用Square新定义的。但是因为函数名在父、子类中是相同的，所以我们需要在子类中通过override明确覆盖掉父类的同名方法。

在前面的例子中我们演示了一些属于类的变量的使用，比如：numberOfSides，这样的变量跟第一节课讲的没啥区别。当然我们可以在类内定义常量，这些变量和常量，都可以叫做是类的属性，确切的说应该叫存储属性。但是有一种属性非常特殊，我们叫它计算属性，我们来看下面的例子：

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }

    var perimeter: Double {
        get {
             return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }

    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)."
    }
}

其中perimeter就是一种计算属性，这种计算属性对于使用方来说，就像是普通的属性一样，比如下面这种调用方式：

var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9
print(triangle.sideLength)

我们通过构造函数，创造了一个名叫a triangle的正三角形，它的边长为3.1，所以其实它的周长是可以被推算出来的，我们就可以省去设置周长的代码。所以在上面代码的第二行，我们可以得到9.3的结果。

但是当我们执行到第三行的时候，如果我们非要把正三角形的周长改成9.9，那么显然相应地正三角形的边长也会发生改变。因而我们在第四行代码可以得到这样的结果：3.0。

所以计算属性的使用，对外围的使用者来说，就像在访问普通的变量一样轻松，没有任何区别。但其实，对类内部来说，计算属性的访问是可以隐含着一系列运算的。具体到上面的例子，当我们相查询perimeter时，其实命中的是get的代码段，而当我们试图给perimeter赋值时，命中的就是set代码段，并且在set代码段内，我们拥有一个天然的局部值newValue，它的类型，就是对应计算属性的类型，它的值，就是我们相给它塞的值，在上面的代码中，就是9。

顺便一说，上面代码中的这段：

get {
     return 3.0 * sideLength
}

其return关键字也是可以省略的。

同时，如果你想构建一个只读的计算属性也是可以的，比如这样：

var perimeter: Double {
    get {
         3.0 * sideLength
    }
}

那么显然perimeter就只能用来获取，而不可以被赋值了。在构造这种只读属性的时候，代码还可以进一步简化成下面的样子：

var perimeter: Double {
    return 3.0 * sideLength
}

而且你应该也能猜到，这里的return是可以省略的。

好了，关于Swift中类和对象的基本用法就先介绍到这里，下期我们会介绍枚举和结构体类型。

阅读相关文章：

Swift 初体验（1）
Swift 初体验（2）- 久仰大名 switch
Swift 初体验（3）- 函数和闭包

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

值得注意的是，在调用函数传递参数的时候，我们不光提供了参数的值，同时也提供了参数的名，这样确实牺牲了一点开发效率，但是提升了不少代码的可读性，总的来说肯定是利大于弊的。不过即使我们提供了参数的名，传递参数的顺序仍然不可更改，在上面的例子中，如果写成greet(day: "Tuesday",person: "Bob")是不可以的。

当然也有一些情况，不传递参数名其实也不影响可读性，比如最常见的print方法，显而易见它的第一参数都是要输出打印的东西，如果我们画蛇添足，明明可以print("Hello Word!")的，却非要写成print(items: "Hello Word!")就会显得过于鸡肋了。所以Swift提供一种方式，可以声明这个参数在调用时不需要提供名，就像这样：

func greet(_ person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("Bob", day: "Tuesday")

在声明函数的时候，在其参数名之前通过_标记一下，即可让这个参数在调用时免去提供参数名的麻烦。并且需要被_的参数，没有顺序要求，像下面这样的代码也是可以的：

func greet(person: String, _ day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob","Tuesday")

这里还有一个不怎么常用的小技巧，就是_的位置也可以替换成其他内容，从而对这个参数起一个别名，比如这样：

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

函数的返回值是通过->标记的，这点在上面的例子上也已经看到了。如果需要返回多个值的话，可以使用Tuple（元组类型），比如这样：

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

上面的函数接收一组整型数据作为参数，并计算出这组数据的最大值、最小值以及总和，把这些结果通过封装在在元组中返回，以达到返回多值的效果。

在一个函数内部还可以继续定义函数，并且遵循了大家已知的闭包作用域的规范：

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

Swift中的函数，是遵循first-class原则，也是一等公民，跟其他数据类型一样享受同样的待遇，当然也可以作为一个函数的返回值，比如：

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

我们可以通过print(increment.self)查看increment变量的类型，得到的结果会是(Function)。

函数既然能被用作返回值，当然也可以当作参数进行传递，比如：

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)

像上面这些把一个函数看成传统类型，一会当返回值一会当参数的玩法在其他很多语言里都是有的。对初学者来说，可能理解起来会稍有困难，主要还是因为实践的少，遇到的场景不多。我觉得没关系，你只要留个印象，以后在阅读别人代码的时候，如果遇到了，自己花点时间能读懂就行了。至于融会贯通、学以致用，可以慢慢来，随着经验的积累自然就会好的。

下面我们再来谈谈Closures（闭包），首先我们准备一个数组，就用前面的那个例子：

var numbers = [20, 19, 7, 12]

如果我想对数组中的每个元素进行一次平方运算，然后获得一个新的数组，首先我需要准备一个能把Int平方的函数：

func square(number: Int) -> Int{
    return number * number
}

而数组提供了一个叫map的函数，可以让我们方便地对其元素做逐个运算，并把运算结果汇集到新的数组中。所以我们只要对numbers进行如下的运算就可以了：

numbers.map(square)

这时候我们得到的结果就是：

[400, 361, 49, 144]

但其实我们可以把声明square和调用map合在一起写，就像这样：

numbers.map({ (number: Int) -> Int in
    return number * number
})

如你所见，声明专门的square函数或者是用闭包的方式来给map传递参数都是等价的。而后者的魅力在于可以省略掉一些已知的东西，进而简化成这样：

numbers.map({number in number * number})

这里，我们简化了入参的类型，return关键字，其实我们还可以更进一步，就连参数number也可以用内嵌的参数名$0替代：

numbers.map({$0 * $0})

当然，如果你的闭包是接收多个参数的，就可以在$0之后继续通过$1、$2...获取其他的参数。比如，如果我们要对numbers排序，就需要提供一个能接收两个参数的闭包，最后写成这样：

numbers.sorted { $0 > $1 }

运算之后的结果为：

[20, 19, 12, 7]

如果你仔细观察sorted和map的代码，会发现在sorted调用闭包的时候，我们省略了闭包外面的()，这是因为如果函数调用只有一个参数，并且这个参数是个闭包时，为了简化输入，可以省略函数调用的()。

关于函数和闭包就先介绍到这里了，我们下次见。

阅读相关文章：

• Swift初体验（1）
• Swift 初体验（2）- 久仰大名 switch

public class SwitchDemo {
    public static void main(String[] args) {

        int score = 5;
        String scoreLabel;
        switch (score) {
            case 1:
                scoreLabel = "差评";
                break;
            case 2:
                scoreLabel = "不满意";
                break;
            case 3:
                scoreLabel = "一般";
                break;
            case 4:
                scoreLabel = "还不错";
                break;
            case 5:
                scoreLabel = "非常满意";
                break;
            default:
                scoreLabel = "无效得分";
                break;
        }
        System.out.println(scoreLabel);
    }
}

Java的这段switch应该还是很有代表性的，就是从C延续下来的写法，很多语言都是这么设计的。说实话，这一水的break，看着还是有点难受，也不能说break的设计完全没用，但是如果大部分情况下break都是不能省的（省了逻辑就变了），那这个设计就值得商榷了。Java程序员忍了多少年，情况终于在2019年发生了一点改变，以下是Java12带来的新的语法：

String scoreLabel = switch (score) {
    case 1 -> "差评";
    case 2 -> "不满意";
    case 3 -> "一般";
    case 4 -> "还不错";
    case 5 -> "非常满意";
    default -> "无效得分";
};

这样写的确清爽很多，我们再来看看同样的问题，在Swift中怎么实现：

let score = 5
var scoreLabel = ""
switch score{
    case 1:
        scoreLabel = "差评"
    case 2:
        scoreLabel = "不满意"
    case 3:
        scoreLabel = "一般"
    case 4:
        scoreLabel = "还不错"
    case 5:
        scoreLabel = "非常满意";
    default:
        scoreLabel = "无效得分";
}
print(scoreLabel)

猛一看，Swift这版代码多了好多行，感觉没有Java12这版优雅啊。这是因为Swift里的switch不能当作一个具备返回值的表达式放在等号的右边。但其实我并不觉得这是Swift的缺点。因为在强类型语言中，任何数据的类型都是非常重要的，不可以朦胧不清。在Java12的示例中，scoreLabel是一个String，但是等号右边的switch如何保证自己的返回是一个String呢？作为一个人类，纯看代码，其实并不能明确地看出来。当然，作为一个机器，编译器还是能看出来，比如我们稍微改下Java12这版代码：

int score = 5;
String scoreLabel = switch (score) {
    case 1 -> "差评";
    case 2 -> "不满意";
    case 3 -> "一般";
    case 4 -> 3;
    case 5 -> "非常满意";
    default -> "无效得分";
};
System.out.println(scoreLabel);

在编译代码阶段，我们就会遇到一个报错提示：

java: 不兼容的类型: switch 表达式中的类型错误
    int无法转换为java.lang.String

所以，不能说Java12的设计有什么问题，反正编译器这边是清醒的。但是我个人总觉得，把等号左边的变量类型通过switch穿透到其内部，来约束switch里面的事情，有越俎代庖之嫌。

下面我们来改进Swift的版本，看看能否得到近似于Java12这般优雅的方式。

let score = 5
let scoreLabel = {()->String in
    switch (score) {
    case 1 :  return "差评"
    case 2 :  return "不满意"
    case 3 :  return "一般"
    case 4 :  return "还不错"
    case 5 :  return "非常满意"
    default : return "无效得分"
    }
}()

print(scoreLabel)

我这个写法对于Swift新手来说，稍微有点超纲了。等号右边是一个立即调用函数表达式，类似于JavaScript里面的这种写法：

var result = (function () {
    var name = "Barry";
    return name;
})();
// IIFE 执行后返回的结果：
result; // "Barry"

我们说回Swift，你大概能明白scoreLabel的值就是等号右边函数执行过后的返回值。你可能会诧异为什么我写的函数没有名字，因为这里是用Closure（闭包）写成的匿名函数，被花括号包围的整个区域（包括花括号），也就是：{()->String in …… }都是这个函数的定义，其中单词in左侧的String代表了这个函数的返回值，而in之后的内容就是函数的逻辑代码了。在函数定义的}之后，我放一对小括号()，也就是这对小括号产生了神奇的效果，让函数获得了立即执行的魔力。

如果你不小心漏写了最后的小括号，比如这样：

let score = 5
let scoreLabel = {()->String in
    switch (score) {
    case 1 :  return "差评"
    case 2 :  return "不满意"
    case 3 :  return "一般"
    case 4 :  return "还不错"
    case 5 :  return "非常满意"
    default : return "无效得分"
    }
}

print(scoreLabel)

你的得到的结果将会是：

(Function)

也就是说scoreLabel这个常量存储的内容是个函数。而有了小括号，scoreLabel2里面存的就是函数的返回值了，你将会看到如下输出：

非常满意

现在回过头来对比下Swift与Java12的两个实现版本，不难看出Swift中通过一次函数返回值的明确声明，锁定了其内部的return语句必须返回String，不失为一个优雅的解决方案，与Java12相比，可谓各有特色。但是考虑下面这种场景，Swift交出来的答卷就有意思了：

score = 3
let scoreLabel3 = {()->String in
    switch (score) {
    case 1 ... 2 :  return "差评"
    case 3 ... 5 :  return "好评"
    default : return "无效得分"
    }
}()

print(scoreLabel3)

如果我们只想给得分来个二分类，1到2分是差评、3到5分是好评。用上面的代码就会非常直观。并且case 1 ... 2 :在此也可以写为case 1 ..< 3 :，同样具有不错的表现力。

写到这一步，Java其实就已经力不从心了。不过下面的代码才是Swift独享的炫技时刻：

let vegetable = "red pepper"
switch vegetable {
    case "celery":
        print("Add some raisins and make ants on a log.")
    case "cucumber", "watercress":
        print("That would make a good tea sandwich.")
    case let x where x.hasSuffix("pepper"):
        print("Is it a spicy \(x)?")
    default:
        print("Everything tastes good in soup.")
}

这里是一位小伙伴在表达自己对各种蔬菜看法。我们先抛开他的个人喜好，注意代码中的第三段case。它专门用来判断vegetable是否以pepper字样结尾，在本示例中，最终输出的代码为：

Is it a spicy red pepper?

通过这段输出，你应该已经明白x的内容就是red pepper，也就是说x即是vegetable。并且这里的x仅仅是个代号，你可以换成任何其他你愿意使用的变量名。也就是说，case后面的这个let，就像魔术师的手，响指一打，你就会获得需要做switch的判断的那个值。有了这个值，我们就可以基于它构建一个能够计算出布尔值的表达式，并把这个表达式放在where之后。这样，当表达式的结果为true时，这条case语句也就命中了。并且不要忘记，刚才魔术师帮你拿到的x，是可以在case语句执行逻辑的区域内使用的。

显然swift的这种switch用法，给我们增加了很多的想象力。不过也许有人会说，这样的switch是不是与if的功能重叠有点多了？我觉得确实是这样，最早switch被设计成一种if的简化版本，主要用来针对等值判断的，但是显然程序员们的愿望不止如此。所以我们才会在本世纪的一些新鲜语言里，看到更为激进的表现形式。

不过，语言层面提供的这些东西，就像佐料，至于真正做菜的时候加什么，放多少，还得是你这位程序员说的算。

阅读相关文章：Swift初体验（1）

先别着急关掉这个页面。本文的目的就是让程序员朋友们能一窥Swift的优秀设计，了解一下这门年轻的语言值不值得学习。

在正式进入到Hello World!之前，先容我介绍几个Swift的非编程特性：

如果你对这段不感兴趣，往后翻可以直接到编码阶段

1. 开源

是的，这是一门开源的语言，采用Apache License 2.0许可。代码就在GitHub，并且此时此刻的Star数为58.3k，着实不低了。

2. 跨平台

请不要惊讶，作为一门苹果公司推出的，用来开发苹果生态产品的编程语言居然是跨平台的。除了macOS， 它还支持Linux与Windows，更夸张的是即使是iOS的老对手Android，这门语言也是支持的。毕竟开源的力量是无穷的。

不过这里要泼个冷水，支持是一回事，好用又是另外一回事。并且在非苹果自家的平台上运行，因为对应UI库的缺失。Swift更适合扮演后端编程语言的角色。

3. 活跃

毕竟是一门年轻的语言，截至2021年末，最新的Swift最新的版本为5.5.2，侧面体现了这门语言的更新之频繁。

凡事都要两面看，“活跃”带来的未必都是好事，过分的“活跃”发版，意味着多变，很多东西没有沉淀，同时也意味着程序员需要付出更多的精力才能跟上这门语言的节奏。不过好在经过几年的野蛮生长，目前Swift的特性演进已经放缓，这点从5.0的版本发布于2019年初即可看出端倪。

4. 苹果公司主导

这也值得一说么？别误会，我并不是要吹嘘苹果公司如何如何。而是想聊聊关于成就与包袱的哲学。

对于一个人，过去曾给他带来荣耀的成就，最终都会变成某种包袱伴其左右，对于一个公司亦如是，这话不是鲁迅说的，是我自个儿想的。当你看到多少功成名就的人固步自封，甚至被捧杀后又跌落神坛；又有多少公司尾大不掉，深陷泥潭，最终被历史淘汰，或许能理解我的这句话。

就拿我最喜欢的语言Java来说，给世人的印象就是保守，它有广袤的生态，相对悠久的历史，储量很大的程序员队伍，这些是它的成就，恰恰也是它的包袱。生态的繁荣，导致很多早已Out的解决方案还能苟延残喘；悠久的历史导致生产环境有很多现存的系统，即使千疮百孔，但无人敢碰，只能继续延用老的架构；庞大的程序员队伍，就像物理定律一般，质量越大，惯性越大，在巨大惯性的作用下，大家你看看我，我看看你，然后心安理得地选择了固步自封。就是因为拖着这些包袱，Java语言或者说Java生态迟迟不能跟过去切割，总给人一种迟暮与臃肿之感，即使这些刻板印象，只是某种未加深入了解的错觉，但也在无形中矮化了其在新晋程序员心目中的印象。

我们再回头看看Swift的缔造者——苹果公司。这是一个不论在消费者还是在生产者（程序员）队伍中都极具号召力的公司。并且它很有主见，做事不拖泥带水。笔记本接口改革，砍掉HDMI，砍掉SD卡槽，说砍就砍，说加就加。丝毫不影响销量。每年iOS大版本更新，升级率也傲视整个手机界。所以，苹果公司是一个敢于跟过去切割的公司，在多年的品牌文化熏陶下，它的用户们也早已习惯了这种“切割”。同时围绕着苹果生态的程序员，大都跟苹果公司的消费者一样，拥有异于其他技术栈的粘性，毕竟要入坑苹果生态开发，需要买个Mac，十有八九还要注册个苹果开发者账号，年租金688，这些可都是真金白银的投入，就算是图个心理安慰，他们追随苹果公司脚步的意愿也不是其他技术栈程序员可比拟的。

当然，最令其他公司难望项背的实力还是苹果公司对上下游无与伦比的掌控力。一个技术点，从硬件设计，到操作系统升级与API开放，再到号召程序员跟进完全都受其领导。比如iOS13新增的文档扫描API，显然依赖于苹果之前在其芯片中对机器学习算力单元的布局，一旦硬件铺开，苹果就可以直接在对应的iOS版本中提供API，而广大开发者几乎都会迅速跟进，早在iOS的beta阶段就可以试水磨练自己的App。等开发者和苹果的beta系统磨合得差不多了，随着正式版iOS向全球用户推送，数月之内广大的终端消费者都会陆续更新他们的iOS版本——对，你可能会说，肯定会有不少年龄大的或者不会更新系统版本的消费者。可是这些消费者恰好也跟愿意在App Store花钱购买App的消费者不重合啊——所以你看到没？这是一个运作良好的正反馈循环。

只要回头看看Android开发，你就会明白这个反馈循环是开发者梦寐以求的。在Android平台上，不管Google拿出什么杀手锏级别的API，广大开发者们都没有勇气在第一时间跟进。因为谁也不知道那些造手机的硬件厂商会在什么时间跟进Android大版本。而只要有那么一两个主流手机厂商更新慢了，那么软件开发者就不愿，或者不敢过早的介入新版API的开发，因为没有人愿意陷入兼容性调试的噩梦以及多版本代码并线开发的深渊。显而易见的，这就是一个负反馈循环，作为Android的供应商Google空有一番力却使不出来，而广大软件开发者们亦是多方掣肘牵绊太多。

好了，关于主观的铺垫就讲到这里。下面我们该进入Swift的编程世界了。本文主要专注语言语法本身的介绍，所以不会过多介绍开发环境的搭建以及IDE的使用。如果你需要动手尝试Swift的话，最好有个Mac然后安装好Xcode，或者你有个iPad，也可直接安装Swift Playgrounds，相信第一眼看到这个截图就会被它所吸引。

如果你是Windows或者Linux等非苹果生态的用户，可以在这里找到相应平台的安装包，https://www.swift.org/download/ ，祝你好运，我们进入正题。

1. Hello World!

print("Hello, world!")

2. 变量与常量

var myVariable = 42
myVariable = 50
let myConstant = 42

• var 代表变量
• let 代表常量
• 在提供数据的情况下，类型可以自动推断
• 如果你需要指定类型，可以像这样

let explicitDouble: Double = 70

如果你想直接组合一个字符串和数字，就会报错，像这样：

let label = "The width is "
let width = 94
let widthLabel = label + width //🙀Binary operator '+' cannot be applied to operands of type 'String' and 'Int'

但是你可以这样：

let widthLabel = label + String(width)

还有一种更优雅的方式把值整合进字符串，像这样：

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

当然多行字符串也是一门现代语言所必备的技能：

let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""

3.数组与字典

用中括号可以快速定义数组：

var shoppingList = ["catfish", "water", "tulips"]
shoppingList[1] = "bottle of water"
shoppingList.append("blue paint")

如果你需要定义一个字典类型（在Java里它比较像HashMap）可以这样：

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
 ]
occupations["Jayne"] = "Public Relations"

如果是定义空的数组或字典，可以这样：

let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]
//当然被声明为let，就不可添加元素喽

遍历数组也很简单，像这样：

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore) //会输出：11

4. Optional与nil

我想每一个使用面向对象语言编程过的人，都与空指针之类的报错战斗过。作为一个Java程序员，NullPointerException绝对是我这辈子遇到过最多的报错，没有之一。

好在Swift从语法层面解决了这个问题。
如果一个变量，我还没想好放什么值，先用nil（类比为Java里的null）顶一下。

var x:String = nil //🙀'nil' cannot initialize specified type 'String'

你将得到一个报错，也就是说String里面是必须有内容的。如果你执意如此，就得这样写：

var x:String? = nil

这样你得到的就不是String了，而是一个Optional，它像一种包装器，把一个String装了进去。但是当你要使用它的时候，因为拿到的是个盒子，你也不知道里面有没有String，所以就需要多一步，把包装打开确认里面有String才行。我们来看下官方示例：

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

代码中的第三行，就体现了拆包的动作，通过一次let操作，就把optionalName拆成了name，而这个name就是彻头彻尾的String类型了，在花括号范围内可以任意使用， 不用担心nil的问题。如果你觉得平白无故多了个叫name的东西有点碍眼，上面的代码还可以写成这样：

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let optionalName = optionalName {
    greeting = "Hello, \(optionalName)"
}

还有一种场景，就是在遇到nil的时候提供一个默认值，比如这样：

let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"

你大概也能猜到，如果nickname有值，就用它，反之，就用fullName拼装到informalGreeting中。

讲到这，你有没有觉得这门语言似乎有点意思了，希望你可以动手体验一下Swift编程。咱们下节课见喽。

Java真的有点老了，之前我们不觉得，但是当95后程序员看着一门比他们年纪还大的语言的时候，那种感觉，应该跟我这样的80后看到C++的感觉差不多。但是你也不要被这种“老”所误导，Java仍然是一门相当活跃的语言，这种活跃体现在官方发版和社区生态两个方面。尤其是2017年以后，Java也是发车式release，一年两班车，版本必须发，赶得上的特性就上，赶不上就等一下班。

我觉得喜欢技术的人，没人会抗拒这种激进的发版策略。但是公司就不一样了，现在我司所有的Java程序还跑在Java8上，还想在生产环境用Oracle的Java8的话就有风险了，不付费的话，更新补丁啥的想都不要想。

这就引出了我要讲的第一个地方：

除了Oracle的Java，还有的选么？

有，不仅有，而且非常多。这里我随便列几家（摘自sdk list java）：

• AdoptOpenJDK
• Amazon
• Azul Zulu
• BellSoft
• SAP
• TravaOpenJDK

是不是有点意思了？

当然这都源于06年的时候，Sun公司做的一个无比英明的决定，就是搞开源版的Java，后来便有了OpenJDK项目，真是大写的服字。那年笔者刚上大学，不过还没等我大学毕业，Sun公司转眼就被Oracle给收购了，怎不令人唏嘘？

顺便再提一下这两天刚发生的有意思的事情：Apple公司不是在几天前（2020-11-11）刚刚发布了他们基于ARM架构的新Mac么，而就在前不久，微软站出来说给Java贡献代码，为了实现Java向Apple的新架构的适配。我还在新闻下面看到一个评论，大意是说曾几何时，微软的JVM还是特别厉害的JVM实现呢。

所以，Java虽然名义上是Oracle的，但因其开源的历史渊源，其实很多公司都对它投入了相当大心血，包括很多大佬级别的公司，比如华为公司也是贡献过不少代码的。这些全球顶尖的公司，共同维持着Java世界的秩序。现在Java的迭代速度又坐上火箭了，所以网上那些非要较真引战的伪技术帖，动不动就唱衰Java，我觉得还为时过早。

如果你是名前端程序员，想学学后端，技多不压身想法的话，我觉得后端学什么都挺好；但是如果你是打算吃后端这碗饭，我个人还是首推Java的。

但是Java写起项目来，仪式感真是太强了（贬义），对新人极度不友好。有时候别说是新人了，那种充满了仪式感的样板语言，还有言Java必Spring的无脑式安利，对老人也是一种摧残。

这里我推荐几个框架，让大家从Spring的樊笼中解放出来

1. SparkJava

• 上手难度：★☆☆☆☆
• 学习曲线：★☆☆☆☆
• 功能强大：★★☆☆☆
• 场景推荐：入门学习或者个人微型项目使用

2.    Micronaut

• 上手难度：★★☆☆☆
• 学习曲线：★★★☆☆
• 功能强大：★★★★☆
• 场景推荐：有Java Web开发经验的团队使用

3.     Vert.x

• 上手难度：★☆☆☆☆
• 学习曲线：★★★☆☆
• 功能强大：★★★★★
• 场景推荐：有异步编程基础的个人或团队，需要应对高并发项目使用

4.    Quarkus

• 上手难度：★★☆☆☆
• 学习曲线：★★★★☆
• 功能强大：★★★★★
• 场景推荐：离不开Java生态，团队战力强，做云原生项目使用

以上几款框架都是发展态势非常好的框架，笔者多多少少也在项目里用过，所以就根据自己的经验做了推荐。具体还得各位看看文档，自己斟酌食用。

当你打开上面几个框架的官网，应该还会发现另外一个有意思的事情——几乎这些框架都支持多种语言。我个人最喜欢Vert.x，它也是最神勇的一个。来看看它支持的语言吧，下面是其官网的截图：

醒目的“Polyglot”，相当给力的多语言支持。这又是怎么回事呢？咱们开始下一个议题。

Java不止Java

我们都知道Java程序实际上是靠Java虚拟机，也就是JVM解释执行Java字节码运行的（当然也有例外，这个以后有机会展开说）。所以用什么语言写代码其实反而没那么重要，只要最后经过编译，能搞成字节码在JVM上执行就行了。微软也是这么干的鼻祖，近几年前端JS、TS也得编译编译，最后被浏览器执行，我觉得也都是这么个意思。

那么，在Java生态里，可以编译成字节码被JVM运行的语言有多少呢？我列几个给大家看看：

• Ruby对应的JRuby
• Python对应JPython
• Groovy
• Scala
• Clojure
• Kotlin

上面这几个兄弟，在JVM面前，跟老大哥Java语言基本上也平起平坐了，用起来都算方便的。可以根据自己的经验，比如之前用Ruby、Python什么的可以继续用着；而搞科研的一般Scala用得比较多，不过你要是没听过，基本也就别用了，曲高和寡啊；Kotlin现在如日中天，如果你除了是全栈，也想搞搞全端开发，Kotlin还是很推荐的；我自己呢，Groovy用得比较多，这是一款动静两相宜的语言，用过都说好。

对比一下上一小节的图片，唯独少了JavaScript，这又是怎么回事呢？这个又是个有意思的事了。

Java与JavaScript

网上经常拿雷锋与雷峰塔类比这哥俩，我是觉得说得有点太伤感情了。毕竟Java与JavaScript还是有不少历史渊源的，至少后者当年定名是为了蹭Java的热度来的，有兴趣的小伙伴可以自己查查当年的故事，也是不错的。

更何况现在地球人都知道Java是Oracle的，毕竟Oracle因为Google Android侵权Java而起诉的事情闹得沸沸扬扬也有年头了——9行代码引出的血案。但是JavaScript的商标属于哪个公司，不知道大家都知道么？答案还是Oracle。

上面都是些历史或者商业上的事，跟技术到底有啥关系呢？其实也没啥关系。不过在JVM里面有个叫Nashorn的东西又是一个超神的存在，它居然是一个嵌在JVM里面的JavaScript引擎。说白了，JavaScript代码是可以跑在Java环境下的。来看下面的例子：

var hello = function() {
  print("Hello Nashorn!");
};

hello();

把上面的内容保存到hello.js文件里。如果你的电脑装过Java，可以通过jjs命令调用上面的脚本文件，如图：

惊不惊喜，意不意外？不过如果你安装了最新版本的Java 15的话，就不用了这个功能了，因为这个功能在15里被拿掉了。不过，考虑这个叫Nashorn的引擎从Java 8开始就一直存在了，至少从2014年到现在也有6年了，事实上不论是JavaScript程序员还是Java程序员都极少知道它的存在，建议你现在可以就地问问你身边写Java代码的朋友知不知道这回事；）

结语

好奇心重的小伙伴可能会问了：Nashorn被拿掉之后，Oracle难道就没什么后着？还有前面说Java主要就是JVM解释字节码执行代码的时候，留了个伏笔，暗示还有不一样的玩法存在。下一回，我来给大家讲讲目前一个超级有意思的项目，一个既能颠覆Java自己，又能影响整个语言生态的东西——GraalVM。

但是递归的代价也很明显，在Java中一个最典型的错误就是StackOverflowError，当你对一个factorial（阶乘）递归函数传入参数10000时，就可以遇到它了。

当然，在JavaScript也是会遇到类似的问题的。请看下面这段代码：

function factorial(n) {
    if (n < 2) {
        return 1;
    }
    return n * factorial(n - 1);
}

这就是一段非常典型的递归调用，可以算出n的阶乘。不加优化的情况下，这个函数会在执行的瞬间在内存中持有n份factorial函数的上下文，相应地我们就付出了n份内存的代价。显而易见，这样的程序在空间复杂度的考量上是极不友好的。同时，伴随着每次函数执行成功，返回、出栈，也会对CPU造成一定的压力。

因此，当我们在实战中真的遇到调用深度可能比较深的时候，要想办法避免传统的递归，而转而采用一种叫尾递归的方式来优化代码。

直接解释尾递归的概念的话，比较抽象。我们先来看用尾递归思路优化过后的代码：

function factorial(n, result = 1) {
    if (n < 2) {
        return result;
    }
    return factorial(n - 1, n * result);
}

这里我建议读者朋友们可以尝试在草稿纸上推导一下factorial(3)的执行过程，从而理解上面两种写法都是可以实现目的的。并且我在本文一开始也说了，递归的运用，其实是对程序逻辑的直观表达，更具可读性。这个在我们理解上面两段代码的逻辑时应该能有所体会。第一种写法应该是更好懂一些。

但是第二种写法是对机器极其友好的写法，因为它运用了尾递归，其执行速度就跟普通的循环没什么区别了，并且递归的深度也不受任何限制，也不用担心调用栈溢出或内存耗尽。

像上面第二种写法，在方法结束时出现的表达式，仅仅是自身的函数调用的递归，就是尾递归。

这里比较return n * factorial(n - 1);与return factorial(n - 1, n * result);就可以很好的看出来了，后者是一个纯粹的函数调用，而前者是在函数调用完后仍然做了其他运算。

那么为什么尾递归的执行效率更高呢？这其实是JavaScript解释器帮我们优化的结果。要理解这种优化，我们还需要引入另外一个概念——尾调用，先别着急头大。尾调用的概念更加简单些，维基百科里是这么解释的：

尾调用是指一个函数里的最后一个动作是返回一个函数的调用结果的情形，即最后一步新调用的返回值直接被当前函数的返回结果。

也就是上面的尾递归代码就是一种典型的尾调用，只是因为调用的函数也是自身，所以同时命中了递归的概念。其实JavaScript解释器之所以能够优化尾递归的执行效率，本质上是因为其对尾调用的优化。这种优化过程，说起来稍微有点绕，下面引用一段维基百科中的介绍帮助大家理解：

传统模式的编译器对于尾调用的处理方式就像处理其他普通函数调用一样，总会在调用时创建一个新的栈帧（stack frame）并将其推入调用栈顶部，用于表示该次函数调用。

当一个函数调用发生时，电脑必须“记住”调用函数的位置——返回位置，才可以在调用结束时带着返回值回到该位置，返回位置一般存在调用栈上。在尾调用这种特殊情形中，电脑理论上可以不需要记住尾调用的位置而从被调用的函数直接带着返回值返回调用函数的返回位置（相当于直接连续返回两次）。尾调用消除即是在不改变当前调用栈（也不添加新的返回位置）的情况下跳到新函数的一种优化（完全不改变调用栈是不可能的，还是需要校正调用栈上形式参数与局部变量的信息。）

由于当前函数帧上包含局部变量等等大部分的东西都不需要了，当前的函数帧经过适当的更动以后可以直接当作被尾调用的函数的帧使用，然后程序即可以跳到被尾调用的函数。产生这种函数帧更动代码与 “jump”（而不是一般常规函数调用的代码）的过程称作尾调用消除（Tail Call Elimination）或尾调用优化（Tail Call Optimization，TCO）。尾调用优化让位于尾位置的函数调用跟 goto 语句性能一样高，也因此使得高效的结构编程成为现实。

如果你想了解具体JavaScript解释器是怎么操作的，还可以阅读《JavaScript悟道》这本书的第 143 页。

对于初学者来说，理解不了上面复杂的优化概念也没有关系。我们需要了解的第一是递归的写法和应用场景，第二要明白递归是有代价的，不宜过深，第三就是在合适的时候通过尾递归的方式优化递归函数的执行效率。牢记这三点就足够了。

所以长远来看，对待任何一门语言的SDK环境，我们都应找到一种方式，合理管理不同的SDK版本。这里我强烈建议你在处理自己电脑的开发环境时，有意识地对SDK版本进行管理，而不是直接上网搜了个最新版的安装包，莫名其妙地装，莫名其妙地用。

别担心，这并不难。各路大神已经把轮子给你造好了。

几乎对任何一门语言，只要你在网上搜索：

xxxLanguage version manager

稍加甄别就能得到自己想要的答案。当然，下面我也把常用的一些语言及环境的version manager列了出来，供你享用。

• Java——sdkman👍
• Java——jabba
• Python——Miniforge👍
• Python——Anaconda
• Python——pyenv
• Node——nvm
• Go——gvm
• Ruby——rvm
• PHP——phpbrew

这些工具的使用大同小异，咱们前后端各选一个代表测试一下，下面先来演示node的管理环境nvm。

安装

直接在终端里执行这句话即可：

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.37.2/install.sh | bash

使用

配置完毕后，打开一个新的终端，可以通过nvm ls-remote列出所有可用的node版本了，如果只想查看lts版本，可以通过追加参数实现，nvm ls-remote --lts。确认要安装的版本后，就可以通过nvm install v15.11.0的方式安装了。如果你安装了多个版本，需要在不同版本间切换，只需要简单的使用nvm use v15.11.0就可以进行版本切换了。

更多

关于nvm的使用，还有很多功能有待你来发掘，具体可以执行nvm --help获得更多有用信息。顺便一提，用nvm在ARM架构的Mac电脑上安装node的时候，是基于node的源码进行本地编译安装的，因而你将获得一个ARM版本的node，这点对正在使用M1芯片Mac的小伙伴非常友好。

介绍完了前端，咱们再来看看后端，这里以Java的sdkman进行演示。

安装

也是非常简单，一句话的事。

curl -s "https://get.sdkman.io" | bash

使用

列出可用的Java（JDK）版本，执行sdk list java即可，然后通过执行sdk install java 15.0.2-zulu就可以安装你需要的JDK版本了。

额外说一句，如果是ARM架构的Mac其实是支持x86和ARM两种架构的JDK的，只是前者要经过MacOS的Rosetta2的转译，大部分情况下我们为了追求性能想使用ARM版本的JDK，此时你可以更改sdkman的配置文件，vim ~/.sdkman/etc/config，找到sdkman_rosetta2_compatible那一行，如果设置成true，就仅显示ARM版本的JDK了。

如果你安装了多个版本的JDK，一样可以通过sdk use java 8.0.275-amzn的方式进行切换。如果你想改变全局环境的默认JDK版本，则可以使用sdk default java 8.0.275-amzn进行设置。

其他

sdkman除了支持JDK的版本管理外，还支持Java系的很多技术栈，比如：Gradle、Maven、Kotlin、Groovy等。所以如果你有这方面需求的话，记得执行sdk --help探索更多有用功能哦。

八卦

其实关于sdkman还有一段有意思的往事，曾经sdkman的名字是gvm，专门用来管理一门自2003年就存在的Groovy语言，这门语言跟Java一样，也是运行在JVM（Java虚拟机）上的。

但是后来程序界又迎来了另一个G姓语言——Go，越来越多的小伙伴希望gvm这个名字能见文知意，用作Go的版本管理，而不是去管理一个小众的JVM语言。

于是在2015年，之前维护gvm的小伙伴，宣布了gvm改名为sdkman，从而把gvm的使用权交给了Go Version Manager。

今天我还会介绍一个属于PostgreSQL独有的特性，并且这个特性如同一把钥匙，可以给你打开一个崭新的数据库编程世界，至少我是这么认为的，那么我们赶紧开始吧。

SQL这种东西，本身是面向结果的，而不是面向过程的。这跟传统的编程语言有很大的区别，比如你在使用JavaScript、Java时，这些语言都是基于过程的，你要一步一步通过代码表达式把要做的逻辑过程编写出来，让计算机理解。而SQL是不具备这种能力的，虽然它看起来更高级，你只需要对着数据库说“要有光”(select light from universe)，“光”就来了。

但是不可否认，SQL语言的表达能力是有限的，有些复杂的逻辑我们无法依赖SQL直接实现。比如：计算当前时间是本年度的第几周，这显然已经超出了SQL的能力范围。所以数据库的创造者们，给数据库增加了SQL之外的能力，也就是Procedural Language（过程语言）简称PL。这种过程语言就给开发者提供了传统编程语言的逻辑方式，方便我们在数据里实现一种叫存储过程/函数的东西，进而拓展了数据库本身的逻辑能力。

几乎每个关系型数据库都有自己的PL实现，比如Oracle的PL/SQL、SQL Server的T-SQL，而在PostgreSQL中，提供的就是PL/pgSQL。

这当然也不是什么新鲜事。作为本系列的最后一篇，如果只是讲讲PL/pgSQL未免有些平淡了。

容我给你展示一组清单：

• PL/Java
• PL/PHP
• PL/Perl
• PL/Python
• PL/V8

结合前文所述，您大概已经猜到了。PL/xxx其实就是在说用基于某个语言实现数据库里的存储过程。换句话说，我们可以用自己熟知的高级语言，如：Java、PHP、Python来编写数据库的存储过程。当然了，这个功能是PostgreSQL独有的，别的数据库可享受不到。至于PL/V8，如果你熟悉前端开发的话，应该不难猜出这里说的是JavaScript的V8引擎。

下面我就用PL/Python来演示下，如何用Python3来开发PostgreSQL的存储过程。

首先需要在数据库服务器上安装Python3，然后再安装PostgreSQL的Python3扩展。以ubuntu为例，你需要执行：

apt-get install postgresql-plpython3-13

注意最后的数字13，应该与你本地的PostgreSQL版本相对应。一旦扩展安装关闭，就可以通过一条SQL语句，在数据库中开启对应的扩展功能，你需要执行。

create extension "plpython3u";

下面我们尝试创建一个存储过程（其实称为“函数”可能更准确，不过“存储过程”比“函数”更贴近数据库的专有词汇，为了方便大家理解，我采用了“存储过程”的说法）。

create function pymax(a integer, b integer)
  returns integer
language plpython3u
as $$
if a > b:
    return a
return b
$$;

这是一个简单的比较两个整型大小的存储过程，本身没什么技术含量。需要特别注意的是$$之间的代码段是通过language指定的，当我们指定了plpython3u后，就可以用Python3来编写函数了。

简单执行测试一下:

studypg=# select pymax(2, 3);
 pymax
-------
     3
(1 row)

可以看到函数顺利执行成功了。

聪明的你可能会说，能利用上Python的语言本身固然有点意思，但是实际价值却不大。要是能利用上Python的生态，那才是真的强。答案当然是Yes啦。

众所周知，最近几年Python在机器学习领域可谓是独领风骚。这得益于其多年在数学领域的积累，而numpy这个包，更是所有数学工作者的最爱。下面我就用numpy演示，如何在PostgreSQL中使用Python的强大生态。

首先安装numpy包，执行：

pip3 install numpy

然后我们创建一个存储过程，用来计算以e为底的自然数对数，语句如下：

create or replace function pylog(x float)
  returns float
language plpython3u
as $$
import numpy as np

return np.log(x)
$$;

看下执行结果：

studypg=# select pylog(1);
 pylog
-------
     0
(1 row)

studypg=# select pylog(0.1);
       pylog
-------------------
 -2.30258509299405
(1 row)

非常完美，借助Python生态的力量，我们仅用几句话就实现了原本SQL根本无法实现的功能。其实这还只是冰山一角。笔者甚至通过Python版的数据库函数作为数据库表的触发器，拦截到数据的变化，直接把变化信息转发到MQTT服务器，从而让其他外部应用，可以通过对MQTT消息的订阅，得到数据变化的推送信息。

好了，关于PostgreSQL中神奇的存储过程，就介绍到这里了。其实在PostgreSQL中还有很多神奇的事情值得挖掘，比如触发器，PostgreSQL不光可以拦截DML还可以拦截DDL；还有外部数据源FDW，PostgreSQL中可以引用多种外部数据，包括MySQL、Oracle等主流关系型数据库，甚至还支持Redis、MongoDB等非关系型数据库。总之，只有想不到，没有做不到。

关于PostgreSQL的系列文章至此就结束了。希望我的文章能激发出你对数据库的兴趣，愿这门悠久而强大的技术能够在你的工作中起到一些积极作用。最重要的，请一定要多实践。我们下个话题再见😃

推荐阅读本系列的其他文章：

• 2021年了，你真的应该考虑PostgreSQL了（1）
• 2021年了，你真的应该考虑PostgreSQL了（2）
• 2021年了，你真的应该考虑PostgreSQL了（3）