1. 读后概述

阅读完《the swift programming language 中文版》，对swift语言有了初步的认识。在特点是：swift既是项目开发的编程语言，又有脚本语言的特点；在学习上：swift可以在xcode的playground进行编写，所见即所得，非常适合语法学习。
对于swift语言，个人认为就是"站在巨人的肩膀上"的一门语言，及众家之所长。只要熟悉一门主流的编程语言，学习swift的语法都不会太困难。swift和Java语言在某些语法和关键字上面甚是相似，因此在学习时困难不大。当然，对于熟悉C++的同学可以进行类比。
同时，swift是一门新生语言，大部分时代潮流技术也在其中，而且有自己独有的一些技巧在其中，非常值得学习。

2. 语法笔记

2.1 说明

编程语言都是相通的，因此对于基础的语法都是一样。下面主要是对不同的且重要的语法进行了做了笔记，对于已知或类似的语法没有进行细致的说明。

2.2 基础类型

1）变量与常量

swift用let定义常量，用var定义变量。对于数据类型则swift自行推断(类型推倒在C++中相当于auto这个类型占位符一样)。常量在设定后，将不能再更改它的值，变量则可以。

如果需要指定类型，则使用类型注解

var welcomeMessage: String
// 一般不需要写类型注解, 在声明常量或者变量的时候赋了一个初始值，Swift 可以推断出这个常量或者变量的类型

常量和变量名可以包含几乎所有的字符，包括 Unicode 字符：

let π = 3.14159
let 你好 = "你好世界"
let 🐶🐮 = "dogcow"

值得注意的是：

a）在实际项目开发中，应该先定义为let类型，如果需要修改时，再修改类型为var

b）let指的是指向的地址不可修改，但是该对象内容是可修改的(常量不可修改)

2）元组

swift提供了元组：多个值组合成一个复合值。

元组内的值可以是任意类型，并不要求是相同类型。有了元组，函数的返回值就可以返回多个不同类型的值。

// 元组定义
// 1. 字面量定义
var tuple1 = (1, 2.0, "string", true)
// 2. 带参数标签的定义
var tuple2 = (parameter1:int, parameter2:double parameter3:String)
tuple2 = (1, 2.0, "string")
let tuple3 = (parameter1: 1, parameter2: "string")
// 元组取值
// 1. 序列号取值
tuple.0, tuple.1, tuple.2
// 2. 标签取值
tuple2.parameter1
tuple2.parameter2

3）可选类型 optional

一、什么是 Optional？

一句话：可选类型 = 变量「有值」或者「没值（nil）」二选一

在其他语言（OC/Java/JS）里，变量可以随便为空，但 Swift 不允许：

  • 普通类型：必须有值，绝对不能为 nil
  • 可选类型：可以有值，也可以是 nil

定义方式

在类型后面加个 ? 就是可选类型：

// 普通 Int：必须有值
var age: Int = 20

// 可选 Int：可以有值，也可以是 nil
var optionalAge: Int? = nil
optionalAge = 25

Int? 不是新类型，它的本质就是：要么存 Int 值，要么存 nil。

二、为什么要有 Optional？

核心目的：从根源避免「空值崩溃」

比如你访问一个空对象的属性 / 方法，其他语言会直接崩溃，但 Swift 会在编译时就强制你处理空值，让代码更安全。

三、Optional 最核心用法（必掌握）

1. 解包（Unwrapping）

可选类型不能直接使用，必须解包取出里面的值，就像拆礼物盒子：

let name: String? = "小明"

// 错误：不能直接用可选类型
// print(name.count)

// 正确：解包后使用
print(name!.count) // 5
2. 强制解包（!）—— 慎用

! 表示：我确定里面有值，直接给我拿出来⚠️ 风险：如果是 nil，程序直接崩溃

var a: Int? = 10
print(a!) // 10

var b: Int? = nil
// print(b!) // 崩溃！

永远不要随便用！，除非你 100% 确定有值。

3. 可选绑定（最安全、最常用）

用 if let / guard let 安全解包：

let score: Int? = 90

