Ios Dev Skill

iOS/macOS 开发技能（SwiftUI + UIKit）与 Swift 6.3 语言权威参考合集。覆盖 MVVM/Cocoa 架构、网络层（URLSession/async-await）、状态管理（@State/@Published/Combine）、依赖注入、 Navigation、性能优化、单元测试/UI 测试、持久化、App 分发，以及 Swift 完整语法（类型系统/集合/闭包/协议/泛型/并发）。当用户询问 iOS 开发、SwiftUI、Swift 语法、 Swift 语言任何相关内容时触发。

yhongm@yhongm

Install

openclaw skills install @yhongm/ios-dev-skill

iOS 开发技能

iOS/macOS 应用开发技能，基于 SwiftUI + UIKit。

核心架构

MVVM 架构（SwiftUI）

text

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│    View     │ ←── │  ViewModel  │ ←── │   Model    │
│  (SwiftUI)  │     │ (ObservableObject) │   │   (Struct) │
└─────────────┘     └──────────────┘     └─────────────┘
     @StateObject          @Published           @State
     @ObservedObject       @State               let

数据流向：

View 订阅 ViewModel 的 @Published 属性
ViewModel 处理业务逻辑，调用 Model
Model 定义数据结构
状态变化自动触发 View 重新渲染

UIKit 架构对比

模式	适用场景	复杂度
MVC	简单页面	低
MVVM	中等复杂度	中
MVP	需要解耦 View	中
VIPER	大型模块化	高
Coordinator	导航复杂	高

iOS 生命周期与状态管理

App 生命周期

状态	触发时机	典型用途
`didFinishLaunching`	App 启动完成	初始化配置
`sceneWillEnterForeground`	从后台恢复	刷新数据
`sceneDidBecomeActive`	获得焦点	恢复动画
`sceneWillResignActive`	失去焦点	暂停任务
`sceneDidEnterBackground`	进入后台	保存状态

SwiftUI 状态修饰符

swift

@State       // 值类型，值语义
@StateObject  // 引用类型，ObservableObject
@ObservedObject // 外部提供的 ObservableObject
@EnvironmentObject // 环境注入的共享状态
@Published   // 属性观察器，自动触发更新

状态管理对比

方式	适用场景	生命周期
`@State`	视图私有	随视图
`@StateObject`	模型对象	随视图
`@EnvironmentObject`	跨视图共享	随 App
`@AppStorage`	UserDefaults	持久

数据持久化

方案对比

方案	适用数据量	类型	线程安全
`UserDefaults`	< 1MB	Key-Value	✅
FileManager	任意	文件	❌
`PropertyListEncoder`	中等	结构化	❌
`SQLite.swift`	大型	关系型	✅
Core Data	超大型	对象图	✅
Realm	超大型	对象	✅

UserDefaults

swift

@AppStorage("username") var username = ""
@AppStorage("theme") var theme = "light"

SQLite.swift

swift

import SQLite

let db = try Connection("db.sqlite3")
let users = Table("users")
let id = Expression<Int64>("id")
let name = Expression<String>("name")

try db.run(users.insert(name <- "Alice"))
for user in try db.prepare(users) {
    print(user[name])
}

网络与 API

URLSession 封装

swift

enum APIError: Error {
    case invalidURL, noData, decodingError, networkError(Error)
}

func fetch<T: Decodable>(_ type: T.Type, from url: String) async throws -> T {
    guard let url = URL(string: url) else { throw APIError.invalidURL }
    let (data, _) = try await URLSession.shared.data(from: url)
    do {
        return try JSONDecoder().decode(T.self, from: data)
    } catch {
        throw APIError.decodingError
    }
}

SwiftUI 网络图片

swift

AsyncImage(url: URL(string: "https://...")) { phase in
    switch phase {
    case .empty: ProgressView()
    case .success(let image): image.resizable()
    case .failure: Image(systemName: "photo")
    @unknown default: EmptyView()
    }
}

App 分发与发布

构建配置

配置	用途	代码签名
Debug	开发调试	Development
Release	App Store	Distribution
Ad Hoc	测试分发	Distribution

发布检查清单

App Icon 1024×1024
启动屏（Splash Screen）
Info.plist 权限说明
隐私政策 URL
TestFlight / App Store Connect 上传
App Store 截图（6.7 / 6.5 / 5.5 英寸）

常用权限声明

权限	Info.plist Key
相机	`NSCameraUsageDescription`
照片	`NSPhotoLibraryUsageDescription`
位置	`NSLocationWhenInUseUsageDescription`
通知	推送证书配置

SwiftUI 基础

页面结构

swift

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup { ContentView() }
    }
}

struct ContentView: View {
    @State private var count = 0

    var body: some View {
        VStack(spacing: 20) {
            Text("Count: \(count)")
                .font(.largeTitle)
            Button("Increment") { count += 1 }
                .buttonStyle(.borderedProminent)
        }
    }
}

组件层级

text

Window → ViewController → View → Subviews
NavigationController → ViewController → TableView → Cell
TabBarController → ViewController × N → NavigationController

状态管理

状态类型	SwiftUI	UIKit	生命周期
本地临时	@State	local var	视图存在期间
页面级	@State	view property	页面存在期间
应用级	@AppStorage	UserDefaults	跨页面持久化
全局共享	@StateObject	Singleton	应用生命周期

SwiftUI 状态装饰器

swift

// @State — 值类型，组件私有
@State private var text = "Hello"

// @Binding — 双向绑定
@Binding var isPresented: Bool

// @StateObject — 引用类型，视图拥有
@StateObject private var viewModel = ViewModel()

// @ObservedObject — 引用类型，外部传入
@ObservedObject var viewModel: ViewModel

