以下是 Swift 中常用关键字的分类及具体示例，特别补充了 Swift 并发相关内容，帮助理解每个关键字的使用场景：

一、声明修饰符 (Declaration Modifiers)

1. mutating
   用途：允许结构体或枚举的方法修改实例属性。

   struct Counter {
       var count = 0
       mutating func increment() { // 必须声明 mutating
           count += 1
       }
   }
   

2. static
   用途：定义类型级别的属性或方法（结构体/枚举）。

   struct MathUtils {
       static let pi = 3.1415
       static func square(_ x: Int) -> Int { x * x }
   }
   print(MathUtils.pi) // 直接通过类型访问
   

3. class（修饰方法）
   用途：定义类方法，子类可重写。

   class Animal {
       class func sound() { print("Animal sound") }
   }
   class Dog: Animal {
       override class func sound() { print("Woof!") } // 重写类方法
   }
   

4. final
   用途：禁止子类重写或继承。

   final class MyFinalClass {}  // 不可被继承
   class MyBaseClass {
       final func cannotOverride() {} // 不可被重写
   }
   

5. required
   用途：强制子类实现指定初始化方法。

   class Vehicle {
       required init() {} // 子类必须实现
   }
   class Car: Vehicle {
       required init() {} // 必须添加 required
   }
   

二、访问控制 (Access Control)

1. public
   用途：允许跨模块访问。

   public struct APIClient { // 其他模块可访问
       public static let baseURL = "https://api.example.com"
   }
   

2. private
   用途：仅在当前作用域内访问。

   class DataManager {
       private var secretKey = "12345" // 仅在 DataManager 内访问
   }
   

三、类型定义 (Types)

1. class
   用途：定义引用类型（支持继承）。

   class Person {
       var name: String
       init(name: String) { self.name = name }
   }
   

2. struct
   用途：定义值类型（默认不可继承）。

   struct Point {
       var x: Int, y: Int
   }
   

3. enum
   用途：定义枚举类型（关联值、方法）。

   enum NetworkError: Error {
       case timeout(duration: Int)
       case serverError(code: Int)
   }
   

4. protocol
   用途：定义协议（方法/属性约束）。

   protocol Drawable {
       func draw()
   }
   

四、函数与闭包参数 (Function/Closure)

1. inout
   用途：允许函数修改外部变量。

   func swapValues(_ a: inout Int, _ b: inout Int) {
       let temp = a
       a = b
       b = temp
   }
   var x = 1, y = 2
   swapValues(&x, &y) // x=2, y=1
   

2. @escaping
   用途：标记闭包可能在函数返回后执行（如异步操作）。

   func fetchData(completion: @escaping (Data) -> Void) {
       DispatchQueue.global().async {
           let data = Data()
           completion(data) // 异步回调
       }
   }
   

3. rethrows
   用途：函数本身不抛出错误，但参数闭包可能抛出。

   func process(_ closure: () throws -> Void) rethrows {
       try closure() // 仅当闭包抛出错误时，函数才会抛出
   }
   

五、内存管理 (Memory Management)

1. weak
   用途：弱引用（自动置为 nil）。

   class ViewController {
       weak var delegate: DataDelegate? // 避免循环引用
   }
   

2. unowned
   用途：无主引用（假定对象始终存在）。

   class CreditCard {
       unowned let owner: Person // owner 必须比 CreditCard 生命周期长
   }
   

六、错误处理 (Error Handling)

1. throws
   用途：标记函数可能抛出错误。

   func readFile(path: String) throws -> String {
       guard FileManager.default.fileExists(atPath: path) else {
           throw FileError.notFound
       }
       return try String(contentsOfFile: path)
   }
   

2. defer
   用途：延迟执行代码块（常用于清理资源）。

   func writeToFile() {
       let file = openFile()
       defer { closeFile(file) } // 函数返回前执行
       // 写入操作...
   }
   

七、模式匹配与泛型 (Patterns & Generics)

1. where
   用途：添加类型约束。

   func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {
       return array.firstIndex(where: { $0 == value })
   }
   

2. associatedtype
   用途：协议中定义关联类型。

   protocol Container {
       associatedtype Item
       var items: [Item] { get }
   }
   

八、实用工具 (Utilities)

1. lazy
   用途：延迟初始化属性。

   class ImageLoader {
       lazy var cachedImage: UIImage = {
           return UIImage(named: "placeholder")!
       }()
   }
   

2. guard
   用途：提前退出条件不满足的情况。

   func processUser(input: String?) {
       guard let input = input else { return } // 确保 input 非空
       // 安全使用 input
   }
   

3. @discardableResult
   用途：允许忽略函数返回值。

   @discardableResult
   func log(message: String) -> Bool {
       print(message)
       return true
   }
   log(message: "Hello") // 无需接收返回值
   

九、Swift 并发 (Swift Concurrency)

1. async/await
   用途：定义和调用异步函数。

   func fetchData() async throws -> Data {
       let url = URL(string: "https://api.example.com/data")!
       let (data, _) = try await URLSession.shared.data(from: url)
       return data
   }
   

2. Task
   用途：创建并发任务。

   Task {
       let data = try await fetchData() // 在后台线程执行
       print("Received data: \(data)")
   }
   

3. actor
   用途：定义 Actor 类型（线程安全的数据隔离）。

   actor BankAccount {
       private var balance: Double = 0
       func deposit(_ amount: Double) {
           balance += amount
       }
   }
   let account = BankAccount()
   Task {
       await account.deposit(100) // 通过 await 安全访问
   }
   

以下是 Swift 关键字的分类总结表，包含关键字的作用和目的，并补充完善了部分分类和内容，尤其强化了 Swift 并发相关特性：

总结表：Swift 关键字分类、作用及目的

关键补充说明

1. Swift 并发

• async/await：
  用于编写非阻塞异步代码，替代传统的闭包回调，使代码更线性易读。

  func fetchImage() async -> UIImage {
      let data = await downloadData() // 异步等待数据
      return UIImage(data: data)!
  }
  

• actor：
  通过隔离数据访问确保线程安全，避免锁机制。

  actor Counter {
      private var value = 0
      func increment() { value += 1 }
      func getValue() -> Int { value }
  }
  

2. 泛型改进

• some（不透明类型）：
  返回特定协议类型，隐藏具体实现。

  func makeShape() -> some Shape { // 返回某个具体 Shape 类型
      return Circle(radius: 10)
  }
  

• any（存在类型）：
  动态分发协议类型（替代旧版 Protocol 用法）。

  var shapes: [any Shape] = [Circle(), Rectangle()]
  

3. 访问控制

• open vs public：
  • open：允许其他模块继承和重写（仅限类）。
  • public：允许其他模块访问，但不可继承。

总结

通过分类和明确作用，可以更系统地掌握 Swift 关键字的设计意图：

• 安全性：如 weak、unowned 管理内存，throws 明确错误处理。
• 表达力：如 async/await 简化异步代码，actor 解决并发问题。
• 灵活性：如 where 添加泛型约束，@escaping 控制闭包生命周期。

此表可作为快速查阅手册，帮助理解 Swift 语言的核心机制和现代特性。