// if let：有值就执行，没值就跳过
if let realScore = score {
    print("分数是：\(realScore)") // 执行
} else {
    print("没有分数")
}

// 也可以直接同名覆盖
if let score = score {
    print(score)
}

guard let（用于函数内，提前退出）：

func printScore(_ score: Int?) {
    // 没值直接 return，不往下走
    guard let score = score else {
        print("无分数")
        return
    }
    
    // 下面可以安全使用 score
    print("分数：\(score)")
}
4. 空合运算符（??）—— 快速给默认值

如果可选值为 nil，就用后面的默认值：

let name: String? = nil
let realName = name ?? "匿名用户"
print(realName) // 匿名用户
5. 可选链（?）—— 安全调用属性 / 方法

连续调用时，任意一步为 nil，整个表达式返回 nil，不会崩溃：

struct Student {
    var name: String?
}

let stu: Student? = Student(name: "小红")

// 可选链调用
print(stu?.name?.count ?? 0)

四、一张表看懂核心语法

表格

写法含义风险
Type?可选类型（可能为 nil）无
变量!强制解包为 nil 则崩溃
if let安全解包无（最推荐）
guard let安全解包 + 提前退出无
??空合默认值无
?.可选链调用无

五、简单总结

  1. Optional = 有值 或 nil
  2. 普通类型不能为 nil，可选类型可以
  3. 取值必须解包
  4. 优先用 if let / guard let，少用 !
  5. 用 ?? 给默认值，用 ?. 安全调用

总结

  • Optional 是 Swift 处理空值的安全方案，用 ? 定义
  • 强制解包 ! 会崩溃，优先用安全解包
  • 日常开发：if let + ?? + ?. 是三件套

你只要记住：Swift 不让你随便用 nil，就是为了保护你不崩溃。

4）值类型与引用类型

值类型：当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。

引用类型：增加引用计数，不进行拷贝。

5）其他

5.1)类型别名:

swift中不使用typedef , 且有等号。

typealias AudioSample = UInt16

5.2)分号:

在swift中不用使用分号, 但是在同一行的两个语句使用分号.

2.3 运算符

1）空合运算符

如果 a 包含一个值就进行解包，否则就返回一个默认值 b

a != nil ? a! : b
// a必须是可选类型
//

2）区间运算符

Swift 提供了几种方便表达一个区间的值的_区间运算符_。

闭区间运算符（a...b）定义一个包含从 a 到 b（包括 a 和 b）的所有值的区间。a 的值不能超过 b。

半开区间运算符（a..<b）定义一个从 a 到 b 但不包括 b 的区间。

单侧区间运算符（a.../...b）可以表达往一侧无限延伸的区间

2.4 字符与字符串

Swift 的 String 和 Character 类型提供了一种快速且兼容 Unicode 的方式来处理代码中的文本内容, 因此可以用任何字符。有趣的是，变量或者常量命名可以采用emoji表情或者汉字。

for character in "Dog!🐶" {
    print(character)
}
// D
// o
// g
// !
// 🐶

在书中介绍了String是基于 Unicode 标量 建立的. 因此需要了解一下Unicode中的码点, utf-8等概念. 在说到 count和objective-c的length返回的值不一样, 也是由于采取的编码格式不同.

String是值类型，对于String的使用不再赘述。

2.5 控制流

1）if

if的条件必须是一个布尔表达式——这意味着像 if score { ... } 这样的直接传值的代码将报错，swift不会隐形地与 0 做对比。

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
  // swift的if语句可以像其他编程语言的一样，格式一样
	// 可以采用之前的写法
	if (score > 50) {
    // ...
  }
	// 也可以不写括号，裸奔~
  if score > 50 {
      teamScore += 3
   } else {
       teamScore += 1
   }
}
print(teamScore)

// guard语句对比：相当于if 相反的执行
if 条件为真 {
  // 执行
}

guard 条件为真else {
  // 执行
}

// guard也可以进行可选绑定
let str : String?;
guard let value = str else {
	//解绑失败，即数据为空进入  
}

