Swift interview

二、Swift 基础

1. struct vs class

1. struct 和 class 的核心区别（值类型 vs 引用类型、内存管理、继承等）？
2. struct 自动生成 init，class 必须手动初始化？
3. mutating 关键字的作用？
4. final 关键字的作用？

2. Optional

1. Optional 的本质是什么？（enum：.none 和 .some(Wrapped)）
2. ??、if let、guard let、optional chaining 的区别？
3. @unwrapped 和隐式解包（String!）的区别？

3. 协议 & 泛型

1. Protocol 的 associatedtype 是什么？如何约束？
2. where 子句在泛型中的作用？
3. Self 和 self 的区别？

4. 闭包

1. 逃逸闭包（@escaping）和非逃逸闭包的区别？
2. [weak self] 和 [unowned self] 的区别？
3. lazy var + 闭包初始化？

5. 多线程（Swift）

1. GCD 在 Swift 中的使用（DispatchQueue、DispatchGroup）？
2. async/await 和 Task 的使用？
3. @MainActor 的作用？

6. Codable

1. class 可以遵守 Codable 吗？如何实现？
2. 如何用 CodingKeys 映射 JSON 字段？
3. 如何处理接口返回的 Int/String 兼容问题？

7. 内存管理（Swift）

1. weak、unowned、strong 的区别？
2. 循环引用在 Swift 中的常见场景及解决方案？
3. deinit 的作用？

8. 响应式编程

1. Combine 的核心组件（Publisher、Subscriber、Subject）？
2. RxSwift 的常见操作符（map、filter、flatMap）？

3. Observable 和 Future 的区别？

   Swift

4. struct 和 class 的区别？

5. struct、class 初始化时属性/init 的注意事项？
6. class 是否可以服从 Codable 协议？
7. 如何利用 Codable 协议兼容接口字段名和类型？
8. Optional 的本质是什么？
9. Swift 是值语义还是引用语义？
10. 什么是 mutating 关键字？

11. enum 的高级用法有哪些？关联值、递归枚举？

    Swift async/await

12. Swift 中如何使用 async/await 实现并发任务？

13. async let 和 TaskGroup 的区别与使用场景？
14. actor 是什么？如何解决数据竞争？

    七、常用框架

Combine

1. Combine 的核心概念（Publisher/Subscriber/Operator）？
2. @Published 和 ObservableObject 有什么区别？
3. 如何取消订阅？AnyCancellable？

RxSwift

1. 什么是 Observable？Observer？
2. 如何使用 Subjects？（Publish/Behavior/Replay/Async）
3. DisposeBag 有什么用？
4. RxSwift 与 Combine 有哪些异同？

---

八、高阶 Swift 语法

1. 泛型如何定义？如何约束？
2. 如何实现一个泛型缓存类？
3. Protocol 和 associatedtype 的高级用法？
4. Swift 的闭包语法和使用？
5. 什么是逃逸闭包（@escaping）？
6. 高阶函数：map/filter/reduce/flatMap/compactMap 的用法？
7. 如何使用 Swift 的 Result 类型处理异步任务？

   1. Swift 高阶特性

8. 泛型与协议

   • 如何设计一个支持泛型缓存的 Repository 模式？
   • associatedtype 与 some、any 关键字的区别？Swift 5.7 的不透明类型优化了什么？
   • 为什么 Protocol 不能直接作为类型使用？如何用类型擦除（Type Erasure）解决？

9. 内存管理

   • Swift 的 unowned 和 weak 在底层是如何实现的？何时会导致野指针？
   • withUnsafeBytes 和 withMemoryRebound 的使用场景？如何安全操作指针？

10. 并发模型

    • actor 的隔离机制如何实现？与 @MainActor 的线程调度差异？
    • Sendable 协议的作用？如何让自定义类型支持跨线程传递？

六、实战编码题

1. 实现线程安全的 LRU 缓存

   final class LRUCache<Key: Hashable, Value> {
       private let lock = NSLock()
       private let capacity: Int
       private var cache: [Key: Value] = [:]
       private var order: [Key] = []
       
       init(capacity: Int) { self.capacity = capacity }
       
       func get(_ key: Key) -> Value? {
           lock.lock()
           defer { lock.unlock() }
           guard let value = cache[key] else { return nil }
           order.removeAll { $0 == key }
           order.append(key)
           return value
       }
       
       func set(_ key: Key, value: Value) {
           lock.lock()
           defer { lock.unlock() }
           if cache[key] == nil && cache.count >= capacity {
               let removedKey = order.removeFirst()
               cache[removedKey] = nil
           }
           cache[key] = value
           order.append(key)
       }
   }

2. 基于 Combine 实现防抖搜索

   import Combine
   
   class SearchViewModel {
       @Published var query: String = ""
       private var cancellables = Set<AnyCancellable>()
       
       init() {
           $query
               .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
               .removeDuplicates()
               .sink { [weak self] query in
                   self?.performSearch(query: query)
               }
               .store(in: &cancellables)
       }
       
       private func performSearch(query: String) {
           print("Searching for: \(query)")
       }
   }

---

十、Swift 进阶机制

1. Property Wrapper 的原理和常见用法（@State、@Published、@UserDefault 等）？
2. Swift 的访问控制（open、public、internal、fileprivate、private）有哪些场景？
3. Swift 的模块化开发方式？如何拆分模块？
4. 如何实现依赖注入（DI）？有无使用框架（如 Resolver、Swinject）？