Swift 常用关键字

一、数据类型

1. 流程控制

2. 访问控制

3. 功能修饰词

4. 错误处理

5. 泛型和类型

6. 其它关键字

二、部分关键字说明

1. guard

2. class 和 struct

struct（结构体）

class（类）

使用场景

3. mutating

4. protocol

定义协议

遵循协议

继承协议

协议作为类型

协议组合

5. extension

6. weak和strong

Strong

Weak

Unowned

官网：Documentationhttps://docs.swift.org/swift-book/documentation/the-swift-programming-language/guidedtour

一、数据类型

class: 定义一个类

enum: 定义一个枚举

struct: 定义一个结构体

protocol: 定义一个协议

typealias: 定义一个类型别名

var: 定义一个变量

let: 定义一个常量

func: 定义一个函数

1. 流程控制

if: 条件语句

else: 条件语句的另一部分

switch: 多选择语句

case: switch 语句中的一个分支

for: for-loop，循环语句

in: for-loop 中用于区间或集合的遍历

while: while-loop，循环语句

repeat: do-while-loop 的开始部分

do: do-while 或 do-catch 的开始部分

break: 跳出循环或 switch 语句

continue: 跳过当前循环的其余部分，进行下一次循环

2. 访问控制

public: 可以被任何地方访问

internal: 只能在当前模块内访问

fileprivate: 只能在当前文件内访问

private: 只能在当前声明里和扩展中访问

3. 功能修饰词

static: 静态方法或属性

class: 类方法或属性（可以被子类重写的 static）

dynamic: 允许动态派发

final: 阻止子类重写

mutating: 允许值类型的方法修改其所属实例

nonmutating: 标记方法在改变值类型属性时不会改变它的状态

lazy: 延迟加载属性直到第一次被调用

optional: 表示协议中的方法或属性是可选的

4. 错误处理

throw: 抛出一个错误

throws: 标记一个函数可能抛出错误

rethrows: 标记一个函数为仅当闭包参数抛出错误时才抛出错误

try: 调用可能抛出错误的函数

catch: 捕获并处理异常

5. 泛型和类型

associatedtype: 定义一个协议的关联类型

where: 指定类型约束条件

Any: 表示任意类型

Self: 表示类型本身

6. 其它关键字

import: 引入外部模块

return: 返回一个函数的结果

self: 指向实例自身

super: 指向父类

nil: 表示空值

true / false: 布尔值

defer: 代码块退出之前执行的代码

guard: 提供一种提前退出的方法

二、部分关键字说明

`1. guard`

guard 语句是一个用于条件检查的控制流结构，它与 if 语句相似，但有一些关键区别。guard 语句被设计用来提前退出一个函数、方法、循环等，如果条件不满足的话。与 if 语句不同的是，guard 语句要求你必须有一个 else 子句，在其中退出当前的作用域，通常使用 return、break、continue 或者 throw。

guard 语句有助于提高代码的清晰度和安全性，因为它要求你在开始执行实际工作之前先处理错误情况或者缺少必要条件的情况。

guard 语句的一般形式是：

guard 条件 else {
    // 如果条件不满足，执行这里的代码
    // 必须退出当前作用域，例如：return, break, continue, throw
}

// 如果条件满足，继续执行后面的代码

guard 的一个常见用例是提前检查方法的参数或者前置条件：

func someFunction(value: Int?) {
    guard let unwrappedValue = value else {
        print("Value must not be nil")
        return
    }

    // 使用 unwrappedValue 作为非可选类型
}

在上面的例子中，如果 value 是 nil，guard 语句的 else 快将会被执行，并且函数会提前退出。如果 value 不是 nil，unwrappedValue 可以在 guard 语句之后安全地使用，因为它已经被解包了。

guard 语句的另一个关键特性是它创建的常量或变量（在上面的例子中是 unwrappedValue）也可以在 guard 外面的代码块中使用，这为它在 Swift 编程中提供了方便的可读性和安全性。

`2. class` 和 `struct`

class 和 struct 都是构建代码的基础结构，但它们有几个关键区别。下面将介绍他们之间的不同之处：

`struct`（结构体）