2）switch

switch 支持任意类型的数据（区间、元组…………）以及各种比较操作——不仅仅是整数以及测试相等。

case还支持多个条件                      

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.")
}

在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止 switch 语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用 break 语句。如果需要产生case穿透，则可以在case结束后，增加fallthrough

2.6 函数

1）函数的定义

// 定义格式
func funcName(parameters) -> returnType {
    function body
}
// 例子
func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

这里函数的格式类似JavaScript的格式，只是多了返回值类型

2）参数列表

这里重点说明参数列表。

a）参数标签和参数名称：每个函数参数都有一个_参数标签（argument label）以及一个_参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，参数名称来作为它们的参数标签。

// 参数列表
func someFunction(parameterName: Int) {
    // 在函数体内，parameterName 代表参数值
}

b）如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
     // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)

c）当然也可以类似C++使用缺省参数，即就是提供默认值

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) 
// parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) 
// parameterWithDefault = 12

d）当然你还可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。

e）函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为_输入输出参数_

定义一个输入输出参数时，在参数定义前加 inout 关键字，且这个值需要时变量而不是常量

当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

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

3）函数类型

函数类型就像是函数指针一样。实则，还是那句话"万物皆对象"。

在 Swift 中，每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。使用函数类型就像使用其他类型一样。

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}

func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

var mathFunction: (Int, Int) -> Int = addTwoInts

函数类型可以作为参数类型，返回值类型等。

2.7 闭包 

1) 闭包简介

OC有Block，C++有lambda表达式，swift则有闭包。

闭包采用如下三种形式之一：

  • 全局函数是一个有名字但不会捕获任何值的闭包
  • 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
  • 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

闭包的语法

{ (parameters) -> return type in
    statements
}

// 使用
var blockOne:(String, Int) = {(parma1:String, parma2:Int) -> void in 
                             }



// 还有很多精巧的语法
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
// 单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
// 直接通过 $0，$1，$2 来顺序调用闭包的参数，以此类推。
reversedNames = names.sorted(by: { $0 > $1 } )
// Swift 的 String 类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值
reversedNames = names.sorted(by: >)

另外要注意的是闭包表达式是引用类型。

2) 逃逸闭包

什么是 逃逸闭包 @escaping

一句话先戳穿本质：这个闭包，没有在函数结束前立刻跑完，而是 “逃” 出去，晚点再执行 → 就是逃逸闭包。

1. 先分清两种闭包

① 非逃逸（默认）

闭包 在函数结束前就执行完。

func test(closure: () -> Void) {
    closure() // 马上执行
}
// 函数结束时，closure 早就跑完了

② 逃逸 @escaping

闭包 在函数返回之后才执行，它 “逃出” 了函数的生命周期。

func test(closure: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        closure() // 1秒后才执行
    }
}

函数早就结束了，闭包才跑 → 必须加 @escaping

2. 什么时候必须写 @escaping？

只要出现下面任意一种，必须加，不加直接报错：

  • 异步延迟执行：asyncAfter、网络请求回调
  • 把闭包存起来，比如存在属性里：var callbacks: [()->Void]
  • 放到线程队列里稍后执行

只要不是当场立刻执行，就是逃逸。

3. 为什么要特意标记 @escaping？

因为：逃逸闭包会捕获外部对象，可能造成循环引用、内存泄漏。

Swift 要你明确知道：

这个闭包会活得比函数久，你要注意引用问题。

4. 最简单记忆口诀

  • 当场执行 → 不用标
  • 晚点执行、存起来、异步 → 标 @escaping

5. 最经典 iOS 场景

// 网络请求
func requestData(completion: @escaping (String) -> Void) {
    // 去请求...
    DispatchQueue.global().async {
        completion("结果") // 很久之后才回调
    }
}

这里 completion 就是典型逃逸闭包。、

3)闭包捕获

一句话讲明白

闭包捕获 = 闭包可以 “抓住” 外面的变量，带着走，还能继续用。

最简单例子一看就懂