// @EnvironmentObject — 环境注入的全局状态
@EnvironmentObject var authService: AuthService

// @AppStorage — 持久化
@AppStorage("username") var username = ""

UIKit 状态

swift

// 局部变量
class ViewController: UIViewController {
    private var data: [String] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        data = loadData()
    }
}

// 视图属性
class ViewController: UIViewController {
    var initialData: [String] = []
}

// UserDefaults
UserDefaults.standard.string(forKey: "username")

// Singleton
let shared = NetworkManager.shared

Navigation 导航模式

SwiftUI NavigationStack（推荐）

swift

NavigationStack {
    List(users) { user in
        NavigationLink(destination: UserDetailView(user: user)) {
            Text(user.name)
        }
    }
}

UIKit 导航

swift

// 导航控制器
let nav = UINavigationController(rootViewController: HomeVC())
nav.pushViewController(detailVC, animated: true)
nav.popViewController(animated: true)

// TabBar 切换
UITabBarController()
  ├─ UINavigationController(首页)
  ├─ UINavigationController(发现)
  └─ UINavigationController(我的)

网络层

SwiftUI + async/await

swift

actor NetworkService {
    static let shared = NetworkService()

    func fetch<T: Decodable>(_ type: T.Type, from url: URL) async throws -> T {
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode(T.self, from: data)
    }
}

// 使用
Task {
    let users = try await NetworkService.shared.fetch([User].self, from: url)
}

UIKit + async/await

swift

class NetworkManager {
    static let shared = NetworkManager()

    func request<T: Decodable>(_ type: T.Type, endpoint: String) async throws -> T {
        guard let url = URL(string: endpoint) else {
            throw NetworkError.invalidURL
        }
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode(T.self, from: data)
    }
}

URLSession 完整示例

swift

import Foundation

struct User: Codable, Identifiable {
    let id: String
    let name: String
    let email: String
}

enum NetworkError: Error {
    case invalidURL
    case requestFailed
    case decodingFailed
    case noData
}

class APIClient {
    private let baseURL = "https://api.example.com"
    private let session: URLSession

    init() {
        let config = URLSessionConfiguration.default
        config.timeoutIntervalForRequest = 30
        self.session = URLSession(configuration: config)
    }

    func get<T: Codable>(_ type: T.Type, path: String) async throws -> T {
        guard let url = URL(string: baseURL + path) else {
            throw NetworkError.invalidURL
        }

        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        let (data, response) = try await session.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.requestFailed
        }

        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase

        do {
            return try decoder.decode(T.self, from: data)
        } catch {
            throw NetworkError.decodingFailed
        }
    }

    func post<T: Codable, B: Encodable>(_ type: T.Type, path: String, body: B) async throws -> T {
        guard let url = URL(string: baseURL + path) else {
            throw NetworkError.invalidURL
        }

        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        let encoder = JSONEncoder()
        encoder.keyEncodingStrategy = .convertToSnakeCase
        request.httpBody = try encoder.encode(body)

        let (data, response) = try await session.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.requestFailed
        }

        return try JSONDecoder().decode(T.self, from: data)
    }
}

依赖注入

SwiftUI Environment 注入

swift

struct ContentView: View {
    @EnvironmentObject var authService: AuthService
    var body: some View { ... }
}

// App 层级注入
ContentView()
    .environmentObject(AuthService())

UIKit Protocol 注入

swift

protocol NetworkServiceProtocol {
    func fetchUsers() async throws -> [User]
}

class ViewModel {
    let networkService: NetworkServiceProtocol
    init(networkService: NetworkServiceProtocol = NetworkService.shared) {
        self.networkService = networkService
    }
}

Combine 响应式编程

Publisher 与 Subscriber

swift

import Combine

// Publisher
let publisher = PassthroughSubject<String, Never>()

// Subscriber
let cancellable = publisher
    .filter { $0.count > 3 }
    .map { $0.uppercased() }
    .sink { print($0) }

// Future + Promise
func fetchUser(id: Int) -> Future<User, Error> {
    Future { promise in
        // 异步操作
        promise(.success(user))
    }
}

SwiftUI + Combine

swift

@Published var searchText: String = ""

var searchResults: AnyPublisher<[User], Never> {
    $searchText
        .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
        .removeDuplicates()
        .flatMap { query in
            query.isEmpty ? Just([]).eraseToAnyPublisher()
                         : api.search(query: query)
        }
        .receive(on: DispatchQueue.main)
        .eraseToAnyPublisher()
}

### AnyCancellable 内存管理