值类型：当一个结构体实例被赋予一个变量或常量，或者被传递给一个函数时，实际上传递的是该实例的一个副本。
堆栈分配：由于它们是值类型，除非需要，否则结构体通常分配在堆栈上，这通常会比堆分配更有效率。
不支持继承：结构体不能继承另一个结构体或类的特性。
默认逐成员的初始化器：在没有自定义初始化器的情况下，结构体提供一个默认的初始化器，可以通过它的属性名称直接初始化。

`class`（类）

引用类型：当你为一个类实例赋值给一个变量或常量，或者传递到一个函数时，都是传递的同一个实例的引用。
堆分配：类的实例通常是在堆上分配的，这允许更复杂的引用计数和回收策略。
支持继承：类可以从其他类继承方法，属性和其他特性。
需要显式的初始化器：如果类的属性没有默认值，则必须提供一个初始化器。
可以有析构器：类可以有 deinit 方法，它会在类的实例被释放时调用。
可以有多个引用：一个类的实例可以有多个引用指向它，即多个变量或常量可以同时引用同一个实例。
引用计数：由于类是引用类型，Swift使用引用计数来跟踪和管理内存。

下面是一个 struct 和 class 的例子：

// 定义一个结构体
struct Point {
    var x: Int
    var y: Int
}

// 定义一个类
class Vehicle {
    var numberOfWheels: Int
    
    init(numberOfWheels: Int) {
        self.numberOfWheels = numberOfWheels
    }
}

// 创建结构体实例
var p1 = Point(x: 10, y: 20)
// p2将是p1的一个全新副本
var p2 = p1
p2.x = 30 // 只会修改p2的x属性，不会影响p1

// 创建类实例
var car = Vehicle(numberOfWheels: 4)
// truck和car引用的是同一个Vehicle实例
var truck = car
truck.numberOfWheels = 18 // 会改变car中的numberOfWheels，因为他们指向同一个引用

在Swift中，结构体用得非常广泛，Apple建议在可能的情况下优先使用结构体，因为它们更加高效。只有在需要利用引用类型的特征（如继承或生命周期管理）时才使用类。

使用场景

在Swift中，根据具体的设计模式和所需特性，会有不同的场景适合使用class或struct。下面是一些指导原则，帮助决定何时使用哪一个。

使用场景

使用struct的场景

struct通常用于封装少量简单数据值，并且满足以下条件时更适宜使用：

你想要的是值类型的行为，也就是说，你需要的是一个复制的副本而不是同一个实例的引用。
你不需要使用到继承。
实例是相对短暂的或只是数据载体。
包含的数据用于表示一个对象的状态或实质内容。
数据量较小，例如，一个坐标点(x, y)，三维向量(x, y, z)。

使用class的场景

当以下条件满足时，使用class可能会更好：

你需要一个引用类型来共享数据或状态。
需要利用类特有的特性，如继承，析构器，引用计数。
当对象的生命周期需要控制，譬如单例模式或在管理资源时（如文件句柄，网络连接）。
当你要建模的实体需要有一个明确的身份概念，因而两个实体即使属性相同也不被视为相等。

原则和建议

Swift官方文档建议默认使用struct，因为它们更快。大多数情况下，你应该从struct开始，并在需要时迁移到class。这种优先使用struct的策略有以下好处：

值类型更易于推理，因为它们不会被意外更改。
避免了内存泄漏和多线程的问题。
有助于遵循函数式编程范式，函数式编程范式强调不可变性和函数的纯粹性。

上面的建议是一个起点，最终的决定还要考虑具体的应用场景和代码设计。例如，使用UIKit时，需要创建UIView的子类，这必须用class，因为UIKit中的所有视图元素都是以类的形式存在的。而在处理JSON数据模型时，经常使用struct，因为它们通常包含简单的数据属性，没有必要使用继承或复杂的对象引用。

3. mutating

允许值类型的方法修改其所属实例

关键字 mutating 用于标记那些能修改结构体（struct）或枚举（enum）实例状态的方法。由于结构体和枚举是值类型（Value Type），当它们的实例方法尝试修改实例内部的值时，需要用 mutating 关键字进行标识。

这里有个例子来演示如何使用 mutating 关键字：

struct Point {
    var x: Int
    var y: Int
    