func makeCounter() {
    var count = 0
    
    // 这个闭包会捕获 count
    let closure = {
        count += 1
        print(count)
    }
    
    closure()  // 1
    closure()  // 2
    closure()  // 3
}

makeCounter()
  • count 是外面的变量
  • 闭包把它抓住了
  • 每次调用都会在原来的值上累加

这就叫 捕获。

为什么叫 “捕获”？

因为正常情况下：

  • 函数执行完，里面的局部变量就销毁了但闭包一捕获：
  • 变量不会被销毁
  • 闭包把它 “抓在手里”，只要闭包还在，变量就活着

这就是闭包最强大、也最容易出坑的地方。

再看一个更明显的

func makeIncrementer() -> () -> Int {
    var total = 0

    // 返回一个闭包,这个闭包捕获了 total
    return {
        total += 1
        return total
    }
}

// 拿到这个闭包
let increment = makeIncrementer()

// 函数早就执行完了,但里面的 total 还活着!
print(increment()) // 1
print(increment()) // 2
print(increment()) // 3

结果：1、2、3说明 total 被闭包捕获并保留下来了。

和你刚才学的逃逸闭包连起来

  • 闭包捕获了外部变量
  • 闭包又逃逸了（函数结束后才执行）→ 变量必须活着，不能销毁→ 所以才需要 @escaping 标记

超简总结

闭包捕获 = 闭包可以抓住外面的变量，带着走，一直用。

这就是为什么：

  • 闭包能记住上次的值
  • 闭包会延长变量寿命
  • 用不好会内存泄漏（循环引用）

内存泄露问题

闭包会抓住它用到的外部变量，如果抓住了 self（当前控制器 / 对象），而 self 又持有闭包，就会互相抓住不放 → 内存泄漏。

1. 什么叫 “闭包捕获了 self”？

你在闭包里面写：

view.alpha = 0
tableView.reloadData()

或者

self.view.alpha = 0

只要用到了当前对象的属性、方法，闭包就自动捕获了 self，把 self 牢牢抓住，不让它释放。

2. 循环引用是怎么形成的？

典型场景：ViewController 里用网络请求 / 延时闭包

class MyViewController: UIViewController {
    // 网络请求工具类（self 持有它）
    let manager = NetworkManager()

    func loadData() {
        manager.request { [weak self] data in
            // 这里用到了 self
            self?.title = data
        }
    }
}

结构是这样：

  1. self (VC) → 持有 manager
  2. manager → 持有 逃逸闭包
  3. 闭包 → 捕获并持有 self

结果：

  • self 抓着闭包
  • 闭包抓着 self
  • 谁都不肯放→ 循环引用 → 内存泄漏 → 页面销毁不了

3. 为什么非逃逸闭包一般不会泄漏？

因为：

  • 非逃逸：函数执行完，闭包就销毁
  • 闭包销毁，就不再抓着 self
  • 所以不会形成长久循环

逃逸闭包会被存起来、异步执行、活得很久，所以抓着 self 很久不放，才会泄漏。

4. 解决方案：[weak self]

manager.request { [weak self] data in
    self?.title = data
}
  • [weak self] 意思：闭包你可以抓住 self，但别强引用，要弱引用。
  • 弱引用不会阻止对象释放
  • 页面销毁时，self 变成 nil，闭包抓个空，不会内存泄漏

5. 一句话总结

  • 闭包用到 self → 捕获 self
  • 逃逸闭包被长期持有 + self 持有闭包→ 循环引用，内存泄漏
  • 解决：[weak self] 变成弱引用

最简单记忆口诀

闭包用 self，闭包又逃逸，不加 [weak self]，内存必泄漏。

4)尾随闭包


如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以将闭包书写在函数圆括号之后，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函数体部分
}
func mySug() {
    // 以下是不使用尾随闭包进行函数调用
    someFunctionThatTakesAClosure(closure: {
        // 闭包主体部分
    })

    // 以下是使用尾随闭包进行函数调用
    someFunctionThatTakesAClosure() {
        // 闭包主体部分
    }
}

2.8 枚举、结构体、类

1）枚举

Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。