```swift
import Combine

class ViewModel {
    private var cancellables = Set<AnyCancellable>()

    func bind() {
        $searchText
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .sink { [weak self] text in
                self?.performSearch(text)
            }
            .store(in: &cancellables)
    }
}

// Store in property
class AnotherViewModel {
    @Published var data: [Item] = []

    private var cancellables = Set<AnyCancellable>()

    func subscribe(to api: APIService) {
        api.itemsPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] items in
                self?.data = items
            }
            .store(in: &cancellables)
    }
}

// 取消订阅
cancellables.removeAll()  // 手动取消所有

常用 Operators

Operator	用途
`map`	转换值
`filter`	过滤值
`flatMap`	展平嵌套 Publisher
`debounce`	防抖（搜索场景）
`throttle`	节流（滚动场景）
`removeDuplicates`	去重
`combineLatest`	合并多个 Publisher
`merge`	合并同类型 Publisher
`catch`	错误处理
`retry`	重试
`zip`	配对组合

性能优化

场景	SwiftUI	UIKit
列表滚动	LazyVStack	UITableView/UICollectionView
图片缓存	AsyncImage + 第三方库	SDWebImage/Kingfisher
预取数据	.task modifier	UITableViewDataSourcePrefetching
后台任务	Task.detached	async/await

SwiftUI 列表优化

swift

// ✅ 推荐：LazyVStack
List {
    ForEach(items) { item in
        ItemView(item: item)
    }
}

// ❌ 避免：大列表不用 Lazy
VStack {
    ForEach(items) { item in  // 全部渲染
        ItemView(item: item)
    }
}

UIKit 列表优化

swift

// UICollectionView 预加载
func collectionView(_ collectionView: UICollectionView, prefetchItemsAt indexPaths: [IndexPath]) {
    for indexPath in indexPaths {
        let item = items[indexPath.item]
        imageLoader.prefetch(url: item.imageURL)
    }
}

测试策略

text

单元测试 → ViewModel / Service 逻辑
   ↓
UI 测试 → View 渲染 + 交互（XCUITest）
   ↓
集成测试 → 模块间交互
   ↓
快照测试 → UI 视觉回归（swift-snapshot-testing）

Swift 单元测试示例

swift

import XCTest

final class UserViewModelTests: XCTestCase {
    var viewModel: UserListViewModel!
    var mockService: MockNetworkService!

    override func setUp() {
        super.setUp()
        mockService = MockNetworkService()
        viewModel = UserListViewModel(networkService: mockService)
    }

    func testLoadUsersSuccess() async {
        // Given
        mockService.users = [User(id: "1", name: "John")]

        // When
        await viewModel.loadUsers()

        // Then
        XCTAssertEqual(viewModel.users.count, 1)
        XCTAssertFalse(viewModel.isLoading)
    }
}

完整页面示例

SwiftUI + MVVM

swift

// Model
struct User: Identifiable, Codable {
    let id: String
    let name: String
    let email: String
}

// ViewModel
@MainActor
class UserListViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false
    @Published var error: String?

    func loadUsers() async {
        isLoading = true
        defer { isLoading = false }
        do {
            users = try await api.fetch(User.self, path: "/users")
        } catch {
            self.error = error.localizedDescription
        }
    }
}

// View
struct UserListView: View {
    @StateObject private var vm = UserListViewModel()

    var body: some View {
        NavigationStack {
            Group {
                if vm.isLoading {
                    ProgressView()
                } else if let error = vm.error {
                    Text("Error: \(error)")
                        .foregroundColor(.red)
                } else {
                    List(vm.users) { user in
                        NavigationLink(destination: UserDetailView(user: user)) {
                            HStack {
                                Text(user.name)
                                Spacer()
                                Text(user.email)
                                    .foregroundColor(.secondary)
                            }
                        }
                    }
                }
            }
            .navigationTitle("用户")
            .task { await vm.loadUsers() }
        }
    }
}

UIKit + MVC

swift

import UIKit
import SnapKit

class UserListViewController: UIViewController {
    private let tableView = UITableView(frame: .zero, style: .insetGrouped)
    private var users: [User] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        loadData()
    }

    private func setupUI() {
        title = "用户"
        view.backgroundColor = .systemGroupedBackground

        tableView.delegate = self
        tableView.dataSource = self
        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")
        view.addSubview(tableView)

        tableView.snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }
    }

    private func loadData() {
        Task {
            do {
                users = try await APIClient.shared.get([User].self, path: "/users")
                tableView.reloadData()
            } catch {
                showError(error)
            }
        }
    }
}

extension UserListViewController: UITableViewDataSource, UITableViewDelegate {
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return users.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
        let user = users[indexPath.row]
        var config = cell.defaultContentConfiguration()
        config.text = user.name
        config.secondaryText = user.email
        cell.contentConfiguration = config
        return cell
    }

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        tableView.deselectRow(at: indexPath, animated: true)
        let user = users[indexPath.row]
        let detailVC = UserDetailViewController(user: user)
        navigationController?.pushViewController(detailVC, animated: true)
    }
}

Swift 语言权威参考

来源：The Swift Programming Language (6.3) https://docs.swift.org/swift-book/documentation/the-swift-programming-language/ CC BY 4.0 License

类型系统

基本类型

类型	说明	示例
Int	整数	`42`, `-7`
Double	64位浮点	`3.14159`
Float	32位浮点	`3.14`
Bool	布尔	`true` / `false`
String	字符串	`"Hello"`
Character	单字符	`"A"`

类型推断与注解

swift

let inferred = 42        // Int
let annotated: Int = 42  // 显式 Int
let pi: Double = 3.14   // Double

类型别名

swift

typealias AudioSample = UInt16
typealias Callback = (Int, String) -> Void

Optional 可选类型

定义与解包

swift

// 定义
var serverResponse: String? = nil
var response: String! = nil  // 隐式解包

// 解包方式
if let value = optional {
    print(value)
}

// guard 解包
func process(_ value: String?) {
    guard let value = value else { return }
    print(value)
}

// ?? 操作符
let name = optional ?? "default"

// 链式调用
let upper = optional?.uppercased()

Optional 模式

swift

// switch 模式匹配
switch optional {
case .some(let value):
    print(value)
case .none:
    print("nil")
}

// 问号链式调用
person?.address?.city

Tuple 元组

swift

// 定义
let httpError = (404, "Not Found")
let (code, message) = httpError
let onlyCode = httpError.0

// 命名
let success = (code: 200, message: "OK")
success.code
success.message

// 返回多值
func getUser() -> (name: String, age: Int) {
    return ("Alice", 30)
}

集合类型

Array

swift

// 创建
var arr = [Int]()           // 空
var arr2 = Array(repeating: 0, count: 5)  // [0,0,0,0,0]
let literals = [1, 2, 3]    // 字面量

// 操作
arr.append(4)
arr.insert(0, at: 0)
arr.remove(at: 0)
arr.removeLast()
arr.first
arr.last

// 遍历
for item in arr { }
for (i, v) in arr.enumerated() { }

Set

swift

// 创建
var set = Set<Int>()
let genres: Set<String> = ["Rock", "Jazz"]

// 操作
set.insert("Pop")
set.remove("Rock")
set.contains("Jazz")

// 集合运算
a.union(b)           // 并集
a.intersection(b)    // 交集
a.subtracting(b)     // 差集
a.symmetricDifference(b)  // 对称差集

// 关系
a.isSubset(of: b)
a.isSuperset(of: b)
a.isDisjoint(with: b)

Dictionary

swift

// 创建
var dict = [String: Int]()
let capitals = ["CN": "Beijing", "JP": "Tokyo"]

// 操作
dict["key"] = "value"
dict["key"] = nil      // 删除
dict.updateValue("v", forKey: "k")  // 返回旧值

// 安全访问
if let value = dict["key"] { }

// 遍历
for (k, v) in dict { }
for key in dict.keys { }
for value in dict.values { }

函数

定义与调用

swift

func greet(name: String) -> String {
    return "Hello, \(name)"
}
greet(name: "World")

// 参数标签
func greet(to name: String) -> String {
    return "Hello, \(name)"
}
greet(to: "World")

// 默认参数
func greet(_ name: String = "World") -> String {
    return "Hello, \(name)"
}

// 可变参数
func sum(_ numbers: Int...) -> Int {
    return numbers.reduce(0, +)
}
sum(1, 2, 3, 4, 5)

// inout 参数
func swap(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

函数类型

swift

var mathFunc: (Int, Int) -> Int = { $0 + $1 }

// 作为参数
func apply(_ op: (Int, Int) -> Int, _ a: Int, _ b: Int) -> Int {
    return op(a, b)
}
apply(mathFunc, 3, 4)

// 作为返回值
func choose(_ op: Bool) -> (Int, Int) -> Int {
    return op ? { $0 + $1 } : { $0 - $1 }
}

嵌套函数

swift

func outer() -> () -> Int {
    var count = 0
    func inner() -> Int {
        count += 1
        return count
    }
    return inner
}

闭包

基本语法

swift

// 完整语法
{ (params) -> ReturnType in
    statements
}

// 类型推断
{ a, b in a + b }

// 无参数
{ () -> Int in 42 }

// 返回类型推断
{ $0 + $1 }

尾随闭包

swift

// 不用尾随
arr.map({ (x: Int) -> Int in x * 2 })

// 尾随闭包
arr.map { $0 * 2 }

// 最后一个参数是闭包
arr.map { x in x * 2 }

@escaping

swift

var handlers: [() -> Void] = []

func withEscaping(_ handler: @escaping () -> Void) {
    handlers.append(handler)
}

func withoutEscaping(_ handler: () -> Void) {
    handler()
}

// 逃逸闭包需要显式 self
class MyClass {
    var x = 10
    func test() {
        withEscaping { self.x = 20 }  // 必须显式
        withoutEscaping { x = 30 }      // 可省略
    }
}

捕获

swift

func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}
let counter = makeCounter()
counter()  // 1
counter()  // 2

枚举

swift

enum Direction {
    case north, south, east, west
}

let dir: Direction = .north

// 关联值
enum Result {
    case success(Data)
    case failure(Error)
}

// 方法
enum Device {
    case phone, tablet
    func description() -> String {
        switch self {
        case .phone: return "iPhone"
        case .tablet: return "iPad"
        }
    }
}

// 原始值
enum ASCIIControl: Character {
    case tab = "\t"
    case newline = "\n"
}

结构体与类

对比

特性	struct	class
类型	值类型	引用类型
继承	❌	✅
初始化	自动生成	手动
析构	—	✅
引用计数	—	✅

swift

struct Point {
    var x: Double
    var y: Double
    // 自动生成 memberwise init
}

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

属性

存储属性

swift

struct FixedRange {
    var start: Int
    let end: Int  // 常量
}

计算属性

swift

struct Rect {
    var origin: Point
    var size: Size
    var center: Point {
        get {
            Point(x: origin.x + size.width/2,
                  y: origin.y + size.height/2)
        }
        set {
            origin.x = newValue.x - size.width/2
            origin.y = newValue.y - size.height/2
        }
    }
}

属性包装器

swift

@propertyWrapper
struct SmallNumber {
    private var number: Int
    var value: Int {
        get { min(number, 12) }
        set { number = newValue }
    }
    init() { number = 0 }
    init(wrappedValue: Int) { number = min(wrappedValue, 12) }
}

@SmallNumber var value: Int  // 使用

属性观察者

swift

class StepCounter {
    var totalSteps: Int = 0 {
        willSet { print("will set to \(newValue)") }
        didSet { print("did set from \(oldValue)") }
    }
}

懒加载

swift

class DataManager {
    lazy var importer = DataImporter()  // 首次访问时才创建
}

方法

实例方法

swift

class Counter {
    var count = 0
    func increment() { count += 1 }
    func increment(by amount: Int) { count += amount }
    func reset() { count = 0 }
}

静态/类方法

swift

struct MathUtils {
    static func sqrt(_ n: Double) -> Double { ... }
}
MathUtils.sqrt(16)

// 类方法（可被重写）
class Animal {
    class func info() { print("Animal") }
}

下标

swift

struct TimesTable {
    subscript(index: Int) -> Int {
        return index * multiplier
    }
}
let table = TimesTable(multiplier: 3)
table[6]  // 18

// 多维下标
struct Matrix {
    subscript(row: Int, col: Int) -> Double {
        get { return grid[row * 3 + col] }
        set { grid[row * 3 + col] = newValue }
    }
}

继承

swift

class Vehicle {
    var speed = 0
    func describe() -> String { "speed: \(speed)" }
}

class Bicycle: Vehicle {
    var hasBasket = false
    override func describe() -> String {
        // 调用父类
        return super.describe() + ", basket: \(hasBasket)"
    }
}

// final 类不可被继承
final class FinalClass { }

初始化与析构

初始化

swift

class ShoppingListItem {
    var name: String
    var quantity: Int = 1
    var completed: Bool = false

    init(name: String, quantity: Int = 1) {
        self.name = name
        self.quantity = quantity
    }
}

// 可失败初始化
struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}

析构

swift

class FileHandler {
    var file: FileHandle
    init() { file = open(...) }
    deinit {
        file.close()
    }
}

错误处理

swift

// 定义错误
enum NetworkError: Error {
    case badURL
    case noData
    case decodingFailed
}

// 抛出
func fetch() throws -> Data {
    guard let url = URL(string: "...") else {
        throw NetworkError.badURL
    }
    return try Data(contentsOf: url)
}

// 处理
do {
    let data = try fetch()
} catch NetworkError.badURL {
    print("Bad URL")
} catch {
    print("Error: \(error)")
}

// try? 转换 Optional
let data = try? fetch()

// try! 强制解包（危险）
let data = try! fetch()

协议与泛型

协议

定义与遵循

swift

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

// 遵循
struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() { }
}

// 类遵循
class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A simple class"
    func adjust() { }
}

协议扩展

swift

extension Collection {
    func allEven() -> [Element] where Element: Numeric {
        return self.filter { ($0 as? Int ?? 0) % 2 == 0 }
    }
}

泛型

函数泛型

swift

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}
swapTwoValues(&x, &y)

类型约束

swift

func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind { return index }
    }
    return nil
}

泛型类型

swift

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

where 子句

swift

func allItemsMatch<C1: Container, C2: Container>
    (_ someContainer: C1, _ anotherContainer: C2) -> Bool
    where C1.Element == C2.Element, C1.Element: Equatable
{
    // ...
}

访问控制

修饰符	范围
open	任意模块，可被继承
public	任意模块
internal	模块内（默认）
fileprivate	当前文件
private	当前作用域

swift

public class PublicClass {
    private var privateVar = 0
    fileprivate var fileVar = 0
}

扩展

swift

extension Int {
    var isEven: Bool { return self % 2 == 0 }
    func repetitions(_ task: () -> Void) {
        for _ in 0..<self { task() }
    }
}

5.isEven           // true
3.repetitions { print("Hello") }

类型转换

swift

// 类型检查
if item is String {
    print("String")
}

// 向下转型
if let str = item as? String {
    print(str)
}

// 强制转型（危险）
let str = item as! String

// Any 和 AnyObject
var things: [Any] = []
things.append(42)
things.append("string")

嵌套类型

swift

struct ChessBoard {
    enum Piece {
        case king, queen, rook, bishop, knight, pawn
    }
    var board: [[Piece?]]
}

let piece: ChessBoard.Piece = .king

Swift 6 并发

Swift 6 Concurrency

async/await

swift

func fetchData() async throws -> Data { ... }

Task {
    do {
        let data = try await fetchData()
    } catch {
        print(error)
    }
}

// async let 并行
async let first = fetchData()
async let second = anotherFetch()
let results = await [first, second]

Task

swift

// 创建
let task = Task { await doWork() }
let result = await task.value
task.cancel()

// TaskGroup
await withTaskGroup(of: Data.self) { group in
    for url in urls {
        group.addTask { await fetch(url) }
    }
    var results: [Data] = []
    for await data in group {
        results.append(data)
    }
}

Actor

swift

actor SafeCounter {
    private var count = 0
    func increment() { count += 1 }
    func getCount() -> Int { count }
}

// MainActor
@MainActor
func updateUI() {
    // UI 更新
}

Sendable

swift

struct User: Sendable { let id: String }

actor SafeLogger: Sendable {
    // actor 自动 Sendable
}

避坑指南

常见错误

错误做法	正确做法
❌ 在主线程执行网络请求	✅ async/await 自动后台执行
❌ 不处理网络错误	✅ always try-catch + user feedback
❌ @State 用于引用类型	✅ @StateObject 用于 class
❌ 不用 LazyVStack 处理大列表	✅ 懒加载避免性能问题
❌ 硬编码 URL	✅ Configuration/Environment

SwiftUI 陷阱

⚠️ @State 复制语义 — @State 修饰的 struct 是值语义，修改会触发重渲染
⚠️ @StateObject 只初始化一次 — 不能在 body 中创建
⚠️ onAppear vs task — task 可取消，onAppear 不行

UIKit 陷阱

⚠️ 循环引用 — delegate/closure 记得用 [weak self]
⚠️ 主线程 UI — UI 更新必须在主线程
⚠️ Memory Leak — 及时清理 NotificationCenter 观察者

来源

来源：Apple Developer Documentation（2026-04-23 访问）

SwiftUI: https://developer.apple.com/documentation/swiftui

UIKit: https://developer.apple.com/documentation/uikit

Xcode: https://developer.apple.com/documentation/xcode

Combine: https://developer.apple.com/documentation/combine

更新频率：随 Xcode/iOS 版本迭代

持久化

UserDefaults

适用于：小量配置、用户偏好、简单状态

swift

// SwiftUI
@AppStorage("username") var username = ""
@AppStorage("isDarkMode") var isDarkMode = false

// 代码直接访问
UserDefaults.standard.string(forKey: "username")
UserDefaults.standard.set("value", forKey: "key")

SQLite（生产推荐）

适用于：结构化数据、离线存储、查询性能

swift

import SQLite

class DatabaseManager {
    static let shared = DatabaseManager()
    private var db: Connection?

    // 表定义
    private let users = Table("users")
    private let id = SQLite.Expression<Int64>("id")
    private let name = SQLite.Expression<String>("name")
    private let email = SQLite.Expression<String>("email")

    init() {
        do {
            let path = NSSearchPathForDirectoriesInDomains(
                .documentDirectory, .userDomainMask, true
            ).first!
            db = try Connection("\(path)/sqlite.db")
            try createTables()
        } catch {
            print("Database error: \(error)")
        }
    }

    private func createTables() throws {
        try db?.run(users.create(ifNotExists: true) { t in
            t.column(id, primaryKey: .autoincrement)
            t.column(name)
            t.column(email)
        })
    }

    // CRUD
    func insertUser(_ user: User) throws {
        let insert = users.insert(
            name <- user.name,
            email <- user.email
        )
        try db?.run(insert)
    }

    func fetchUsers() throws -> [User] {
        guard let db = db else { return [] }
        return try db.prepare(users).map { row in
            User(
                id: row[id],
                name: row[name],
                email: row[email]
            )
        }
    }

    func deleteUser(_ userId: Int64) throws {
        let user = users.filter(id == userId)
        try db?.run(user.delete())
    }
}

Core Data（苹果官方）

适用于：复杂对象图、大量关系数据、Apple 生态深度集成

swift

// Core Data Stack
class CoreDataManager {
    static let shared = CoreDataManager()

    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "Model")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Core Data failed: \(error)")
            }
        }
        container.viewContext.automaticallyMergesChangesFromParent = true
        return container
    }()

    var viewContext: NSManagedObjectContext {
        persistentContainer.viewContext
    }

    func save() {
        let context = viewContext
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                print("Save error: \(error)")
            }
        }
    }
}

// SwiftUI 集成
struct ContentView: View {
    @Environment(\.managedObjectContext) var viewContext

    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \User.name, ascending: true)],
        animation: .default
    )
    var users: FetchedResults<User>

    var body: some View {
        List(users, id: \.self) { user in
            Text(user.name ?? "Unknown")
        }
    }
}

Swift Concurrency 深度

Sendable 协议

确保数据可以安全跨并发域传递。

swift

// ✅ 可Sendable的类型
struct User: Sendable {
    let id: String
    let name: String
    // 值类型默认 Sendable
}

// ⚠️ Class 需要手动实现
final class SafeClass: @unchecked Sendable {
    // 不做线程安全假设，仅用于已知安全的场景
}

// ❌ 不可Sendable
class UnsafeClass {
    var cache = [String: Any]()  // 包含可变状态
}

MainActor

确保代码在主线程执行，用于 UI 更新。

swift

// 方法级别
@MainActor
func updateUI() {
    // 自动在主线程执行
    self.username = "New Name"
}

// 类级别（所有方法默认主线程）
@MainActor
class ViewModel: ObservableObject {
    @Published var items: [Item] = []

    // 隐式 @MainActor
    func loadItems() async {
        let fetched = await network.fetchItems()
        self.items = fetched  // 安全
    }
}

// 非隔离函数访问主线程数据
nonisolated func describe(_ vm: ViewModel) {
    // ❌ 不能访问 @Published
    // ✅ 可以访问 Sendable 属性
    print("Description")
}

TaskGroup

并发执行多个任务。

swift

// 并发下载
func fetchAllImages(urls: [URL]) async throws -> [Data] {
    try await withThrowingTaskGroup(of: Data.self) { group in
        for url in urls {
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return data
            }
        }

        var results: [Data] = []
        for try await data in group {
            results.append(data)
        }
        return results
    }
}

// 带取消
func fetchWithCancel(urls: [URL]) async {
    await withTaskGroup(of: Data?.self) { group in
        for url in urls {
            group.addTask {
                try? await Task.sleep(nanoseconds: 1_000_000_000)
                guard !Task.isCancelled else { return nil }
                let (data, _) = try await URLSession.shared.data(from: url)
                return data
            }
        }
    }
}

Task 取消

swift

// 检查取消
func performWork() async throws {
    for item in items {
        try Task.checkCancellation()  // 抛出 CancellationError
        // 处理 item
    }
}

// withTaskCancellationHandler
try await withTaskCancellationHandler {
    try await longRunningWork()
} onCancel: {
    cleanup()
}

// 传递取消
struct DetailView: View {
    @State private var data: Data?
    @Environment(\.dismiss) var dismiss

    var body: some View {
        Button("加载") {
            Task {
                data = await fetchData()
            }
        }
        .onDisappear {
            // 视图消失时自动取消
        }
    }
}

UIKit 进阶

UICollectionView

生产级列表/网格首选。

swift

class CollectionViewController: UIViewController {
    private var collectionView: UICollectionView!
    private var dataSource: UICollectionViewDiffableDataSource<Section, Item>!

    enum Section: Hashable {
        case main
        case featured
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        setupCollectionView()
        configureDataSource()
        applySnapshot()
    }

    private func setupCollectionView() {
        // Compositional Layout
        let config = UICollectionLayoutConfiguration(
           -interSectionSpacing: 16
        )
        let layout = UICollectionViewCompositionalLayout(
            sectionProvider: { sectionIndex, environment in
                let itemSize = NSCollectionLayoutSize(
                    widthDimension: .fractionalWidth(0.5),
                    heightDimension: .fractionalHeight(1.0)
                )
                let item = NSCollectionLayoutItem(layoutSize: itemSize)
                item.contentInsets = NSDirectionalEdgeInsets(
                    top: 8, leading: 8, bottom: 8, trailing: 8
                )

                let groupSize = NSCollectionLayoutSize(
                    widthDimension: .fractionalWidth(1.0),
                    heightDimension: .absolute(180)
                )
                let group = NSCollectionLayoutGroup.horizontal(
                    layoutSize: groupSize, subitems: [item]
                )

                let section = NSCollectionLayoutSection(group: group)
                section.contentInsets = NSDirectionalEdgeInsets(
                    top: 0, leading: 16, bottom: 16, trailing: 16
                )

                return NSCollectionLayoutSection(section: section)
            },
            configuration: config
        )

        collectionView = UICollectionView(
            frame: view.bounds,
            collectionViewLayout: layout
        )
        collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        collectionView.delegate = self
        view.addSubview(collectionView)
    }

    private func configureDataSource() {
        let cellRegistration = UICollectionView.CellRegistration<
            UICollectionViewCell, Item
        > { cell, indexPath, item in
            var config = UIListContentConfiguration.cell()
            config.text = item.title
            config.secondaryText = item.subtitle
            config.image = UIImage(systemName: item.icon)
            cell.contentConfiguration = config
        }

        dataSource = UICollectionViewDiffableDataSource<Section, Item>(
            collectionView: collectionView
        ) { collectionView, indexPath, item in
            collectionView.dequeueConfiguredReusableCell(
                using: cellRegistration, for: indexPath, item: item
            )
        }
    }

    private func applySnapshot() {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        snapshot.appendSections([.main])
        snapshot.appendItems(items)
        dataSource.apply(snapshot, animatingDifferences: true)
    }
}

extension CollectionViewController: UICollectionViewDelegate {
    func collectionView(
        _ collectionView: UICollectionView,
        didSelectItemAt indexPath: IndexPath
    ) {
        guard let item = dataSource.itemIdentifier(for: indexPath) else { return }
        // 处理选择
    }
}

Auto Layout 完整约束

swift

// NSLayoutConstraint 语法
label.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    label.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
    label.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
    label.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 16),
    label.heightAnchor.constraint(greaterThanOrEqualToConstant: 44)
])

// 优先级
let highPriority = label.widthAnchor.constraint(equalToConstant: 100)
highPriority.priority = .defaultHigh  // 750

let lowPriority = label.widthAnchor.constraint(equalToConstant: 50)
lowPriority.priority = .defaultLow  // 250

// 比例约束
label.widthAnchor.constraint(equalTo: view.widthAnchor, multiplier: 0.5)

// 尺寸约束
label.heightAnchor.constraint(equalTo: label.widthAnchor, multiplier: 1.5)

键盘处理

swift

class KeyboardViewController: UIViewController {
    @IBOutlet weak var scrollView: UIScrollView!
    @IBOutlet weak var textField: UITextField!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupKeyboardObservers()
    }

    private func setupKeyboardObservers() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(keyboardWillShow),
            name: UIResponder.keyboardWillShowNotification,
            object: nil
        )
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(keyboardWillHide),
            name: UIResponder.keyboardWillHideNotification,
            object: nil
        )
    }

    @objc func keyboardWillShow(_ notification: Notification) {
        guard let keyboardFrame = notification.userInfo?[
            UIResponder.keyboardFrameEndUserInfoKey
        ] as? CGRect else { return }

        let contentInsets = UIEdgeInsets(
            top: 0, left: 0,
            bottom: keyboardFrame.height, right: 0
        )
        scrollView.contentInset = contentInsets
        scrollView.scrollIndicatorInsets = contentInsets
    }

    @objc func keyboardWillHide(_ notification: Notification) {
        scrollView.contentInset = .zero
        scrollView.scrollIndicatorInsets = .zero
    }

    @objc func dismissKeyboard() {
        view.endEditing(true)
    }
}

// SwiftUI 版本
struct KeyboardAvoidingView: View {
    @State private var text = ""
    @FocusState private var isFocused: Bool

    var body: some View {
        ScrollView {
            TextField("输入", text: $text)
                .focused($isFocused)
                .padding()
                .background(Color.gray.opacity(0.2))
        }
        .onTapGesture {
            isFocused = false
        }
    }
}

Swift Concurrency 避坑

常见错误

错误做法	正确做法
❌ nonisolated 函数访问 @Published	✅ 用 @MainActor 包装
❌ 跨线程传递 UIView	✅ 始终在主线程操作
❌ Task 不保存引用	✅ 存储 Task 以支持取消
❌ 忘记 CancellationError	✅ 调用 Task.checkCancellation()
❌ actor 内部用锁	✅ actor 天然线程安全
❌ 传递非 Sendable 闭包	✅ 确保闭包捕获值是 Sendable

@MainActor 传递规则

swift

@MainActor
class ViewModel {
    func update() { /* 主线程 */ }
}

// ✅ 正确：await 后自动回到主线程
let vm = ViewModel()
Task { @MainActor in
    await someAsyncMethod()
    vm.update()  // 安全
}

// ❌ 错误：非隔离上下文访问
Task {
    await someAsyncMethod()
    // vm.update() // ❌ 编译错误
}

Widget 开发

widget.md — TimelineProvider / App Group / Interactive Widget / Lock Screen Widget

国际化与本地化

localization.md — NSLocalizedString / String Catalog / 格式化 / RTL / App Store 本地化

Swift Concurrency 权威参考

swift-concurrency.md — async/await / TaskGroup / MainActor / Actor / Sendable / Swift 6

快速参考

SwiftUI 状态装饰器速查

装饰器	作用域	父传子	创建者
@State	局部	❌	视图
@Binding	局部	✅	视图
@StateObject	局部	❌	视图
@ObservedObject	局部	✅	父视图
@EnvironmentObject	全局	✅	任意
@AppStorage	全局	✅	UserDefaults
@SceneStorage	全局	✅	Scene
@FocusState	局部	✅	视图
@ScaledMetric	局部	✅	视图

UIKit vs SwiftUI 生命周期

阶段	UIKit	SwiftUI
创建	`init`	`@State init`
加载视图	`loadView`	body
视图加载	`viewDidLoad`	`.task`
即将显示	`viewWillAppear`	`.onAppear`
已显示	`viewDidAppear`	—
即将消失	`viewWillDisappear`	`.onDisappear`
已消失	`viewDidDisappear`	—
内存警告	`didReceiveMemoryWarning`	`.onChange`

iOS 版本支持速查

API	最低版本
NavigationStack	iOS 16+
@MainActor	iOS 16+ / Swift 5.5+
SwiftUI Charts	iOS 16+
AnyCancellable store	iOS 13+
AsyncSequence	Swift 5.5+
WidgetKit	iOS 14+
Live Activities	iOS 16.1+
Interactive Widget	iOS 17+

Auto Layout 速查

swift

// 核心约束
label.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    label.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
    label.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
    label.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
    label.heightAnchor.constraint(greaterThanOrEqualToConstant: 44)
])

// SnapKit
view.snp.makeConstraints { make in
    make.edges.equalToSuperview().inset(16)
    make.height.greaterThanOrEqualTo(100)
    make.width.equalToSuperview().multipliedBy(0.5)
}

// 优先级
.widthAnchor.constraint(equalToConstant: 100).priority = .defaultHigh  // 750
.widthAnchor.constraint(equalToConstant: 50).priority = .defaultLow   // 250
.widthAnchor.constraint(equalToConstant: 0).priority = .required      // 1000

网络状态速查

状态	SwiftUI	UIKit
空闲	`isLoading = false`	`state = .idle`
加载中	`isLoading = true`	`state = .loading`
成功	`@Published var items`	`delegate?.didFinish`
错误	`@Published var error`	`delegate?.didFail`

Combine 操作符速查

操作符	用途	示例
`map`	转换值	`.map { $0 * 2 }`
`filter`	过滤	`.filter { $0 > 0 }`
`flatMap`	展平	`.flatMap { $0.publisher }`
`debounce`	防抖	`.debounce(for: .milliseconds(300), scheduler: RunLoop.main)`
`throttle`	节流	`.throttle(for: .seconds(1), scheduler: RunLoop.main, latest: true)`
`combineLatest`	合并	`Publishers.CombineLatest(a, b)`
`merge`	合并同类型	`a.merge(with: b)`
`catch`	错误处理	`.catch { Just(default) }`
`retry`	重试	`.retry(3)`
`zip`	配对	`a.zip(b)`

Auto Layout 速查

swift

// 核心约束
label.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16)
label.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16)
label.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor)
label.heightAnchor.constraint(greaterThanOrEqualToConstant: 44)

// SnapKit
view.snp.makeConstraints { make in
    make.edges.equalToSuperview().inset(16)
    make.height.greaterThanOrEqualTo(100)
}

// 优先级
.widthAnchor.constraint(equalToConstant: 100).priority = .defaultHigh
.widthAnchor.constraint(equalToConstant: 50).priority = .defaultLow

Widget 尺寸速查

尺寸	宽度	高度	用途
systemSmall	155pt	155pt	单指标
systemMedium	329pt	155pt	双指标
systemLarge	329pt	345pt	列表卡片
accessoryCircular	—	—	锁屏圆形
accessoryRectangular	—	—	锁屏矩形

常用尺寸速查

场景	尺寸
最小点击区域	44pt
标准间距	16pt
大间距	24pt
安全区留边	16pt
TabBar 高度	49pt
NavigationBar 高度	44pt
Widget 圆角	20pt
按钮圆角	8pt
图片圆角	12pt

Swift Concurrency 速查

swift

// async/await
func fetch() async throws -> Data

// Task
Task { await fetch() }
Task.detached { await fetch() }

// TaskGroup
await withTaskGroup(of: Data.self) { group in
    group.addTask { await fetch() }
}

// MainActor
@MainActor func update() { }
Task { @MainActor in update() }

// Sendable
struct User: Sendable { let id: String }
actor SafeCounter { }

// 取消
Task.checkCancellation()
Task.isCancelled
task.cancel()

生命周期速查

事件	SwiftUI	UIKit
视图出现	`.onAppear`	`viewDidAppear`
视图消失	`.onDisappear`	`viewDidDisappear`
应用激活	`.onReceive`	`applicationDidBecomeActive`
应用休眠	—	`applicationWillResignActive`

输出格式规范

当使用本技能回答用户问题时，遵循以下格式：

回复结构

直接回答 — 一段简洁的话给出核心答案
代码示例 — 提供完整的 SwiftUI/UIKit 代码（如需）
实现要点 — 关键步骤和注意事项
避坑提醒 — 常见错误+正确做法

示例回复（网络请求）

SwiftUI 推荐使用 async/await 处理网络请求。定义一个 NetworkService actor 封装 URLSession，在 ViewModel 中用 @Published 管理状态。示例：定义 fetch<T: Decodable> 泛型方法，用 Task 调用并更新 @Published 属性。错误处理用 do-catch，始终给用户反馈。

禁用格式

❌ 不要显式分层（避免"第一层/第二层/框架分析"等字眼）
❌ 不要长篇解释概念，要直接给出实现
❌ 不要只给代码片段，要给完整可运行的示例
✅ 输出应是一段干净的话 + 完整代码