    // 使用 mutating 关键字来允许这个方法修改结构体内的值
    mutating func moveBy(x deltaX: Int, y deltaY: Int) {
        x += deltaX
        y += deltaY
    }
}

var point = Point(x: 0, y: 0)
point.moveBy(x: 5, y: 5)
print(point) // 输出: Point(x: 5, y: 5)

在这个例子中，moveBy(x:y:) 方法前面有 mutating 关键字，这个意味着它可以修改 Point 结构体的实例的 x 和 y 属性。如果你移除 mutating 关键字，编译器将会给出一个错误，因为方法尝试改变了结构体的成员变量，而结构体没有被明确允许可以这样做。

需要注意的是，当你尝试在一个常量 (let) 结构体实例上调用一个 mutating 方法时，Swift 会给出编译错误。因为常量结构体的成员不能被改变，就算是在其 mutating 方法中也不可以。

`4. protocol`

protocol 是一种定义一组方法、属性或其他要求的方式，这组要求可以由类、结构体或枚举遵循（实现）。协议类似于其他编程语言中的接口（interfaces），它们声明了代码需遵守的规范，但它们本身并不提供这些要求的实现。遵循（或实现）协议的类型必须实现这些要求，除非要求是可选的。

协议可以要求遵循它的类型具有特定的实例属性和实例方法，类方法，运算属性以及下标。

下面是 protocol 的一些基本用法：

定义协议

protocol SomeProtocol {
    // 定义属性要求
    var mustBeSettable: Int { get set }
    var doesNotNeedToBeSettable: Int { get }
    
    // 定义方法要求
    func someMethod()
    
    // 定义可变方法要求
    mutating func mutate()
    
    // 定义初始化器要求
    init(someParameter: Int)
}

遵循协议

struct SomeStruct: SomeProtocol {
    var mustBeSettable: Int
    var doesNotNeedToBeSettable: Int
    
    func someMethod() {
        // 实现协议中的方法
    }
    
    mutating func mutate() {
        // 实现协议中的可变方法
    }
    
    init(someParameter: Int) {
        // 实现协议中的初始化器
        mustBeSettable = someParameter
        doesNotNeedToBeSettable = someParameter
    }
}

继承协议

协议可以继承，允许你在新协议中添加你自己的要求，或修改父协议的行为。

protocol AnotherProtocol: SomeProtocol {
    // 新的要求
    func anotherMethod()
}

协议作为类型

协议本身可以作为一个类型在函数、方法或集合等中使用，这提供了极大的灵活性。

class SomeClass {
    // 使用协议作为属性的类型
    var delegate: SomeProtocol?
    
    func doSomething() {
        // 在需要的时候使用 delegate
        delegate?.someMethod()
    }
}

协议组合

你可以将多个协议组合在一起，要求一个类型必须同时遵循所有的协议。

protocol Named {
    var name: String { get }
}

protocol Aged {
    var age: Int { get }
}

struct Person: Named, Aged {
    var name: String
    var age: Int
}

func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}

let birthdayPerson = Person(name: "John", age: 20)
wishHappyBirthday(to: birthdayPerson)

在上面的例子中，Person 结构体遵循了 Named 和 Aged 协议。

协议是 Swift 语言的核心特性之一，通过使用协议，你的代码会更加灵活、解耦，并且易于维护和扩展。

5. extension

extension: 扩展现有类型

extension 是一种强大的语言特性，允许你为现有的类、结构体、枚举或者协议类型添加新功能。通过扩展，你可以在不访问原始源代码的情况下增加新的计算属性、实例方法、类方法、初始化器、下标以及特定于协议的实现等。

扩展可以在同一文件或者不同文件中添加，这为组织和模块化代码提供了极大的灵活性和便利。

// 假设这是你无法修改的原始类
class SomeType {
    var property: String = "Some Value"
}

// 使用扩展为 SomeType 添加新功能
extension SomeType {
    // 新的计算实例属性
    var propertyDescription: String {
        return "The property value is '\(property)'"
    }
    
    // 新的实例方法
    func describeProperty() {
        print(propertyDescription)
    }
    
    // 新的初始化器
    convenience init(customValue: String) {
        self.init()
        self.property = customValue
    }
}

let someInstance = SomeType()
someInstance.describeProperty() // 调用扩展中的方法