// 枚举的定义
enum SomeEnumeration {
    // 枚举定义放在这里
    // 使用 case 关键字来定义一个新的枚举成员值。
}
// 枚举的定义例子
enum CompassPoint {
    case north
    case south
    case east
    case west
}
// 可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}
// 枚举的遍历
enum TestEnum:CaseIterable {
  
}
for item in TestEnum.allCases {
  
}

2）结构体与类

定义语法：

struct SomeStructure {
    // 在这里定义结构体
}
class SomeClass {
    // 在这里定义类
}

// 结构体是值类型
// 类是引用类型
// 结构体也可以当类来使用，但是不建议
// 还要很多相同点, 但是class就是定义类的, 不过多赘述struct

注意：

  • 继承允许一个类继承另一个类的特征
  • 类型转换允许在运行时检查和解释一个类实例的类型
  • 析构器允许一个类实例释放任何其所被分配的资源
  • 引用计数允许对一个类的多次引用

3）类的属性与方法

a）属性

swift中类的属性分为存储属性与计算属性。

存储属性就是存储在特定类或结构体实例里的一个常量或变量。

class FixedLengthRange {
    var firstValue: Int
    let length: Int
}

计算属性就是不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

swift还有一个类属性，类似C++的static成员。

使用关键字 static 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 class 来支持子类对父类的实现进行重写。

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}
enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}

b）方法

实例方法同普通方法一样，方法体可以使用self关键字

类方法在方法的 func 关键字之前加上关键字 static，来指定类型方法。类还可以用关键字 class 来指定，从而允许子类重写父类该方法的实现。

2.9 类的构造与析构

1）基础说明


类的构造与析构和C++的构造与析构类似，唯一不同的可能就是在语法上不同了。
比如：全缺省构造，默认构造等等。
列出几个比较重要的构造函数语法：

// 默认构造
init() {
  // 在构造函数中，如果没有明确super.init()，那么系统会自动添加
  // 使用KVC构造时，一定要先super.init()
}
// 参数构造
init(parmaterNmae : type) {
	// 有歧义则加self
  self.xxx = parmaterNmae;
}
init?(parmaterNmae : type){
  // 可能返回空，获取时为可选类型
}
// 必要构造
required init(parmaterNmae : type) {
}

下面挨个举例：

class Color {
    let red, green, blue: Double
    init () {
    // 默认构造
    }
    init(red: Double, green: Double, blue: Double) {
    // 逐一成员构造器
        self.red   = red
        self.green = green
        self.blue  = blue
    }
    init(white: Double) {
    // 形参构造：同函数的参数标签一样
        red   = white
        green = white
        blue  = white
    }
    
}

2）构造代理


构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能避免多个构造器间的代码重复。在《effective OC2.0》中也说到，在设置构造函数的时候，提供一个基础构造方法，共其他构造使用。
由于结构体以及枚举为值类型，无法继承，它们只能代理给自己的其它构造器。

1. 先讲：Swift 构造函数（初始化）

就是 创建对象时自动调用的方法，用来给属性赋值。

class Person {
    var name: String
    var age: Int
    
    // 构造函数（初始化方法）
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

// 创建对象时自动调用 init
let p = Person(name: "Tom", age: 20)
  • 名字固定叫 init
  • 没有 func
  • 负责保证所有非可选属性必须有值

2. 再讲：代理（Delegate）

代理 = 把自己不想干、干不了的事，交给别人去干。

比如：

  • 学生（自己）不想写作业
  • 找个家教（代理）帮你写

标准结构三步走

  1. 定义协议（规定要做什么事）
  2. 设置代理属性
  3. 让代理去做事
// 1. 协议：规定要做的事
protocol HomeworkDelegate: AnyObject {
    func doHomework()
}

// 学生类（自己）
class Student {
    // 2. 代理属性
    weak var delegate: HomeworkDelegate?
    
    func needHomework() {
        // 3. 让代理去做
        delegate?.doHomework()
    }
}

// 家教（代理）
class Tutor: HomeworkDelegate {
    func doHomework() {
        print("家教在写作业")
    }
}

使用

let tutor = Tutor()
let student = Student()

student.delegate = tutor  // 设置代理
student.needHomework()    // 学生喊一声，家教去做

3.  “构造代理” 是什么？

一般有两种理解：

① 在构造函数里设置代理

class Student {
    weak var delegate: HomeworkDelegate?
    
    // 构造时直接传代理
    init(delegate: HomeworkDelegate) {
        self.delegate = delegate
    }
}

// 一行创建+设置代理
let s = Student(delegate: Tutor())

② 用代理模式来做初始化逻辑

比如创建某个复杂对象时，把配置交给代理。这个很少单独叫 “构造代理”，一般就是代理模式。

超简总结

  • 构造函数 init：创建对象时赋值用
  • 代理 Delegate：把事情交给别人做
  • 构造代理：多半是指 init 里直接设置代理
struct Rect {
    var origin = Point()
    var size = Size()
    init() {}

    init(origin: Point, size: Size) {
        self.origin = origin
        self.size = size
    }

    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

类则不同，它可以继承自其它类。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。
针对类的构造器，有两种，就是指定构造器和便利构造器。(swift针对构造器的设计是真的够啰嗦的)。
简单总结下：
如果一个类是基类，那么构造器就和前面一样写就可以，未初始化的属性一定要初始化。
重点是不是基类的情况：
子类的指定构造器一定要先初始化自己类中的属性，然后再调用父类的指定构造器。重写同理。
便利构造器就是你可以提供简化一下参数，然后调用类中的指定构造器。
类是不继承构造器的。如果触发以下情况，会自动继承：

  1. 前提是你为子类中引入的所有新属性都提供了默认值
  2. 如果子类没有定义任何指定构造器，它将自动继承父类所有的指定构造器。
  3. 如果子类提供了所有父类指定构造器的实现——无论是通过规则 1 继承过来的，还是提供了自定义实现——它将自动继承父类所有的便利构造器。

3）可失败构造


给构造器传入无效的形参，或缺少某种所需的外部资源，又或是不满足某种必要的条件的时候可以构造失败。

class Document {
    var name: String?
    // 该构造器创建了一个 name 属性的值为 nil 的 document 实例
    init() {}
    // 该构造器创建了一个 name 属性的值为非空字符串的 document 实例
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}

4）必要构造器


在类的构造器前添加 required 修饰符表明所有该类的子类都必须实现该构造器

class SomeClass {
    required init() {
        // 构造器的实现代码
    }
}

// 在子类重写父类的必要构造器时，必须在子类的构造器前也添加 required 修饰符
// 表明该构造器要求也应用于继承链后面的子类。
// 在重写父类中必要的指定构造器时，不需要添加 override 修饰符

class SomeSubclass: SomeClass {
    required init() {
        // 构造器的实现代码
    }
}

5）析构


析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字 deinit 来标示，类似于构造器要用 init 来标示。

deinit {
    // 执行析构过程
}

2.10 属性监听器

class SomeClass : NSObject {
  var name : String {
    // 属性即将改变
    willSet {
      
    }
    // 属性已经改变
    didSet {
      
    }
  }
}
// 即使设置相同的值仍会触发
// 不能同setter同时存在
//

2.11 类的继承

面向对象语言的三大特性之一继承，作为复用代码的一种手段，在swift中也是一样。swift和OC不一样，OC中所有的类都是都是基于NSObject的。但是Swift 中的类并不是从一个通用的基类继承而来的。如果你不为自己定义的类指定一个超类的话，这个类就会自动成为基类。
继承的基础语法：

class SomeClass: SomeSuperclass {
    // 这里是子类的定义
}

举个例子：

// 父类
class Vehicle {
    var currentSpeed = 0.0
    var description: String {
        return "traveling at \(currentSpeed) miles per hour"
    }
    func makeNoise() {
        // 什么也不做——因为车辆不一定会有噪音
    }
}
// 子类
class Bicycle: Vehicle {
    var hasBasket = false
}

重写

// 重写
// 重写某个特性，你需要在重写定义的前面加上 override 关键字。
class Train: Vehicle {
    override func makeNoise() {
        print("Choo Choo")
    }
}

// 如果你在重写属性中提供了 setter，那么你也一定要提供 getter。
// 如果你不想在重写版本中的 getter 里修改继承来的属性值，
// 你可以直接通过 super.someProperty 来返回继承来的值，其中 someProperty 是你要重写的属性的名字。

final关键字
你可以通过把方法，属性或下标标记为 final 来防止它们被重写，只需要在声明关键字前加上 final 修饰符即可（例如：final var、final func、final class func 以及 final subscript）。
任何试图对带有 final 标记的方法、属性或下标进行重写的代码，都会在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final。
可以通过在关键字 class 前添加 final 修饰符（final class）来将整个类标记为 final 。这样的类是不可被继承的，试图继承这样的类会导致编译报错。

2.12 扩展

给已有的类、结构体、枚举、协议，偷偷加功能，而且不用继承、不用改源码。

1. 最直观例子

给系统的 String 加个计算属性：

// 给 String 写扩展
extension String {
    // 新增属性：是否为空字符串
    var isNotEmpty: Bool {
        return !isEmpty
    }
}

// 所有字符串都能用了
let str = "hello"
print(str.isNotEmpty) // true

系统原本没有 isNotEmpty，你一扩展，全世界的 String 都能用。

2. 能加什么？不能加什么？

✅ 可以加：