let customInstance = SomeType(customValue: "Custom Value")
print(customInstance.propertyDescription) // 调用扩展中的计算属性

扩展的一些关键特点包括：

计算属性: 扩展可以为已有类型添加计算实例属性和计算类型属性，但它们不能添加存储属性或者为已有属性添加观察者。
方法添加: 扩展可以为已有类型添加新的实例方法和类方法。
构造器添加: 扩展可以为已有的类添加新的便利初始化器，但不能添加新的指定初始化器或析构器。指定初始化器和析构器必须总是由原始的类实现来提供。
下标添加: 扩展可以为已有类型添加新的下标。
嵌套类型: 扩展可以为已有的类、结构体和枚举添加新的嵌套类型。
协议遵从性: 可以通过扩展让一个已有类型遵循一个或多个协议。如果这样做，扩展必须实现协议所要求的方法。

扩展还可以添加新的泛型方法和条件遵循，这为泛型编程提供了额外的灵活性。

请注意，尽管扩展可以为类型添加新的功能，但它们不允许重写已有功能。此外，扩展不能访问类型的私有或文件私有成员，除非扩展和类型都位于同一个文件中。

6. weak和strong

weak 和 strong 是两种不同的引用类型，用于在内存管理中处理对象之间的关系。在 Swift 的内存管理中，引用计数（Reference Counting）是被用来跟踪和管理应用中对象的生命周期的。

Strong

默认情况下，当一个对象被另一个对象引用时，它是一个强引用（strong reference）。一个强引用会让被引用的对象保持在内存中；只要至少有一个强引用，对象就不会被销毁。这保证了你能安全地访问和使用这个对象。

class ExampleClass {
    var property: String
    
    init(property: String) {
        self.property = property
    }
}

var example: ExampleClass? = ExampleClass(property: "Hello")
// 'example' 持有一个 'ExampleClass' 实例的强引用

只要 example 变量存在，它指向的 ExampleClass 实例的引用计数至少为 1，因此不会被 ARC（Automatic Reference Counting 自动引用计数）回收。

Weak

如果两个对象相互引用，可能会创建一个循环引用，使得它们永远不会被销毁。为此，Swift 提供了 weak 引用。一个弱引用不会增加对象的引用计数，这意味着它不会阻止 ARC 销毁被引用的对象。当对象被销毁时，所有对它的弱引用自动变为 nil。

weak 引用需要被声明为可选类型，因为其指向的对象可以随时被销毁。

class Person {
    let name: String
    var apartment: Apartment?
    
    init(name: String) {
        self.name = name
    }
}

class Apartment {
    let unit: String
    weak var tenant: Person?
    
    init(unit: String) {
        self.unit = unit
    }
}

var john: Person?
var unit4A: Apartment?

john = Person(name: "John")
unit4A = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil
unit4A = nil

在上面的例子中，Person 和 Apartment 相互引用，但由于 Apartment 中的 tenant 属性是弱引用 weak，当我们设置 john 和 unit4A 为 nil 时，它可以阻止循环引用，并允许这两个对象被 ARC 销毁。

Unowned

unowned 引用与 weak 引用类似，它也不增加对象的引用计数，因此不会阻止被引用的对象被销毁。然而，与 weak 引用不同的是，unowned 引用假定它始终指向一个对象，它不会变成 nil。因此，unowned 引用总是被定义为非可选类型。

尽量在你可以确定引用始终指向一个未销毁的对象时使用 unowned。

class Customer {
    let name: String
    var card: CreditCard?
    
    init(name: String) {
        self.name = name
    }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
}

var customer: Customer? = Customer(name: "Alice")
customer!.card = CreditCard(number: 1234567890123456, customer: customer!)

customer = nil // Customer 可以安全地被销毁，因为没有 CreditCard 持有它的强引用

在上面的例子中，尽管 CreditCard 用 unowned 对 Customer 进行引用，Customer 实例仍然可以被销毁，因为它的 card 属性不是一个强引用。

使用 weak 和 unowned 引用的选择取决于你的具体场景，你要确保不会无意间造成循环引用和内存泄漏。一般来说，weak 是适合不能确定引用是否总会指向一个对象，而 unowned 是适合引用总是指向对象并且对象的生命周期内总会存在的情况。