  • 方法（func）
  • 计算属性（var，只能 get，不能存值）
  • 便利构造器
  • 下标
  • 遵守协议

❌ 不能加：

  • 存储属性（不能加真正的变量，比如 var a: Int）
  • 重写原有方法（重写要用继承）

3. 给你自己的类扩展

class Person {
    var name = "张三"
}

// 扩展 Person
extension Person {
    func sayHi() {
        print("我是 \(name)")
    }
}

let p = Person()
p.sayHi()

4. 最常用场景：把协议实现丢进 extension

这是 iOS 标准写法，让代码更干净：

class VC: UIViewController {}

// 单独写扩展，专门实现协议
extension VC: UITableViewDataSource {
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return 10
    }
}

好处：主类代码清爽，功能按模块分开。

5. 给协议加默认实现（超级强）

protocol Run {
    func run()
}

// 扩展协议：给默认实现
extension Run {
    func run() {
        print("跑起来了")
    }
}

// 遵守协议的类，不用实现 run 也能用
struct Person: Run {}

let p = Person()
p.run() // 跑起来了

一句话总结

  • extension = 无侵入式扩展功能
  • 不用继承、不用改源码
  • 能加方法、计算属性、协议实现
  • 不能加存储属性

2.13 协议

协议 = 规矩 / 合同只规定要做什么，不写怎么做。谁遵守这个协议，谁就必须实现这些功能。

1. 最简单的协议长这样

protocol Animal {
    func eat()
    func run()
}
  • 只定义方法、属性
  • 没有具体实现
  • 像个 “任务清单”

2. 类 / 结构体 / 枚举 遵守协议

谁遵守，谁就要把清单里的任务全部实现。

class Dog: Animal {
    func eat() {
        print("狗吃骨头")
    }
    func run() {
        print("狗跑")
    }
}

class Cat: Animal {
    func eat() {
        print("猫吃鱼")
    }
    func run() {
        print("猫跳")
    }
}

3. 协议可以当 “类型” 用

这是协议最强大的地方：统一类型，多态

let pet: Animal = Dog()
pet.eat() // 狗吃骨头

不管是猫是狗，只要是 Animal，都能调用 eat()、run()。

4. 协议里可以定义属性

必须注明 { get } 或 { get set }

protocol Person {
    var name: String { get set }
    var age: Int { get }
}

实现：

struct Student: Person {
    var name: String
    var age: Int
}

5. 代理模式（iOS 最常用！）

协议 = 老板下任务代理 = 员工去干活

// 老板规定任务
protocol WorkDelegate: AnyObject {
    func doWork()
}

class Boss {
    weak var delegate: WorkDelegate?
    func startWork() {
        delegate?.doWork()
    }
}

// 员工遵守协议，完成任务
class Staff: WorkDelegate {
    func doWork() {
        print("员工在干活")
    }
}

使用：

let boss = Boss()
let staff = Staff()

boss.delegate = staff
boss.startWork() // 员工在干活

6. 为什么要 : AnyObject？

protocol WorkDelegate: AnyObject {}

表示：这个协议只能被类遵守目的：可以用 weak，防止循环引用、内存泄漏

7. 协议扩展（超级好用）

可以给协议默认实现，遵守者不用自己写：

extension Animal {
    func eat() {
        print("吃东西")
    }
}

最精简总结（必记）

  1. 协议 = 规定要做什么，不实现
  2. 遵守协议 = 必须实现里面的方法 / 属性
  3. 协议可以当类型，实现多态
  4. iOS 里 90% 用来做代理 Delegate
  5. 代理用 weak + AnyObject 防循环引用

2.14 泛型

1）基础语法

一句话核心

泛型 = 万能占位符先不指定具体类型，用一个字母（比如 T）代替，用到的时候再自动变成真实类型。目的：写一份代码，适配所有类型。

1. 先看没泛型有多麻烦

比如你想写个 “交换两个数” 的函数：

// 交换 Int
func swapInt(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

// 交换 String 还要再写一遍！
func swapString(_ a: inout String, _ b: inout String) {
    let temp = a
    a = b
    b = temp
}

类型不一样，就要写 N 份重复代码。

2. 用泛型，一份搞定所有类型

func swap<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}
  • <T> 就是泛型占位符：随便什么类型都行
  • 调用时自动识别类型：
var a = 10
var b = 20
swap(&a, &b)  // T 自动变成 Int

var s1 = "hello"
var s2 = "world"
swap(&s1, &s2) // T 自动变成 String

一套代码，通吃 Int、String、Double、Person……

3. 泛型最常用：容器类（Array、Dictionary 本身就是泛型）

// Array 就是泛型结构体
let arr: Array<Int> = [1,2,3]
let arr2: [Int] = [1,2,3] // 语法糖

你自己写个万能栈：

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

// 整数栈
var intStack = Stack<Int>()
// 字符串栈
var strStack = Stack<String>()

4. 泛型约束（限制 T 是什么类型）

比如要求 T 必须遵守 Equatable：

func isEqual<T: Equatable>(_ a: T, _ b: T) -> Bool {
    return a == b
}
  • T: Equatable 表示：T 必须是可比较相等的类型不是什么乱七八糟的类型都能传。

5. 最简单总结

  1. 泛型 = 万能类型占位符 <T>
  2. 写一次代码，支持所有类型，不重复
  3. Array、Dictionary、Set 全是泛型

最直白比喻

  • 普通函数：只收一种类型
  • 泛型函数：什么类型都收，自己适配

由于时间关系，总结的比较草率，还有很多需要补充的地方。对于swift语言，只是对语法进行了简单的学习。其核心思想还需进一步的深入学习——实践+概念。

# ios # swift # 学习
Logo
乐奇 Rokid 开放社区

更多推荐

cover

【应用方案】智能眼镜一站式解决方案：交互与感知技术赋能下一代穿戴体验

avatar 乐奇 Rokid 开放社区
cover

全球 AI / 科技简报｜2026 年 9 月 4 日

avatar 乐奇 Rokid 开放社区

朱老师教你玩转 AIUI 开源项目 — 上传到 GitHub 即刻参与开源协作

如果说 AIUI Sports Agents 适合用来学习“运动数据、设备验证和平台提审如何分工”，EverMind 则是另一个很适合新手观察的开源案例：它把长期记忆框架、命令行工具、Agent 插件和公开文档拆成清晰的模块，让读者能够沿着 README、Quick Start、架构说明和贡献指南逐层理解一个项目。检查与收束读第八章。填写项目问卷时，进入 Issues → New issue，选择

avatar 乐奇 Rokid 开放社区