普通视图

发现新文章，点击刷新页面。

今天 — 2026年4月17日掘金 iOS

第5章：基础状态管理

掘金 iOS

作者 90后晨仔

2026年4月16日 21:57

示例代码都放这里啦，有需要的可以下载学习。swiftUIDemo

5.1 @State：本地视图状态

@State 介绍

@State 是 SwiftUI 中最基本的状态管理工具，用于管理视图的本地状态。它是一个属性包装器，允许我们在结构体中创建可变状态。

基本用法

import SwiftUI

struct CounterView: View {
    // 使用 @State 声明本地状态
    @State private var count = 0
    
    var body: some View {
        VStack(spacing: 20) {
            // 显示状态值
            Text("Count: \(count)")
                .font(.largeTitle)
                .fontWeight(.bold)
            
            // 修改状态
            Button("Increment") {
                count += 1  // 状态改变，UI 自动更新
            }
            .buttonStyle(.borderedProminent)
            
            Button("Reset") {
                count = 0  // 状态重置
            }
            .buttonStyle(.bordered)
        }
        .padding()
    }
}

#Preview {
    CounterView()
}

工作原理

@State 的工作原理：

当你使用 @State 标记一个属性时，SwiftUI 会在底层为这个属性创建一个独立的存储
这个存储不受结构体值类型特性的影响，即使结构体被重新创建，状态也会保持
当状态值改变时，SwiftUI 会自动重新计算视图的 body 属性
系统会对比新旧视图树，只更新发生变化的部分

最佳实践

标记为 private：@State 应该只在当前视图内部使用，所以应该标记为 private
初始值：必须为 @State 属性提供初始值
避免在 body 中修改：不要在 body 计算属性中直接修改 @State 值
简单类型：@State 适合存储简单类型（如 Bool、Int、String 等）

5.2 @Binding：父子视图双向绑定

@Binding 介绍

@Binding 用于在父子视图之间创建双向绑定，允许子视图修改父视图的状态。

基本用法

import SwiftUI

// 父视图
struct ParentView: View {
    // 父视图的状态
    @State private var isPlaying = false
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Parent View")
                .font(.headline)
            
            Text("Is Playing: \(isPlaying ? "Yes" : "No")")
            
            // 使用 $ 符号创建绑定并传递给子视图
            PlayButton(isPlaying: $isPlaying)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

// 子视图
struct PlayButton: View {
    // 使用 @Binding 接收父视图的状态引用
    @Binding var isPlaying: Bool
    
    var body: some View {
        Button(isPlaying ? "Pause" : "Play") {
            // 修改绑定值，会同步更新父视图的状态
            isPlaying.toggle()
        }
        .buttonStyle(.borderedProminent)
        .tint(isPlaying ? .red : .green)
        .padding()
        .background(Color.gray.opacity(0.05))
        .cornerRadius(8)
    }
}

#Preview {
    ParentView()
}

工作原理

@Binding 的工作原理：

它不是存储状态，而是创建一个对现有状态的引用
当子视图修改绑定值时，实际上是修改了原始的 @State 状态
状态的所有权仍然在父视图中
这种机制确保了单一数据源（SSOT）原则

实际应用

// 表单输入示例
struct FormView: View {
    @State private var username = ""
    @State private var email = ""
    
    var body: some View {
        VStack(spacing: 16) {
            Text("User Form")
                .font(.headline)
            
            TextFieldView(
                title: "Username",
                text: $username,
                placeholder: "Enter your username"
            )
            
            TextFieldView(
                title: "Email",
                text: $email,
                placeholder: "Enter your email"
            )
            
            Text("Username: \(username)")
            Text("Email: \(email)")
        }
        .padding()
    }
}

struct TextFieldView: View {
    let title: String
    @Binding var text: String
    let placeholder: String
    
    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(title)
                .font(.subheadline)
                .fontWeight(.medium)
            
            TextField(
                placeholder,
                text: $text
            )
            .textFieldStyle(.roundedBorder)
        }
    }
}

5.3 @StateObject：可观察对象状态

@StateObject 介绍

@StateObject 用于管理符合 ObservableObject 协议的对象，适用于需要在多个视图之间共享的复杂状态。

基本用法

import SwiftUI
import Combine

// 可观察对象模型
class UserViewModel: ObservableObject {
    // 使用 @Published 标记需要发布的属性
    @Published var username = ""
    @Published var email = ""
    @Published var isLoggedIn = false
    
    func login() {
        // 模拟登录操作
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.isLoggedIn = true
        }
    }
    
    func logout() {
        username = ""
        email = ""
        isLoggedIn = false
    }
}

struct UserView: View {
    // 使用 @StateObject 管理可观察对象
    @StateObject private var viewModel = UserViewModel()
    
    var body: some View {
        VStack(spacing: 20) {
            Text("User Profile")
                .font(.headline)
            
            if viewModel.isLoggedIn {
                Text("Welcome, \(viewModel.username)!")
                    .font(.title)
                Text("Email: \(viewModel.email)")
                
                Button("Logout") {
                    viewModel.logout()
                }
                .buttonStyle(.borderedProminent)
                .tint(.red)
            } else {
                TextField("Username", text: $viewModel.username)
                    .textFieldStyle(.roundedBorder)
                TextField("Email", text: $viewModel.email)
                    .textFieldStyle(.roundedBorder)
                
                Button("Login") {
                    viewModel.login()
                }
                .buttonStyle(.borderedProminent)
                .disabled(viewModel.username.isEmpty || viewModel.email.isEmpty)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

#Preview {
    UserView()
}

工作原理

@StateObject 的工作原理：

它会创建并拥有一个符合 ObservableObject 协议的对象
当对象的 @Published 属性改变时，所有使用该对象的视图都会自动更新
即使视图被重新创建，@StateObject 也会保持对象的生命周期
适用于需要在多个视图之间共享的复杂状态

最佳实践

用于复杂状态：适用于包含多个相关属性的复杂状态
单一数据源：作为状态的唯一来源
生命周期管理：由 SwiftUI 管理对象的生命周期
性能考虑：对于大型对象，考虑使用更细粒度的状态管理

5.4 @ObservedObject：观察外部对象

@ObservedObject 介绍

@ObservedObject 用于观察外部传入的符合 ObservableObject 协议的对象，适用于从父视图传递的可观察对象。

基本用法

import SwiftUI

// 父视图
struct ParentWithObservedObject: View {
    // 父视图拥有状态对象
    @StateObject private var userViewModel = UserViewModel()
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Parent View")
                .font(.headline)
            
            // 传递给子视图
            ChildView(viewModel: userViewModel)
        }
        .padding()
    }
}

// 子视图
struct ChildView: View {
    // 使用 @ObservedObject 观察外部对象
    @ObservedObject var viewModel: UserViewModel
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Child View")
                .font(.subheadline)
            
            TextField("Username", text: $viewModel.username)
                .textFieldStyle(.roundedBorder)
            
            TextField("Email", text: $viewModel.email)
                .textFieldStyle(.roundedBorder)
            
            Button("Login") {
                viewModel.login()
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

#Preview {
    ParentWithObservedObject()
}

工作原理

@ObservedObject 的工作原理：

它不拥有对象，只是观察外部传入的对象
当对象的 @Published 属性改变时，视图会自动更新
对象的生命周期由其拥有者管理
适用于从父视图传递的可观察对象

与 @StateObject 的区别

特性	@StateObject	@ObservedObject
所有权	拥有对象，管理生命周期	观察对象，不管理生命周期
初始化	在视图中直接初始化	从外部传入
适用场景	作为状态的唯一来源	观察父视图传递的对象
性能	更高效，避免重复创建	可能会因父视图重建而重复创建

5.5 @EnvironmentObject：全局环境对象

@EnvironmentObject 介绍

@EnvironmentObject 用于访问通过环境传递的全局可观察对象，适用于跨多个视图层级共享的状态。

基本用法

import SwiftUI

// 全局状态模型
class AppState: ObservableObject {
    @Published var isDarkMode = false
    @Published var userLanguage = "zh"
    
    func toggleDarkMode() {
        isDarkMode.toggle()
    }
    
    func changeLanguage(to language: String) {
        userLanguage = language
    }
}

// 主视图 - 设置环境对象
struct MainView: View {
    @StateObject private var appState = AppState()
    
    var body: some View {
        NavigationStack {
            VStack {
                Text("Main View")
                    .font(.headline)
                
                NavigationLink("Settings", destination: SettingsView())
                NavigationLink("Profile", destination: ProfileView())
            }
            .padding()
        }
        // 通过环境传递对象
        .environmentObject(appState)
    }
}

// 设置视图 - 访问环境对象
struct SettingsView: View {
    // 通过 @EnvironmentObject 访问全局对象
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Settings")
                .font(.headline)
            
            Toggle("Dark Mode", isOn: $appState.isDarkMode)
            
            Picker("Language", selection: $appState.userLanguage) {
                Text("English").tag("en")
                Text("中文").tag("zh")
                Text("日本語").tag("ja")
            }
            .pickerStyle(.segmented)
        }
        .padding()
        .background(appState.isDarkMode ? Color.black : Color.white)
        .foregroundColor(appState.isDarkMode ? Color.white : Color.black)
    }
}

// 个人资料视图 - 访问环境对象
struct ProfileView: View {
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Profile")
                .font(.headline)
            
            Text("Current Language: \(appState.userLanguage)")
            Text("Dark Mode: \(appState.isDarkMode ? "On" : "Off")")
        }
        .padding()
        .background(appState.isDarkMode ? Color.black : Color.white)
        .foregroundColor(appState.isDarkMode ? Color.white : Color.black)
    }
}

#Preview {
    MainView()
}

工作原理

@EnvironmentObject 的工作原理：

它从环境中查找指定类型的可观察对象
当对象的 @Published 属性改变时，所有使用该对象的视图都会自动更新
不需要手动传递对象，通过环境自动注入
适用于跨多个视图层级共享的全局状态

最佳实践

全局状态：用于应用级别的全局状态
依赖注入：通过环境进行依赖注入，避免层层传递
类型安全：基于类型查找，确保类型正确
错误处理：确保在使用前在环境中设置了对象

5.6 @Environment：环境值

@Environment 介绍

@Environment 用于访问 SwiftUI 环境中的系统值，如布局方向、颜色方案、字体大小等。

基本用法

import SwiftUI

struct EnvironmentValuesView: View {
    // 访问环境值
    @Environment(\.colorScheme) private var colorScheme
    @Environment(\.layoutDirection) private var layoutDirection
    @Environment(\.dynamicTypeSize) private var dynamicTypeSize
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Environment Values")
                .font(.headline)
            
            Text("Color Scheme: \(colorScheme == .dark ? "Dark" : "Light")")
            Text("Layout Direction: \(layoutDirection == .leftToRight ? "LTR" : "RTL")")
            Text("Dynamic Type Size: \(dynamicTypeSize.description)")
            Text("Horizontal Size Class: \(horizontalSizeClass == .regular ? "Regular" : "Compact")")
            
            // 根据环境值调整布局
            if horizontalSizeClass == .regular {
                HStack {
                    Text("Wide Layout")
                    Spacer()
                    Text("More Content")
                }
            } else {
                VStack {
                    Text("Narrow Layout")
                    Text("Content Below")
                }
            }
        }
        .padding()
        .background(colorScheme == .dark ? Color.black : Color.white)
        .foregroundColor(colorScheme == .dark ? Color.white : Color.black)
    }
}

#Preview {
    EnvironmentValuesView()
}

常用环境值

环境值	类型	描述
`\.colorScheme`	`ColorScheme`	当前颜色方案（浅色/深色）
`\.layoutDirection`	`LayoutDirection`	布局方向（LTR/RTL）
`\.dynamicTypeSize`	`DynamicTypeSize`	动态字体大小
`\.horizontalSizeClass`	`UserInterfaceSizeClass?`	水平尺寸类
`\.verticalSizeClass`	`UserInterfaceSizeClass?`	垂直尺寸类
`\.locale`	`Locale`	当前区域设置
`\.calendar`	`Calendar`	当前日历
`\.timeZone`	`TimeZone`	当前时区
`\.accessibilityEnabled`	`Bool`	是否启用辅助功能
`\.scenePhase`	`ScenePhase`	场景阶段（活跃/非活跃/背景）

工作原理

@Environment 的工作原理：

它从 SwiftUI 环境中读取指定的环境值
当环境值改变时，视图会自动更新
环境值由系统或父视图设置
适用于响应系统设置和环境变化

5.7 @SceneStorage：场景存储

@SceneStorage 介绍

@SceneStorage 用于在场景级别持久化存储简单数据，适用于保存用户偏好设置和状态。

基本用法

import SwiftUI

struct SceneStorageView: View {
    // 使用 @SceneStorage 存储数据
    @SceneStorage("username") private var username = ""
    @SceneStorage("isDarkMode") private var isDarkMode = false
    @SceneStorage("counter") private var counter = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Scene Storage")
                .font(.headline)
            
            TextField("Username", text: $username)
                .textFieldStyle(.roundedBorder)
            
            Toggle("Dark Mode", isOn: $isDarkMode)
            
            VStack {
                Text("Counter: \(counter)")
                HStack {
                    Button("Increment") {
                        counter += 1
                    }
                    .buttonStyle(.bordered)
                    
                    Button("Reset") {
                        counter = 0
                    }
                    .buttonStyle(.bordered)
                }
            }
            
            Text("Note: Data persists across app restarts")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(isDarkMode ? Color.black : Color.white)
        .foregroundColor(isDarkMode ? Color.white : Color.black)
    }
}

#Preview {
    SceneStorageView()
}

工作原理

@SceneStorage 的工作原理：

它将数据存储在场景的 UserDefaults 中
数据会在场景重启后保持
每个场景有自己的存储，不同场景之间数据隔离
适用于存储用户偏好设置和临时状态

最佳实践

简单数据：适合存储简单类型（String、Int、Bool 等）
场景隔离：每个场景有独立的存储
自动持久化：数据自动保存，无需手动管理
键名唯一性：使用唯一的键名避免冲突

5.8 @AppStorage：应用存储

@AppStorage 介绍

@AppStorage 用于在应用级别持久化存储简单数据，适用于保存全局用户偏好设置。

基本用法

import SwiftUI

struct AppStorageView: View {
    // 使用 @AppStorage 存储数据
    @AppStorage("userName") private var userName = "Guest"
    @AppStorage("appTheme") private var appTheme = "light"
    @AppStorage("notificationsEnabled") private var notificationsEnabled = true
    
    var body: some View {
        VStack(spacing: 20) {
            Text("App Storage")
                .font(.headline)
            
            TextField("User Name", text: $userName)
                .textFieldStyle(.roundedBorder)
            
            Picker("Theme", selection: $appTheme) {
                Text("Light").tag("light")
                Text("Dark").tag("dark")
                Text("Auto").tag("auto")
            }
            .pickerStyle(.segmented)
            
            Toggle("Enable Notifications", isOn: $notificationsEnabled)
            
            Text("Note: Data persists across app reinstalls")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(getThemeColor())
        .foregroundColor(appTheme == "dark" ? Color.white : Color.black)
    }
    
    private func getThemeColor() -> Color {
        switch appTheme {
        case "dark":
            return Color.black
        case "light":
            return Color.white
        default:
            return Color.white
        }
    }
}

#Preview {
    AppStorageView()
}

工作原理

@AppStorage 的工作原理：

它将数据存储在应用的 UserDefaults 中
数据会在应用重启后保持
所有场景共享相同的存储
适用于存储全局用户偏好设置

与 @SceneStorage 的区别

特性	@AppStorage	@SceneStorage
存储范围	应用级别，所有场景共享	场景级别，每个场景独立
持久化	持久化到 UserDefaults	持久化到场景的 UserDefaults
适用场景	全局偏好设置	场景特定状态
数据共享	跨场景共享	场景隔离

5.9 @FocusedValue：聚焦值

@FocusedValue 介绍

@FocusedValue 用于在视图层次结构中传递聚焦状态相关的值，适用于处理键盘焦点和上下文相关操作。

基本用法

import SwiftUI

// 定义聚焦值键
struct EditModeKey: FocusedValueKey {
    typealias Value = Bool
}

// 扩展 FocusedValues
extension FocusedValues {
    var isEditMode: EditModeKey.Value? {
        get { self[EditModeKey.self] }
        set { self[EditModeKey.self] = newValue }
    }
}

struct FocusedValueView: View {
    @State private var isEditMode = false
    @State private var text = "Hello, SwiftUI"
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Focused Value")
                .font(.headline)
            
            // 设置聚焦值
            TextField("Enter text", text: $text)
                .textFieldStyle(.roundedBorder)
                .focusedValue(\.isEditMode, true)
            
            Button("Toggle Edit Mode") {
                isEditMode.toggle()
            }
            .buttonStyle(.borderedProminent)
            
            // 子视图访问聚焦值
            FocusedChildView()
        }
        .padding()
        .environment(\.isEditMode, isEditMode)
    }
}

struct FocusedChildView: View {
    // 访问聚焦值
    @FocusedValue(\.isEditMode) private var isEditMode
    
    var body: some View {
        VStack {
            Text("Child View")
                .font(.subheadline)
            
            Text("Edit Mode: \(isEditMode ?? false ? "On" : "Off")")
            
            if isEditMode ?? false {
                Text("Editing is enabled!")
                    .foregroundColor(.green)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

#Preview {
    FocusedValueView()
}

工作原理

@FocusedValue 的工作原理：

它通过 FocusedValues 字典传递值
当焦点变化时，聚焦值会自动更新
适用于与焦点相关的上下文信息
可以自定义聚焦值键

适用场景

键盘焦点：跟踪当前聚焦的视图
上下文操作：根据聚焦状态显示不同的操作
编辑模式：在编辑模式下显示额外的控件
工具栏配置：根据当前聚焦的内容配置工具栏

5.10 状态驱动 UI 更新原理

核心原理

SwiftUI 的核心设计哲学是状态驱动：

UI = f(State)

这意味着：

UI 是状态的函数
当状态改变时，UI 会自动更新
给定相同的状态，总是渲染相同的 UI

更新流程

当状态改变时，SwiftUI 的更新流程如下：

状态改变：用户操作或其他因素导致状态值发生变化
检测变化：SwiftUI 检测到状态变化
重新计算 body：重新调用受影响视图的 body 计算属性
构建新视图树：生成新的视图层次结构
对比差异：对比新旧视图树，找出变化的部分
更新 UI：只更新发生变化的部分，保持其他部分不变

性能优化

SwiftUI 的状态驱动机制本身就很高效，因为：

增量更新：只更新变化的部分
值类型：视图是轻量级的值类型，创建成本低
智能对比：使用高效的差异算法
批处理：合并多个状态更新，减少渲染次数
懒加载：只渲染可见的部分

5.11 状态管理最佳实践

1. 选择合适的状态管理工具

状态类型	推荐工具	适用场景
本地简单状态	`@State`	单个视图的内部状态
父子视图共享	`@Binding`	子视图需要修改父视图状态
复杂对象状态	`@StateObject`	多个属性的复杂状态
外部对象引用	`@ObservedObject`	观察父视图传递的对象
全局共享状态	`@EnvironmentObject`	跨多个视图的全局状态
系统环境值	`@Environment`	访问系统设置和环境
场景级持久化	`@SceneStorage`	场景特定的持久状态
应用级持久化	`@AppStorage`	全局用户偏好设置
聚焦相关状态	`@FocusedValue`	与焦点相关的上下文信息

2. 状态管理原则

单一数据源：每个状态应该有唯一的来源
状态提升：将状态提升到需要访问它的所有视图的共同父视图
最小化状态：只存储必要的状态，避免冗余
状态隔离：将相关状态组织在一起，避免混乱
可测试性：状态管理应该易于测试
性能考虑：对于大型状态，考虑使用更细粒度的更新

3. 性能优化技巧

使用 Equatable：为模型实现 Equatable 协议，避免不必要的更新
视图分离：将复杂视图拆分为更小的子视图
@State 用于简单类型：@State 适合存储简单类型，复杂类型使用 @StateObject
避免在 body 中创建对象：不要在 body 计算属性中创建新对象
使用 .id() 强制更新：当需要强制视图更新时使用
考虑使用 Combine：对于复杂的异步操作，使用 Combine 框架

实战：创建一个完整的状态管理示例

需求分析

创建一个包含多种状态管理技术的应用，包括：

本地状态管理
父子视图绑定
可观察对象
环境对象
持久化存储

代码实现

import SwiftUI
import Combine

// 全局应用状态
class AppState: ObservableObject {
    @Published var isDarkMode = false
    @Published var currentUser: User? = nil
    
    func toggleTheme() {
        isDarkMode.toggle()
    }
    
    func login(user: User) {
        currentUser = user
    }
    
    func logout() {
        currentUser = nil
    }
}

// 用户模型
struct User: Identifiable, Equatable {
    let id = UUID()
    let name: String
    let email: String
}

// 主应用视图
struct StateManagementDemo: View {
    @StateObject private var appState = AppState()
    @AppStorage("lastLoggedInUser") private var lastLoggedInUser = ""
    
    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                Text("状态管理演示")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                
                // 主题切换
                Toggle("深色模式", isOn: $appState.isDarkMode)
                
                // 用户登录状态
                if appState.currentUser != nil {
                    Text("欢迎, \(appState.currentUser?.name ?? "")!")
                    Button("退出登录") {
                        appState.logout()
                        lastLoggedInUser = ""
                    }
                    .buttonStyle(.borderedProminent)
                    .tint(.red)
                } else {
                    LoginView()
                }
                
                // 导航链接
                NavigationLink("计数器示例", destination: CounterView())
                NavigationLink("待办事项示例", destination: TodoApp())
                NavigationLink("环境对象示例", destination: EnvironmentObjectDemo())
            }
            .padding()
        }
        .environmentObject(appState)
        .preferredColorScheme(appState.isDarkMode ? .dark : .light)
    }
}

// 登录视图
struct LoginView: View {
    @State private var name = ""
    @State private var email = ""
    @EnvironmentObject private var appState: AppState
    @AppStorage("lastLoggedInUser") private var lastLoggedInUser = ""
    
    var body: some View {
        VStack(spacing: 16) {
            TextField("姓名", text: $name)
                .textFieldStyle(.roundedBorder)
            TextField("邮箱", text: $email)
                .textFieldStyle(.roundedBorder)
            Button("登录") {
                let user = User(name: name, email: email)
                appState.login(user: user)
                lastLoggedInUser = name
            }
            .buttonStyle(.borderedProminent)
            .disabled(name.isEmpty || email.isEmpty)
            
            if !lastLoggedInUser.isEmpty {
                Text("上次登录: \(lastLoggedInUser)")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

// 计数器视图
struct CounterView: View {
    @State private var count = 0
    @SceneStorage("counterValue") private var storedCount = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("计数器")
                .font(.headline)
            Text("Count: \(count)")
                .font(.largeTitle)
                .fontWeight(.bold)
            HStack(spacing: 16) {
                Button("减1") {
                    count -= 1
                    storedCount = count
                }
                .buttonStyle(.bordered)
                Button("重置") {
                    count = 0
                    storedCount = 0
                }
                .buttonStyle(.bordered)
                Button("加1") {
                    count += 1
                    storedCount = count
                }
                .buttonStyle(.borderedProminent)
            }
            Text("场景存储值: \(storedCount)")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .onAppear {
            // 从场景存储恢复
            count = storedCount
        }
    }
}

// 待办事项应用
struct TodoApp: View {
    @State private var todos: [TodoItem] = [
        TodoItem(title: "学习 SwiftUI 状态管理"),
        TodoItem(title: "完成本章练习"),
        TodoItem(title: "构建示例应用")
    ]
    @State private var newTodoTitle = ""
    
    var body: some View {
        VStack {
            HStack(spacing: 8) {
                TextField("输入新的待办事项", text: $newTodoTitle)
                    .textFieldStyle(.roundedBorder)
                Button("添加") {
                    addTodo()
                }
                .buttonStyle(.borderedProminent)
                .disabled(newTodoTitle.isEmpty)
            }
            .padding()
            List {
                ForEach($todos) { $todo in
                    HStack {
                        Button(action: {
                            todo.isCompleted.toggle()
                        }) {
                            Image(systemName: todo.isCompleted ? "checkmark.circle.fill" : "circle")
                                .foregroundColor(todo.isCompleted ? .green : .gray)
                        }
                        .buttonStyle(.plain)
                        Text(todo.title)
                            .strikethrough(todo.isCompleted, color: .gray)
                            .foregroundColor(todo.isCompleted ? .secondary : .primary)
                        Spacer()
                        Button(action: {
                            deleteTodo(todo)
                        }) {
                            Image(systemName: "trash.fill")
                                .foregroundColor(.red)
                        }
                        .buttonStyle(.plain)
                    }
                }
            }
        }
        .navigationTitle("待办事项")
    }
    
    private func addTodo() {
        guard !newTodoTitle.isEmpty else { return }
        todos.append(TodoItem(title: newTodoTitle))
        newTodoTitle = ""
    }
    
    private func deleteTodo(_ todo: TodoItem) {
        if let index = todos.firstIndex(where: { $0.id == todo.id }) {
            todos.remove(at: index)
        }
    }
}

// 待办事项模型
struct TodoItem: Identifiable, Equatable {
    let id = UUID()
    var title: String
    var isCompleted = false
}

// 环境对象演示
struct EnvironmentObjectDemo: View {
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        VStack(spacing: 20) {
            Text("环境对象演示")
                .font(.headline)
            Text("当前主题: \(appState.isDarkMode ? "深色" : "浅色")")
            Text("登录状态: \(appState.currentUser != nil ? "已登录" : "未登录")")
            if let user = appState.currentUser {
                Text("用户: \(user.name)")
                Text("邮箱: \(user.email)")
            }
            Button("切换主题") {
                appState.toggleTheme()
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

#Preview {
    StateManagementDemo()
}

代码解析

AppState：使用 @StateObject 管理全局应用状态
User：符合 Identifiable 和 Equatable 协议的用户模型
StateManagementDemo：主应用视图，设置环境对象
LoginView：使用 @State 和 @AppStorage 管理登录状态
CounterView：使用 @State 和 @SceneStorage 管理计数器
TodoApp：使用 @State 管理待办事项列表
EnvironmentObjectDemo：使用 @EnvironmentObject 访问全局状态

小结

本章详细介绍了 SwiftUI 中的状态管理系统，包括：

@State：用于管理视图的本地状态
@Binding：用于父子视图之间的双向绑定
@StateObject：用于管理可观察对象的状态
@ObservedObject：用于观察外部传入的可观察对象
@EnvironmentObject：用于访问全局环境对象
@Environment：用于访问系统环境值
@SceneStorage：用于场景级别的持久化存储
@AppStorage：用于应用级别的持久化存储
@FocusedValue：用于传递聚焦相关的值
状态驱动 UI 更新的原理
状态管理的最佳实践
一个完整的状态管理示例应用

通过本章的学习，你已经掌握了 SwiftUI 中所有的状态管理技术，能够根据不同的场景选择合适的状态管理工具，创建具有复杂交互功能的应用。

参考资料

本内容为《SwiftUI 基础教程》第五章，欢迎关注后续更新。

昨天 — 2026年4月16日掘金 iOS

第4章：基础布局系统

掘金 iOS

作者 90后晨仔

2026年4月16日 21:21

示例代码都放这里啦，有需要的可以下载学习。swiftUIDemo

第4章：基础布局系统

4.1 垂直布局：VStack

VStack 介绍

VStack 是 SwiftUI 中用于垂直堆叠视图的容器，它会将子视图按垂直方向排列。VStack 是构建垂直布局的基础组件，适用于需要从上到下排列的界面元素。

基本用法


// 基本垂直栈

VStack {

    Text("第一行")

    Text("第二行")

    Text("第三行")

}

  


// 带间距和对齐的垂直栈

VStack(alignment: .leading, spacing: 20) {

    Text("左对齐")

    Text("第二行")

    Text("第三行")

}

.padding()

对齐方式

VStack 提供了三种主要的对齐方式：

.leading：左对齐
.center：居中对齐（默认）
.trailing：右对齐
.top、.bottom：在嵌套布局中使用


// 不同对齐方式

VStack(alignment: .leading) {

    Text("左对齐")

    Text("这是一行更长的文本")

    Text("短文本")

}

.padding()

  


VStack(alignment: .center) {

    Text("居中对齐")

    Text("这是一行更长的文本")

    Text("短文本")

}

.padding()

  


VStack(alignment: .trailing) {

    Text("右对齐")

    Text("这是一行更长的文本")

    Text("短文本")

}

.padding()

嵌套 VStack

VStack 可以嵌套使用，创建更复杂的布局结构。


// 嵌套垂直栈

VStack(spacing: 10) {

    Text("标题")

        .font(.headline)

    

    VStack(alignment: .leading, spacing: 8) {

        Text("项目 1")

        Text("项目 2")

        Text("项目 3")

    }

    .padding()

    .background(Color.gray.opacity(0.1))

    .cornerRadius(8)

    

    Button("确认") {}

}

.padding()

适用场景

表单布局：从上到下排列的输入字段
列表项：垂直排列的内容块
页面结构：标题、内容、按钮的垂直布局
卡片式布局：垂直堆叠的信息卡片

性能考虑

VStack 会根据子视图的大小自动调整高度
对于大量子视图，考虑使用 LazyVStack 来提高性能
避免过深的嵌套，可能会影响渲染性能

4.2 水平布局：HStack

HStack 介绍

HStack 是 SwiftUI 中用于水平堆叠视图的容器，它会将子视图按水平方向排列。HStack 是构建水平布局的基础组件，适用于需要从左到右排列的界面元素。

基本用法


// 基本水平栈

HStack {

    Text("左侧")

    Text("中间")

    Text("右侧")

}

  


// 带间距和对齐的水平栈

HStack(alignment: .top, spacing: 20) {

    Text("顶部对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

对齐方式

HStack 提供了三种主要的对齐方式：

.top：顶部对齐
.center：居中对齐（默认）
.bottom：底部对齐
.leading、.trailing：在嵌套布局中使用


// 不同对齐方式

HStack(alignment: .top) {

    Text("顶部对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

  


HStack(alignment: .center) {

    Text("居中对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

  


HStack(alignment: .bottom) {

    Text("底部对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

空间分配

HStack 可以使用 Spacer 来分配空间，实现更灵活的布局。


// 空间分配

HStack {

    Text("左侧")

    Spacer()  // 占据剩余空间

    Text("右侧")

}

.padding()

  


// 带比例的空间分配

HStack {

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

    Spacer()

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

    Spacer()

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

    Spacer()

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

}

.padding()

适用场景

工具栏：水平排列的操作按钮
列表项内容：左侧图标、中间文本、右侧箭头
表单行：标签和输入框的水平排列
导航栏：左侧返回按钮、中间标题、右侧操作按钮

性能考虑

HStack 会根据子视图的大小自动调整宽度
对于大量子视图，考虑使用 LazyHStack 来提高性能
注意水平空间不足时的布局行为，可能需要使用 ScrollView

4.3 层叠布局：ZStack

ZStack 介绍

ZStack 是 SwiftUI 中用于层叠视图的容器，它会将子视图按层叠方式排列，后面的视图会覆盖前面的视图。ZStack 是构建叠加效果的基础组件，适用于需要层级关系的界面元素。

基本用法


// 基本层叠

ZStack {

    Color.blue  // 背景

    Text("前景文本")

        .foregroundStyle(.white)

        .font(.largeTitle)

}

.frame(height: 200)

  


// 多层叠

ZStack {

    // 底层

    Rectangle()

        .fill(Color.yellow)

        .frame(width: 200, height: 200)

    

    // 中层

    Circle()

        .fill(Color.green)

        .frame(width: 150, height: 150)

    

    // 顶层

    Text("ZStack")

        .font(.headline)

}

对齐方式

ZStack 提供了多种对齐方式，可以精确控制子视图的位置：

.topLeading、.top、.topTrailing
.leading、.center、.trailing
.bottomLeading、.bottom、.bottomTrailing


// 不同对齐方式

ZStack(alignment: .topLeading) {

    Rectangle()

        .fill(Color.gray.opacity(0.2))

        .frame(width: 300, height: 200)

    

    Text("左上角")

        .padding(10)

}

  


ZStack(alignment: .center) {

    Rectangle()

        .fill(Color.gray.opacity(0.2))

        .frame(width: 300, height: 200)

    

    Text("居中")

}

  


ZStack(alignment: .bottomTrailing) {

    Rectangle()

        .fill(Color.gray.opacity(0.2))

        .frame(width: 300, height: 200)

    

    Text("右下角")

        .padding(10)

}

实际应用


// 带徽章的图标

ZStack(alignment: .topTrailing) {

    Image(systemName: "bell")

        .font(.system(size: 24))

    

    Circle()

        .fill(Color.red)

        .frame(width: 16, height: 16)

        .overlay {

            Text("3")

                .font(.system(size: 10))

                .foregroundStyle(.white)

        }

        .offset(x: 4, y: -4)

}

  


// 卡片覆盖效果

ZStack {

    RoundedRectangle(cornerRadius: 12)

        .fill(Color.white)

        .shadow(radius: 4)

        .frame(width: 300, height: 200)

    

    VStack {

        Text("卡片标题")

            .font(.headline)

        Text("卡片内容")

            .foregroundStyle(.secondary)

    }

    .padding()

    

    // 右上角标签

    Text("NEW")

        .font(.caption)

        .foregroundStyle(.white)

        .padding(4)

        .background(Color.blue)

        .cornerRadius(4)

        .offset(x: 45, y: -10)

}

适用场景

带背景的文本：文本叠加在背景之上
徽章效果：通知图标上的数字徽章
卡片布局：带有覆盖元素的信息卡片
复杂 UI 组件：需要多层叠加的自定义控件
模态视图：半透明覆盖层

性能考虑

ZStack 会按照添加顺序渲染视图，后面的视图会覆盖前面的
对于复杂的叠加效果，注意渲染性能
考虑使用 offset 修饰符来微调子视图位置

4.4 间距与对齐

间距设置

间距是布局中的重要因素，它决定了视图之间的关系和视觉舒适度。


// VStack 间距

VStack(spacing: 16) {

    Text("项目 1")

    Text("项目 2")

    Text("项目 3")

}

  


// HStack 间距

HStack(spacing: 20) {

    Text("左")

    Text("中")

    Text("右")

}

  


// 嵌套栈的间距

VStack(spacing: 20) {

    Text("标题")

    

    HStack(spacing: 10) {

        Button("按钮 1") {}

        Button("按钮 2") {}

    }

    

    Text("底部文本")

}

对齐设置

对齐决定了视图在容器中的位置，影响整体布局的一致性。


// 垂直对齐

VStack(alignment: .leading) {

    Text("左对齐")

    Text("这是一行更长的文本")

}

  


// 水平对齐

HStack(alignment: .center) {

    Text("顶部")

        .font(.largeTitle)

    Text("底部")

        .font(.footnote)

}

  


// 层叠对齐

ZStack(alignment: .bottom) {

    Image(systemName: "photo")

        .resizable()

        .aspectRatio(contentMode: .fit)

        .frame(height: 200)

    

    Text("图片标题")

        .padding()

        .background(Color.black.opacity(0.5))

        .foregroundStyle(.white)

        .frame(maxWidth: .infinity, alignment: .center)

}

内边距与外边距

内边距（padding）和外边距是控制视图与其他元素之间空间的重要工具。


// 内边距

VStack {

    Text("带内边距的文本")

        .padding()  // 四周内边距

    

    Text("自定义内边距")

        .padding(.horizontal, 20)  // 水平内边距

        .padding(.vertical, 10)    // 垂直内边距

}

  


// 外边距

VStack {

    Text("带外边距的文本")

}

.padding()  // 给整个 VStack 添加内边距

  


// 组合使用

Text("文本")

    .padding(10)  // 内边距

    .background(Color.yellow)

    .padding(10)  // 外边距（看起来像内边距）

    .background(Color.blue)

适用场景

表单设计：通过间距和对齐创建整齐的表单
卡片布局：使用内边距和外边距创建视觉层次感
响应式设计：根据不同屏幕尺寸调整间距
可访问性：适当的间距提高内容的可读性

最佳实践

保持一致的间距系统：使用统一的间距值（如 8、16、24 等）
考虑内容的重要性：重要内容之间应有更大的间距
响应式调整：在不同屏幕尺寸上调整间距
测试不同设备：确保在各种设备上布局都美观

4.5 垫片：Spacer

Spacer 介绍

Spacer 是 SwiftUI 中用于占据剩余空间的视图，它会自动扩展以填充可用空间。Spacer 是实现灵活布局的重要工具，特别适用于需要将元素推到容器边缘的场景。

基本用法


// 水平布局中的 Spacer

HStack {

    Text("左侧")

    Spacer()  // 占据中间的所有空间

    Text("右侧")

}

.padding()

  


// 垂直布局中的 Spacer

VStack {

    Text("顶部")

    Spacer()  // 占据中间的所有空间

    Text("底部")

}

.frame(height: 200)

.padding()

灵活使用


// 顶部对齐

VStack {

    Text("标题")

    Spacer()

}

.frame(height: 200)

.padding()

  


// 底部对齐

VStack {

    Spacer()

    Text("底部文本")

}

.frame(height: 200)

.padding()

  


// 两端对齐

HStack {

    Text("左侧")

    Spacer()

    Text("中间")

    Spacer()

    Text("右侧")

}

.padding()

实际应用


// 工具栏布局

HStack {

    Button("返回") {

        print("返回")

    }

    

    Spacer()

    

    Text("页面标题")

    

    Spacer()

    

    Button("更多") {

        print("更多")

    }

}

.padding()

.background(Color(.systemBackground))

  


// 表单底部按钮

VStack {

    // 表单内容

    ForEach(0..<3) {

        Text("表单项 \($0 + 1)")

            .padding()

            .background(Color.gray.opacity(0.1))

            .cornerRadius(8)

            .padding(.horizontal)

    }

    

    Spacer()

    

    // 底部按钮

    Button("提交") {

        print("提交")

    }

    .buttonStyle(.borderedProminent)

    .padding()

}

适用场景

工具栏：将标题居中，按钮放在两侧
表单：将提交按钮固定在底部
卡片：将内容推到顶部，操作按钮放在底部
导航栏：创建平衡的布局

性能考虑

Spacer 是轻量级视图，对性能影响很小
合理使用 Spacer 可以减少不必要的几何计算
避免在不需要的地方使用 Spacer，可能会导致意外的布局行为

4.6 布局修饰符

框架修饰符

frame 修饰符用于控制视图的大小和对齐方式。


// 设置固定大小

Text("固定大小")

    .frame(width: 200, height: 100)

    .background(Color.yellow)

  


// 设置最大和最小大小

Text("灵活大小")

    .frame(minWidth: 100, maxWidth: 300, minHeight: 50, maxHeight: 150)

    .background(Color.blue)

  


// 填充父容器

Text("填充")

    .frame(maxWidth: .infinity, maxHeight: .infinity)

    .background(Color.green)

  


// 带对齐的框架

Text("右对齐")

    .frame(width: 200, alignment: .trailing)

    .background(Color.gray.opacity(0.2))

位置修饰符

position 和 offset 修饰符用于调整视图的位置。


// 绝对位置

Text("绝对位置")

    .position(x: 100, y: 100)

  


// 相对偏移

Text("相对偏移")

    .offset(x: 50, y: 20)

  


// 组合使用

ZStack {

    Text("基础位置")

        .background(Color.yellow)

    

    Text("偏移位置")

        .offset(x: 50, y: 30)

        .background(Color.red)

}

布局优先级

layoutPriority 修饰符用于设置视图的布局优先级。


HStack {

    Text("短文本")

        .layoutPriority(1)  // 高优先级

        .background(Color.yellow)

    

    Text("这是一段非常长的文本，会被截断")

        .background(Color.blue)

}

.frame(width: 200)

适用场景

响应式设计：根据屏幕尺寸调整视图大小
自定义布局：精确控制视图位置
复杂界面：处理不同优先级的内容
动态布局：根据内容自动调整

4.7 网格布局：LazyVGrid 和 LazyHGrid

网格布局介绍

LazyVGrid 和 LazyHGrid 是 SwiftUI 中用于创建网格布局的容器，它们支持延迟加载，适用于大量数据。网格布局使用 GridItem 来定义列或行的大小和间距。

基本用法


// 定义网格列

let columns = [

    GridItem(.flexible()),

    GridItem(.flexible()),

    GridItem(.flexible())

]

  


// 垂直网格

ScrollView {

    LazyVGrid(columns: columns, spacing: 10) {

        ForEach(1..<10) { index in

            Rectangle()

                .fill(Color(hue: Double(index)/10, saturation: 0.8, brightness: 0.8))

                .frame(height: 80)

                .overlay(

                    Text("\(index)")

                        .foregroundColor(.white)

                        .font(.headline)

                )

        }

    }

    .padding()

}

  


// 水平网格

let rows = [

    GridItem(.flexible()),

    GridItem(.flexible())

]

  


ScrollView(.horizontal) {

    LazyHGrid(rows: rows, spacing: 10) {

        ForEach(1..<10) { index in

            Rectangle()

                .fill(Color(hue: Double(index)/10, saturation: 0.8, brightness: 0.8))

                .frame(width: 100)

                .overlay(

                    Text("\(index)")

                        .foregroundColor(.white)

                        .font(.headline)

                )

        }

    }

    .padding()

}

GridItem 配置

GridItem 支持多种大小配置：

.fixed：固定大小
.flexible：灵活大小（默认）
.adaptive：自适应大小，尽可能多的列


// 固定大小的列

let fixedColumns = [

    GridItem(.fixed(100)),

    GridItem(.fixed(100)),

    GridItem(.fixed(100))

]

  


// 自适应列数

let adaptiveColumns = [

    GridItem(.adaptive(minimum: 80, maximum: 120))

]

  


// 混合配置

let mixedColumns = [

    GridItem(.fixed(80)),

    GridItem(.flexible()),

    GridItem(.fixed(80))

]

适用场景

图片网格：相册、产品展示
图标网格：应用图标、功能入口
数据网格：表格数据展示
响应式布局：自适应不同屏幕尺寸

4.8 列表和表单：List 和 Form

List 列表

List 是 SwiftUI 中用于显示滚动列表的容器，自动处理单元格布局和数据展示。


// 基本列表

List {

    Text("项目 1")

    Text("项目 2")

    Text("项目 3")

}

  


// 带分组的列表

List {

    Section(header: Text("分组 1")) {

        Text("项目 1")

        Text("项目 2")

    }

    

    Section(header: Text("分组 2")) {

        Text("项目 3")

        Text("项目 4")

    }

}

  


// 动态列表

let items = ["苹果", "香蕉", "橙子", "葡萄"]

  


List(items, id: \.self) { item in

    HStack {

        Image(systemName: "fruit")

        Text(item)

    }

}

Form 表单

Form 是专门用于表单布局的容器，提供了预设的样式和间距。


// 基本表单

Form {

    TextField("用户名", text: .constant(""))

    SecureField("密码", text: .constant(""))

    Toggle("记住密码", isOn: .constant(true))

    Button("登录") {}

}

  


// 带分组的表单

Form {

    Section(header: Text("个人信息")) {

        TextField("姓名", text: .constant(""))

        TextField("邮箱", text: .constant(""))

    }

    

    Section(header: Text("偏好设置")) {

        Toggle("接收通知", isOn: .constant(true))

        Picker("主题", selection: .constant("浅色")) {

            Text("浅色").tag("浅色")

            Text("深色").tag("深色")

        }

    }

    

    Section {

        Button("保存设置") {}

    }

}

适用场景

List：显示结构化数据列表、设置项、联系人
Form：创建用户输入表单、设置页面、注册登录页面

4.9 几何读取器：GeometryReader

GeometryReader 介绍

GeometryReader 是一个特殊的容器，它可以读取父视图的几何信息（尺寸和位置），并根据这些信息来布局子视图。


// 基本用法

GeometryReader { geometry in

    VStack {

        Text("宽度: \(geometry.size.width)")

        Text("高度: \(geometry.size.height)")

        Text("安全区域: \(geometry.safeAreaInsets.top)")

    }

    .frame(width: geometry.size.width, height: geometry.size.height)

    .background(Color.gray.opacity(0.1))

}

  


// 根据父视图大小调整子视图

GeometryReader { geometry in

    HStack(spacing: 0) {

        Color.red

            .frame(width: geometry.size.width * 0.3)

        Color.green

            .frame(width: geometry.size.width * 0.3)

        Color.blue

            .frame(width: geometry.size.width * 0.4)

    }

}

.frame(height: 100)

  


// 自适应网格

GeometryReader { geometry in

    let columns = Int(geometry.size.width / 100)

    let gridItems = Array(repeating: GridItem(.flexible()), count: max(columns, 1))

    

    LazyVGrid(columns: gridItems, spacing: 10) {

        ForEach(1..<10) { index in

            Rectangle()

                .fill(Color(hue: Double(index)/10, saturation: 0.8, brightness: 0.8))

                .frame(height: 80)

                .overlay(

                    Text("\(index)")

                        .foregroundColor(.white)

                )

        }

    }

    .padding()

}

适用场景

响应式布局：根据屏幕尺寸调整布局
自定义布局：需要精确控制尺寸的场景
动画效果：基于几何信息创建动画
复杂布局：需要基于父视图尺寸的布局

4.10 其他重要布局组件

Divider 分隔线

Divider 用于在视图之间创建水平或垂直的分隔线。


// 水平分隔线

VStack {

    Text("顶部")

    Divider()

    Text("底部")

}

  


// 垂直分隔线

HStack {

    Text("左侧")

    Divider()

    Text("右侧")

}

.frame(height: 50)

Group 视图分组

Group 用于将多个视图组合在一起，作为一个整体应用修饰符。


// 分组应用修饰符

Group {

    Text("项目 1")

    Text("项目 2")

    Text("项目 3")

}

.foregroundColor(.blue)

.font(.headline)

  


// 条件渲染

Group {

    if true {

        Text("显示这个")

    } else {

        Text("显示那个")

    }

}

自定义布局（iOS 16+）

iOS 16 引入了 Layout 协议，允许创建完全自定义的布局。


// 简单的自定义布局

struct SimpleLayout: Layout {

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {

        // 计算布局尺寸

        return CGSize(width: proposal.width ?? 300, height: proposal.height ?? 200)

    }

    

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {

        // 放置子视图

        for (index, subview) in subviews.enumerated() {

            let x = bounds.minX + CGFloat(index) * 50

            let y = bounds.midY

            subview.place(at: CGPoint(x: x, y: y), proposal: .unspecified)

        }

    }

}

  


// 使用自定义布局

SimpleLayout {

    Text("1")

    Text("2")

    Text("3")

    Text("4")

}

.frame(height: 100)

.background(Color.gray.opacity(0.1))

实战：创建一个登录页面

需求分析

创建一个包含以下元素的登录页面：

应用图标和标题
用户名输入框
密码输入框（带可见性切换）
登录按钮
忘记密码链接
注册链接

代码实现


import SwiftUI

  


struct LoginView: View {

    // 状态变量

    @State private var username = ""

    @State private var password = ""

    @State private var showPassword = false

    

    var body: some View {

        ZStack {

            // 背景

            LinearGradient(

                colors: [.blue.opacity(0.1), .purple.opacity(0.1)],

                startPoint: .top,

                endPoint: .bottom

            )

            .ignoresSafeArea()

            

            VStack(spacing: 24) {

                // 应用图标和标题

                VStack(spacing: 12) {

                    Image(systemName: "lock.fill")

                        .resizable()

                        .aspectRatio(contentMode: .fit)

                        .frame(width: 80, height: 80)

                        .foregroundStyle(.blue)

                    

                    Text("欢迎回来")

                        .font(.largeTitle)

                        .fontWeight(.bold)

                    

                    Text("请登录以继续")

                        .foregroundStyle(.secondary)

                }

                

                // 输入区域

                VStack(spacing: 16) {

                    // 用户名输入框

                    TextField(

                        "用户名",

                        text: $username,

                        prompt: Text("请输入用户名")

                    )

                    .textFieldStyle(.roundedBorder)

                    .padding(.horizontal)

                    

                    // 密码输入框

                    ZStack(alignment: .trailing) {

                        if showPassword {

                            TextField(

                                "密码",

                                text: $password,

                                prompt: Text("请输入密码")

                            )

                        } else {

                            SecureField(

                                "密码",

                                text: $password,

                                prompt: Text("请输入密码")

                            )

                        }

                        

                        Button(action: {

                            showPassword.toggle()

                        }) {

                            Image(systemName: showPassword ? "eye.slash.fill" : "eye.fill")

                                .foregroundStyle(.secondary)

                                .padding(.trailing, 16)

                        }

                    }

                    .textFieldStyle(.roundedBorder)

                    .padding(.horizontal)

                    

                    // 忘记密码

                    HStack {

                        Spacer()

                        Button("忘记密码?") {

                            print("忘记密码")

                        }

                        .foregroundStyle(.blue)

                        .padding(.trailing)

                    }

                }

                

                // 登录按钮

                Button("登录") {

                    print("登录")

                }

                .buttonStyle(.borderedProminent)

                .tint(.blue)

                .padding(.horizontal)

                .frame(maxWidth: .infinity)

                

                // 注册链接

                HStack {

                    Text("还没有账号?")

                    Button("立即注册") {

                        print("注册")

                    }

                    .foregroundStyle(.blue)

                }

                

                Spacer()

            }

            .padding(.top, 60)

        }

    }

}

  


#Preview {

    LoginView()

}

代码解析

ZStack：用于层叠背景和内容，创建深度感
VStack：用于垂直排列各个部分，保持页面结构清晰
HStack：用于水平排列忘记密码链接和注册链接
Spacer：用于底部填充空间，将内容推到顶部
TextField 和 SecureField：用于用户输入
Button：用于操作按钮
LinearGradient：用于创建美观的背景渐变
** @State**：用于管理视图状态

实战：创建一个产品详情页

需求分析

创建一个产品详情页，包含以下元素：

产品图片
产品标题和价格
产品描述
规格选择
购买按钮

代码实现


import SwiftUI

  


struct ProductDetailView: View {

    // 状态变量

    @State private var selectedColor = "红色"

    @State private var selectedSize = "M"

    @State private var quantity = 1

    

    // 产品数据

    let productName = "SwiftUI 高级教程"

    let productPrice = "¥99.00"

    let productDescription = "本教程涵盖了 SwiftUI 的高级特性，包括动画、手势、布局和性能优化等内容。通过实际项目案例，帮助你掌握 SwiftUI 的核心概念和最佳实践。"

    let colors = ["红色", "蓝色", "黑色"]

    let sizes = ["S", "M", "L", "XL"]

    

    var body: some View {

        ScrollView {

            VStack(spacing: 20) {

                // 产品图片

                ZStack {

                    Color.gray.opacity(0.1)

                        .frame(height: 300)

                    

                    Image(systemName: "book.fill")

                        .resizable()

                        .aspectRatio(contentMode: .fit)

                        .frame(width: 150, height: 150)

                        .foregroundStyle(.blue)

                }

                

                // 产品信息

                VStack(alignment: .leading, spacing: 12) {

                    HStack {

                        Text(productName)

                            .font(.title)

                            .fontWeight(.bold)

                        Spacer()

                        Text(productPrice)

                            .font(.title)

                            .fontWeight(.bold)

                            .foregroundStyle(.red)

                    }

                    

                    // 产品描述

                    Text(productDescription)

                        .foregroundStyle(.secondary)

                        .lineLimit(nil)

                    

                    // 颜色选择

                    Text("颜色")

                        .font(.headline)

                    HStack(spacing: 10) {

                        ForEach(colors, id: \.self) {

                            color in

                            Button(action: {

                                selectedColor = color

                            }) {

                                Text(color)

                                    .padding(8)

                                    .background(selectedColor == color ? Color.blue : Color.gray.opacity(0.1))

                                    .foregroundStyle(selectedColor == color ? .white : .primary)

                                    .cornerRadius(4)

                            }

                        }

                    }

                    

                    // 尺寸选择

                    Text("尺寸")

                        .font(.headline)

                    HStack(spacing: 10) {

                        ForEach(sizes, id: \.self) {

                            size in

                            Button(action: {

                                selectedSize = size

                            }) {

                                Text(size)

                                    .padding(8)

                                    .background(selectedSize == size ? Color.blue : Color.gray.opacity(0.1))

                                    .foregroundStyle(selectedSize == size ? .white : .primary)

                                    .cornerRadius(4)

                            }

                        }

                    }

                    

                    // 数量选择

                    Text("数量")

                        .font(.headline)

                    HStack {

                        Button(action: {

                            if quantity > 1 {

                                quantity -= 1

                            }

                        }) {

                            Image(systemName: "minus.circle")

                                .font(.system(size: 24))

                        }

                        

                        Text("\(quantity)")

                            .font(.headline)

                            .padding(.horizontal, 20)

                        

                        Button(action: {

                            quantity += 1

                        }) {

                            Image(systemName: "plus.circle")

                                .font(.system(size: 24))

                        }

                    }

                }

                .padding()

                

                // 购买按钮

                Button("加入购物车") {

                    print("加入购物车")

                }

                .buttonStyle(.borderedProminent)

                .tint(.blue)

                .padding(.horizontal)

                .frame(maxWidth: .infinity)

                .padding(.bottom, 30)

            }

        }

        .navigationTitle("产品详情")

        .navigationBarTitleDisplayMode(.inline)

    }

}

  


#Preview {

    ProductDetailView()

}

代码解析

ScrollView：用于滚动显示产品详情
ZStack：用于显示产品图片和背景
VStack：用于垂直排列产品信息
HStack：用于水平排列价格、颜色选择、尺寸选择和数量控制
Button：用于选择颜色、尺寸和调整数量
** @State**：用于管理用户选择的状态

小结

本章详细介绍了 SwiftUI 中的基础布局系统，包括：

VStack：垂直堆叠视图，适用于从上到下的布局
HStack：水平堆叠视图，适用于从左到右的布局
ZStack：层叠视图，适用于需要层级关系的布局
间距与对齐：控制视图之间的空间和位置关系
Spacer：占据剩余空间，实现灵活布局
布局修饰符：控制视图的大小、位置和优先级
网格布局：LazyVGrid、LazyHGrid，用于创建网格
列表和表单：List、Form，用于显示列表和表单
几何读取器：GeometryReader，用于获取父视图尺寸
其他布局组件：Divider、Group、自定义布局
实战案例：登录页面和产品详情页的完整实现

布局最佳实践

保持简洁：使用最少的容器实现所需布局
嵌套合理：避免过深的布局嵌套
响应式设计：考虑不同屏幕尺寸的布局适配
性能优化：对于大量数据使用 Lazy 容器
一致性：保持间距和对齐的一致性
可访问性：确保布局对所有用户都友好

通过本章的学习，你已经掌握了 SwiftUI 中最基本的布局技巧，能够创建各种常见的布局结构。在实际开发中，你可以根据具体需求选择合适的布局容器和技术，创建美观、响应式的用户界面。

参考资料

本内容为《SwiftUI 基础教程》第四章，欢迎关注后续更新。

第3章：基础视图组件

掘金 iOS

作者 90后晨仔

2026年4月16日 20:46

示例代码都放这里啦，有需要的可以下载学习。swiftUIDemo

3.1 文本显示：Text

Text 组件介绍

Text 是 SwiftUI 中最基本的视图组件，用于显示文本内容。它支持富文本、字体样式、颜色等多种属性。

基本用法

// 基本文本
Text("Hello, SwiftUI!")

// 带样式的文本
Text("Hello, SwiftUI!")
    .font(.largeTitle)         // 设置字体大小
    .fontWeight(.bold)         // 设置字重
    .foregroundStyle(.blue)    // 设置文本颜色
    .italic()                  // 斜体
    .underline()               // 下划线
    .strikethrough()           // 删除线

富文本

// 富文本
Text("Hello, \(Text("SwiftUI").foregroundStyle(.blue).bold())!")

// 多行文本
Text("这是一段多行文本，\n可以通过反斜杠 n 来换行，\n或者直接在字符串中换行。")
    .multilineTextAlignment(.center)  // 多行文本对齐方式
    .lineLimit(3)                     // 限制行数
    .truncationMode(.tail)            // 截断方式

本地化

// 本地化文本
Text("welcome_message")  // 从 Localizable.strings 文件中读取

// 带参数的本地化
Text("greeting", comment: "欢迎语")

// 格式化文本
let name = "张三"
Text("欢迎 %@", name)

日期和数字格式化

// 日期格式化
let date = Date()
Text(date, style: .date)           // 仅日期
Text(date, style: .time)           // 仅时间
Text(date, style: .relative)       // 相对时间
Text(date, style: .offset)         // 时间偏移
Text(date, style: .timer)          // 计时器

// 数字格式化
let number = 123456.789
Text(number, format: .number)
Text(number, format: .currency(code: "CNY"))
Text(number, format: .percent)

3.2 图片显示：Image

Image 组件介绍

Image 用于显示图片，可以从系统图标、资源文件或网络加载图片。

基本用法

// 系统图标
Image(systemName: "star.fill")

// 资源文件图片
Image("avatar")

// 网络图片 (iOS 15+)
AsyncImage(url: URL(string: "https://example.com/image.jpg")) { phase in
    switch phase {
    case .empty:
        ProgressView()  // 加载中
    case .success(let image):
        image
            .resizable()
            .aspectRatio(contentMode: .fill)
    case .failure:
        Image(systemName: "photo")  // 加载失败
    @unknown default:
        EmptyView()
    }
}

图片修饰符

Image("avatar")
    .resizable()                 // 可调整大小
    .aspectRatio(contentMode: .fit)  // 内容模式
    .frame(width: 100, height: 100)  // 设置大小
    .clipShape(Circle())         // 裁剪形状
    .overlay(                    // 叠加内容
        Circle()
            .stroke(Color.blue, lineWidth: 2)
    )
    .shadow(radius: 5)           // 阴影
    .opacity(0.8)                // 透明度

系统图标

// 系统图标
Image(systemName: "heart.fill")
    .foregroundStyle(.red)
    .font(.system(size: 24))

// 多色图标 (iOS 15+)
Image(systemName: "person.fill.badge.plus")
    .symbolRenderingMode(.multicolor)

// 可变颜色图标
Image(systemName: "star")
    .foregroundStyle(.yellow)

3.3 按钮交互：Button

Button 组件介绍

Button 用于创建可点击的按钮，支持多种样式和交互方式。

基本用法

// 基本按钮
Button("点击我") {
    print("按钮被点击了")
}

// 带图标的按钮
Button {
    print("按钮被点击了")
} label: {
    HStack {
        Image(systemName: "star.fill")
        Text("喜欢")
    }
}

// 带角色的按钮
Button("删除", role: .destructive) {
    print("删除操作")
}

按钮样式

// 边框按钮
Button("边框按钮") {
    // 操作
}
.buttonStyle(.bordered)

// 突出显示的按钮
Button("突出按钮") {
    // 操作
}
.buttonStyle(.borderedProminent)
.tint(.blue)  // 按钮颜色

// 胶囊按钮
Button("胶囊按钮") {
    // 操作
}
.buttonStyle(.borderedProminent)
.tint(.green)
.cornerRadius(20)

// 文本按钮
Button("文本按钮") {
    // 操作
}
.buttonStyle(.plain)

禁用状态

@State private var isEnabled = false

Button("禁用按钮") {
    // 操作
}
.disabled(!isEnabled)
.opacity(isEnabled ? 1.0 : 0.5)

3.4 输入控件：TextField、SecureField、TextEditor

TextField 文本输入框

@State private var text = ""

TextField("请输入文本", text: $text)
    .textFieldStyle(.roundedBorder)  // 边框样式
    .padding()                      // 内边距
    .keyboardType(.default)         // 键盘类型
    .autocapitalization(.sentences) // 自动大写
    .autocorrectionDisabled(true)   // 禁用自动纠正

// 带提示的 TextField
TextField(
    "请输入用户名",
    text: $text,
    prompt: Text("用户名不能为空")
        .foregroundStyle(.secondary)
)
.textFieldStyle(.roundedBorder)

SecureField 安全输入框

@State private var password = ""

SecureField("请输入密码", text: $password)
    .textFieldStyle(.roundedBorder)
    .padding()

// 带可见性切换的密码输入
@State private var showPassword = false

ZStack(alignment: .trailing) {
    if showPassword {
        TextField("请输入密码", text: $password)
    } else {
        SecureField("请输入密码", text: $password)
    }
    Button(action: {
        showPassword.toggle()
    }) {
        Image(systemName: showPassword ? "eye.slash.fill" : "eye.fill")
            .foregroundStyle(.secondary)
            .padding(.trailing, 8)
    }
}
.textFieldStyle(.roundedBorder)
.padding()

TextEditor 多行文本编辑器

@State private var message = ""

TextEditor(text: $message)
    .frame(height: 150)           // 设置高度
    .border(Color.gray.opacity(0.3), width: 1)  // 边框
    .cornerRadius(8)              // 圆角
    .padding()
    .foregroundStyle(.primary)    // 文本颜色

// 带占位符的 TextEditor
ZStack(alignment: .topLeading) {
    TextEditor(text: $message)
        .frame(height: 150)
        .padding(8)
    
    if message.isEmpty {
        Text("请输入消息...")
            .foregroundStyle(.secondary)
            .padding(10)
            .allowsHitTesting(false)  // 允许点击穿透
    }
}
.border(Color.gray.opacity(0.3), width: 1)
.cornerRadius(8)
.padding()

3.5 开关与选择：Toggle、Picker、Slider、Stepper

Toggle 开关

@State private var isEnabled = false

Toggle("启用功能", isOn: $isEnabled)
    .toggleStyle(.switch)  // 开关样式
    .padding()

// 带图标的 Toggle
Toggle(isOn: $isEnabled) {
    HStack {
        Image(systemName: "bell.fill")
        Text("接收通知")
    }
}
.toggleStyle(.switch)
.padding()

Picker 选择器

@State private var selectedOption = "选项1"
let options = ["选项1", "选项2", "选项3"]

// 分段控件样式
Picker("选择", selection: $selectedOption) {
    ForEach(options, id: \.self) {
        Text($0)
    }
}
.pickerStyle(.segmented)
.padding()

// 菜单样式
Picker("选择", selection: $selectedOption) {
    ForEach(options, id: \.self) {
        Text($0)
    }
}
.pickerStyle(.menu)
.padding()

// 轮盘样式（iOS 14+）
@State private var selectedColor = Color.red
let colors: [Color] = [.red, .green, .blue, .yellow]

Picker("颜色", selection: $selectedColor) {
    ForEach(colors, id: \.self) {
        ColorPickerView(color: $0)
    }
}
.pickerStyle(.wheel)
.frame(height: 200)
.padding()

// 辅助视图
struct ColorPickerView: View {
    let color: Color
    var body: some View {
        HStack {
            Rectangle()
                .fill(color)
                .frame(width: 20, height: 20)
                .cornerRadius(4)
            Text(String(describing: color))
        }
    }
}

Slider 滑块

@State private var value = 0.5

Slider(value: $value, in: 0...1)
    .padding()
    .tint(.blue)  // 滑块颜色

// 带标签的滑块
Slider(
    value: $value,
    in: 0...1,
    label: { Text("亮度") },
    minimumValueLabel: { Text("暗") },
    maximumValueLabel: { Text("亮") }
)
.padding()

// 整数滑块
@State private var intValue = 5

Slider(value: Binding(
    get: { Double(intValue) },
    set: { intValue = Int($0) }
), in: 0...10, step: 1)
.padding()
Text("值：\(intValue)")

Stepper 步进器

@State private var count = 0

Stepper("数量：\(count)", value: $count)
    .padding()

// 带范围的步进器
Stepper(
    "数量：\(count)",
    value: $count,
    in: 0...10,
    step: 2
)
.padding()

// 带标签的步进器
Stepper {
    Text("数量：\(count)")
} onIncrement: {
    count += 1
    print("增加到：\(count)")
} onDecrement: {
    count -= 1
    print("减少到：\(count)")
}
.padding()

3.6 进度指示：ProgressView

不确定进度

// 基本进度指示器
ProgressView()

// 带标签的进度指示器
ProgressView("加载中...")

// 带样式的进度指示器
ProgressView("处理中...")
    .progressViewStyle(.circular)
    .tint(.blue)
    .padding()

确定进度

@State private var progress = 0.0

ProgressView("下载进度", value: progress, total: 1.0)
    .padding()

// 带百分比的进度条
ProgressView(
    value: progress,
    total: 1.0,
    label: { Text("下载进度") },
    currentValueLabel: { Text("\(Int(progress * 100))%") }
)
.padding()

// 水平进度条样式
ProgressView(value: progress, total: 1.0)
    .progressViewStyle(.linear)
    .tint(.green)
    .frame(height: 10)
    .padding()

实战：创建一个用户设置页面

需求分析

创建一个包含以下元素的用户设置页面：

个人信息区域
通知设置（开关）
主题选择（选择器）
字体大小（滑块）
清除缓存按钮
退出登录按钮

代码实现

import SwiftUI

struct SettingsView: View {
    // 状态变量
    @State private var notificationsEnabled = true
    @State private var selectedTheme = "浅色"
    @State private var fontSize = 16.0
    @State private var cacheSize = "128 MB"
    
    // 主题选项
    let themes = ["浅色", "深色", "跟随系统"]
    
    var body: some View {
        NavigationStack {
            List {
                // 个人信息区域
                Section {
                    HStack {
                        Image(systemName: "person.circle.fill")
                            .resizable()
                            .aspectRatio(contentMode: .fill)
                            .frame(width: 60, height: 60)
                            .foregroundStyle(.blue)
                        
                        VStack(alignment: .leading, spacing: 4) {
                            Text("张三")
                                .font(.headline)
                            Text("zhangsan@example.com")
                                .font(.subheadline)
                                .foregroundStyle(.secondary)
                        }
                        Spacer()
                        Image(systemName: "chevron.right")
                            .foregroundStyle(.secondary)
                    }
                    .padding(.vertical, 8)
                }
                
                // 通知设置
                Section("通知设置") {
                    Toggle("接收推送通知", isOn: $notificationsEnabled)
                    Toggle("声音提醒", isOn: $notificationsEnabled)
                    Toggle("振动提醒", isOn: $notificationsEnabled)
                }
                
                // 外观设置
                Section("外观设置") {
                    Picker("主题", selection: $selectedTheme) {
                        ForEach(themes, id: \.self) {
                            Text($0)
                        }
                    }
                    .pickerStyle(.menu)
                    
                    VStack(alignment: .leading, spacing: 8) {
                        Text("字体大小：\(Int(fontSize))")
                        Slider(value: $fontSize, in: 12...24, step: 1)
                            .tint(.blue)
                    }
                }
                
                // 存储设置
                Section("存储设置") {
                    HStack {
                        Text("缓存大小")
                        Spacer()
                        Text(cacheSize)
                            .foregroundStyle(.secondary)
                    }
                    Button("清除缓存") {
                        // 清除缓存逻辑
                        print("清除缓存")
                    }
                    .foregroundStyle(.blue)
                }
                
                // 账户设置
                Section {
                    Button("关于我们") {
                        // 关于我们逻辑
                    }
                    Button("隐私政策") {
                        // 隐私政策逻辑
                    }
                    Button("退出登录", role: .destructive) {
                        // 退出登录逻辑
                    }
                }
            }
            .navigationTitle("设置")
            .navigationBarTitleDisplayMode(.inline)
        }
    }
}

#Preview {
    SettingsView()
}

代码解析

List 和 Section：使用列表和分组组织设置项
NavigationStack：提供导航功能
Toggle：用于开关设置
Picker：用于主题选择
Slider：用于调整字体大小
Button：用于操作按钮
HStack 和 VStack：用于布局
@State：用于管理视图状态

小结

本章介绍了 SwiftUI 中的基础视图组件，包括：

Text：文本显示，支持富文本、本地化和格式化
Image：图片显示，支持系统图标、资源文件和网络图片
Button：按钮交互，支持多种样式和角色
输入控件：TextField、SecureField、TextEditor
选择控件：Toggle、Picker、Slider、Stepper
进度指示：ProgressView
一个完整的用户设置页面实战

通过本章的学习，你已经掌握了 SwiftUI 中最常用的基础组件，能够创建各种常见的用户界面元素。

参考资料

本内容为《SwiftUI 基础教程》第三章，欢迎关注后续更新。

# iOS 稳定性方向常见面试题与详解

掘金 iOS

作者忆江南

2026年4月16日 11:19

iOS 稳定性方向常见面试题与详解

1. Crash 分类与原理

Q: iOS Crash 可以分为哪几大类？各自的产生原因是什么？

iOS Crash 主要分为三大类：

(1) OC 异常（NSException）

由 Objective-C 运行时或 Foundation 框架抛出，常见场景：

unrecognized selector sent to instance：对象收到了未实现的消息
数组越界 objectAtIndex: 超出 bounds
字典插入 nil value 或 nil key
KVO 移除了未注册的观察者
NSInvalidArgumentException：参数不合法

(2) Mach 异常 / Unix Signal

操作系统层面的异常，由内核产生：

Signal	含义	常见场景
SIGSEGV	访问无效内存	野指针、访问已释放对象
SIGBUS	总线错误，内存对齐问题	访问未映射地址
SIGABRT	程序主动调用 abort()	NSException 未捕获会触发
SIGTRAP	断点/陷阱指令	__builtin_trap()、Swift fatalError
SIGILL	非法指令	代码段损坏
SIGFPE	算术异常	除零
SIGPIPE	向已关闭的 socket 写数据	网络编程

(3) 被系统杀死

不属于传统意义的 Crash，但表现一致：

Watchdog（0x8badf00d）：主线程卡死超时
Jetsam/OOM（0xd00d2bad）：内存超限被系统终止
后台超时：后台任务未在限定时间内完成

2. Mach 异常与 Unix Signal

Q: 请描述 Mach 异常和 Unix Signal 的关系和传递流程。

传递流程

硬件异常 / 软件异常
      ↓
  Mach 异常（内核态）
      ↓
  Mach 异常处理 port（task/thread/host 级别）
      ↓
  如果未处理，内核将其转换为对应的 Unix Signal
      ↓
  Signal Handler（用户态）
      ↓
  如果未处理，进程被终止

关键要点

Mach 异常先于 Signal：内核先尝试通过 Mach 异常端口投递，如果没有 handler 消化，才转换成 Signal。
注册 Mach 异常 handler：通过 task_set_exception_ports() 在 task 级别注册，或通过 thread_set_exception_ports() 在线程级别注册。
注册 Signal handler：通过 signal() 或更推荐的 sigaction() 注册。
两者都注册时：先触发 Mach 异常 handler，再触发 Signal handler。
NSException 最终也会走到 Signal：未被 @try-@catch 或 NSSetUncaughtExceptionHandler 捕获的 OC 异常，最终调用 abort() 产生 SIGABRT。

Mach 异常与 Signal 的映射

Mach 异常	Unix Signal
EXC_BAD_ACCESS	SIGSEGV / SIGBUS
EXC_BAD_INSTRUCTION	SIGILL
EXC_ARITHMETIC	SIGFPE
EXC_BREAKPOINT	SIGTRAP
EXC_SOFTWARE	SIGABRT / SIGPIPE 等

为什么 Crash 收集框架同时注册两者？

Mach 异常可以获得更底层的信息（如 fault address），但不是所有异常都先经过 Mach（如 abort() 直接发 signal）。
Signal handler 可以兜底，但在某些场景下信息不完整。
同时注册可以覆盖更全面的 Crash 场景。

3. OC 层异常捕获（NSException）

Q: NSSetUncaughtExceptionHandler 的原理和注意事项是什么？

原理

void MyUncaughtExceptionHandler(NSException *exception) {
    NSString *name = exception.name;
    NSString *reason = exception.reason;
    NSArray *callStack = exception.callStackSymbols;
    // 持久化保存 crash 信息
}

// 注册
NSSetUncaughtExceptionHandler(&MyUncaughtExceptionHandler);

OC 运行时在异常未被 @try-@catch 捕获时，检查是否设置了全局的 UncaughtExceptionHandler。
如果有，调用该 handler，传入 NSException 对象。
handler 返回后，运行时调用 abort() 终止进程。

注意事项

Handler 会被覆盖：多个 SDK 都可能调用 NSSetUncaughtExceptionHandler，后者覆盖前者。正确做法是保存前一个 handler 并在自己的 handler 中转发：

static NSUncaughtExceptionHandler *previousHandler = nil;

void MyHandler(NSException *exception) {
    // 自己的处理逻辑
    saveException(exception);
    // 转发给前一个 handler
    if (previousHandler) {
        previousHandler(exception);
    }
}

previousHandler = NSGetUncaughtExceptionHandler();
NSSetUncaughtExceptionHandler(&MyHandler);

handler 中不能做太多事：此时进程即将终止，信号可能不安全，应避免申请大块内存、使用锁等操作。
只能捕获 OC 异常：C++ 异常、Mach 异常等无法通过此方式捕获。
callStackSymbols 不一定完整：Release 环境下符号可能被 strip，需要配合 dSYM 符号化。

4. Unrecognized Selector 防护

Q: 如何在线上防护 unrecognized selector 导致的 Crash？请描述 OC 消息转发机制。

OC 消息转发三步流程

1. 动态方法决议（Dynamic Method Resolution）
   +resolveInstanceMethod: / +resolveClassMethod:
   → 可以动态添加方法实现
          ↓ 返回 NO
2. 快速转发（Fast Forwarding）
   -forwardingTargetForSelector:
   → 返回另一个可以处理该消息的对象
          ↓ 返回 nil
3. 完整转发（Normal Forwarding）
   -methodSignatureForSelector:
   -forwardInvocation:
   → 构造 NSInvocation 做完整转发
          ↓ 未处理
   调用 -doesNotRecognizeSelector: → 抛出 NSException → Crash

防护方案

Hook forwardingTargetForSelector: 方法，在消息转发的第二步进行拦截：

- (id)safe_forwardingTargetForSelector:(SEL)selector {
    BOOL aBool = [self respondsToSelector:@selector(selector)];
    NSMethodSignature *signature = [self methodSignatureForSelector:selector];
    // 如果已经有消息转发的实现（如 JSPatch），不拦截，继续走原始流程
    if (aBool || signature) {
        return [self safe_forwardingTargetForSelector:selector];
    } else {
        // 报告异常但不 crash，返回一个动态添加了该方法的"桩对象"
        reportBug(self.class, selector);
        SafeGuardStub *stub = [[SafeGuardStub alloc] init];
        [stub addAnyFunc:selector];
        return stub;
    }
}

关键设计细节

桩对象动态添加方法：通过 class_addMethod 给桩对象添加空实现，避免继续走消息转发导致死循环。
兼容性考量：必须判断 methodSignatureForSelector: 是否返回非 nil，因为有些框架（如 JSPatch、Aspects）依赖完整消息转发，如果提前拦截会导致这些框架失效。
上报但不 crash：线上记录异常信息用于排查，但不中断用户体验。

5. KVO Crash 防护

Q: KVO 常见的 Crash 场景有哪些？如何防护？

常见 Crash 场景

移除未注册的观察者：-removeObserver:forKeyPath: 找不到匹配的注册信息
重复添加同一观察者（某些场景会导致回调多次触发或移除时 crash）
被观察对象 dealloc 时仍有观察者注册
观察者 dealloc 时未移除注册（iOS 11 以前会 crash）

防护方案：KVO 代理中间层

核心思想：维护一个 KVO 关系映射表，拦截 add/remove 操作。

@interface KVOProxy : NSObject
@property (nonatomic, strong) NSMapTable<NSString *, NSHashTable *> *observerMap;
@end

// Hook addObserver:forKeyPath:options:context:
- (void)safe_addObserver:(NSObject *)observer
              forKeyPath:(NSString *)keyPath
                 options:(NSKeyValueObservingOptions)options
                 context:(void *)context {
    // 检查是否已注册，防止重复
    if ([self.kvoProxy containsObserver:observer forKeyPath:keyPath]) {
        return;
    }
    [self.kvoProxy recordObserver:observer forKeyPath:keyPath];
    [self safe_addObserver:observer forKeyPath:keyPath options:options context:context];
}

// Hook removeObserver:forKeyPath:
- (void)safe_removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath {
    if (![self.kvoProxy containsObserver:observer forKeyPath:keyPath]) {
        return; // 未注册则跳过，避免 crash
    }
    [self.kvoProxy removeObserver:observer forKeyPath:keyPath];
    [self safe_removeObserver:observer forKeyPath:keyPath];
}

注意事项

Hook 方式有两种：(a) Swizzle NSObject 的 KVO 方法；(b) 使用 KVO 代理对象集中管理。
方案 (b) 更安全，但实现复杂度更高。
需要在被观察对象 dealloc 时自动清理未移除的观察者。

6. 容器类越界/插 nil 防护

Q: 如何对 NSArray/NSMutableArray/NSDictionary 等容器类做安全防护？为什么需要 Hook 类簇的真实子类？

为什么需要 Hook 真实子类？

OC 中的 NSArray、NSDictionary 等是**类簇（Class Cluster）**设计模式，对外暴露抽象接口，内部使用不同的私有子类：

抽象类	真实子类
NSArray	`__NSArrayI`（不可变）、`__NSArray0`（空数组）、`__NSSingleObjectArrayI`（单元素）
NSMutableArray	`__NSArrayM`
NSDictionary	`__NSDictionaryI`
NSMutableDictionary	`__NSDictionaryM`
NSString	`__NSCFString`、`NSTaggedPointerString`

直接 Swizzle NSArray 的方法不会生效，因为实际运行时对象的类是 __NSArrayI。必须通过 NSClassFromString() 获取真实子类再进行 Swizzle。

防护示例

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = NSClassFromString(@"__NSArrayI");
        safe_swizzleSelector(class,
            @selector(objectAtIndex:), self,
            @selector(safe_objectAtIndex:));
    });
}

- (id)safe_objectAtIndex:(NSUInteger)index {
    if (index >= self.count) {
        // 记录并上报，但不 crash
        reportException(@"NSArray index out of bounds");
        return nil;
    }
    return [self safe_objectAtIndex:index];
}

常见防护点

NSArray: objectAtIndex:, objectAtIndexedSubscript:, initWithObjects:count:
NSMutableArray: addObject:, insertObject:atIndex:, removeObjectAtIndex:, replaceObjectAtIndex:withObject:
NSDictionary: initWithObjects:forKeys:count:
NSMutableDictionary: setObject:forKey:, removeObjectForKey:
NSString: substringWithRange:, characterAtIndex:, stringWithUTF8String:（NULL 检查）

7. 野指针 Crash

Q: 什么是野指针？为什么野指针 Crash 难以复现？如何检测和防护？

什么是野指针

对象被释放后，指向该内存地址的指针没有被置 nil，再次访问就是野指针访问。

为什么难以复现

对象释放后内存进入空闲池，如果该内存被立即复用（分配给新对象），访问旧指针可能：

刚好访问到新对象 → 行为不可预期但不一定 crash
内存未被复用 → SIGSEGV crash
内存被复用为相同类型对象 → 可能表现正常

这种随机性导致问题难以复现。

检测手段

1. Xcode Zombie Objects（开发阶段）

开启 NSZombieEnabled，对象释放后不真正回收内存，而是变成"僵尸对象"。再次访问时会打印明确的日志并 crash。

原理：

Swizzle dealloc，对象释放时将 isa 指针指向 _NSZombie_OriginalClass
向僵尸对象发消息时，objc_msgSend 识别到 Zombie 类，打印日志

2. Address Sanitizer (ASan)

编译时插桩，运行时检测内存越界、use-after-free 等。性能开销约 2-5x，适合开发和测试阶段。

3. Malloc Scribble

释放内存时用 0x55 填充，访问已释放内存大概率 crash，提高复现率。

4. 线上野指针防护方案

思路类似 Zombie，但更轻量：

对象 dealloc 时：
1. 不立即释放内存，放入一个延迟释放队列
2. 将 isa 替换为代理类，代理类的所有方法都上报异常
3. 延迟释放队列满（如超过 10MB）时，真正释放最早入队的对象

这样在对象被真正回收前，任何野指针访问都会被代理类拦截。

8. 内存管理与 OOM

Q: 什么是 OOM？Jetsam 机制是什么？如何监控和治理 OOM？

OOM（Out Of Memory）

iOS 没有内存交换机制（Swap），物理内存耗尽时系统直接终止进程。App 被 Jetsam 杀死时不会产生标准 Crash 日志。

Jetsam 机制

Jetsam 是 iOS/macOS 的内存压力管理系统：

系统维护一个进程优先级队列
内存压力升高时按优先级从低到高终止进程
优先级：后台App < 前台App < 系统进程
终止原因码 0xd00d2bad（FC_RES_TYPE_MEMORY）

内存警告级别

UIApplicationDidReceiveMemoryWarningNotification
  ↓
didReceiveMemoryWarning
  ↓
如果内存未降低 → Jetsam 终止进程

如何监控 OOM

1. 排除法判断 OOM

Facebook 提出的方案：如果上次退出不是以下原因，则认为是 OOM：

非 OOM 退出原因：
- 用户主动杀进程
- App 更新
- crash（有 crash 日志）
- watchdog 杀死
- 正常退出（applicationWillTerminate）
- 调试模式下被 Xcode 杀死

排除以上所有原因后 → 判定为 OOM

2. 内存水位监控

定期采样 App 内存占用：

#import <mach/mach.h>

- (int64_t)memoryUsageInBytes {
    task_vm_info_data_t vmInfo;
    mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
    kern_return_t result = task_info(mach_task_self(),
                                     TASK_VM_INFO,
                                     (task_info_t)&vmInfo,
                                     &count);
    if (result == KERN_SUCCESS) {
        return vmInfo.phys_footprint; // 物理内存占用
    }
    return 0;
}

OOM 治理方向

方向	措施
图片	使用 ImageIO 降采样加载，避免全尺寸解码；及时释放不可见图片
缓存	使用 NSCache（自动响应内存警告），设置合理上限
大数据	分页加载，避免一次加载全量数据
WebView	WKWebView 独立进程，OOM 不影响宿主
内存泄漏	定期检测循环引用（MLeaksFinder / Instruments Leaks）
监控	建立内存水位报警机制，超过阈值主动释放缓存

9. Watchdog 超时（0x8badf00d）

Q: 什么是 Watchdog 机制？如何避免和排查 Watchdog Crash？

Watchdog 机制

系统有一个看门狗线程监控主线程响应能力。如果主线程在规定时间内未完成特定回调，系统直接终止进程。

超时时限

场景	超时时间
启动（`application:didFinishLaunchingWithOptions:`）	约 20 秒
前台无响应	约 10 秒（可能因系统版本和设备而异）
进入后台（`applicationDidEnterBackground:`）	约 5-10 秒
挂起到前台恢复	约 10 秒

终止码

Crash 日志中的 Exception Code: 0x8badf00d（读作 "ate bad food"）。

排查方法

查看 Crash 日志中主线程堆栈：卡在哪一步
常见原因：
- 启动阶段同步读取大文件
- 主线程发起同步网络请求
- 主线程等待锁（被子线程持有且长时间未释放）
- 主线程执行大量计算（如 JSON 解析超大文件）
- 数据库操作在主线程同步执行

防治方案

// 错误：主线程同步网络请求
NSData *data = [NSData dataWithContentsOfURL:url];

// 正确：异步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSData *data = [NSData dataWithContentsOfURL:url];
    dispatch_async(dispatch_get_main_queue(), ^{
        [self updateUI:data];
    });
});

启动阶段精简同步操作，能延迟的延迟，能异步的异步
主线程只做 UI 操作
大量 I/O、计算放到子线程
监控主线程卡顿（见第 19 题）

10. 后台任务被系统杀死

Q: App 进入后台后可能被系统杀死的原因有哪些？如何申请额外的后台执行时间？

被杀原因

内存压力：后台 App 优先被 Jetsam 终止
后台任务超时：beginBackgroundTaskWithExpirationHandler: 的任务未在限定时间内调用 endBackgroundTask:
CPU 使用过高：后台持续占用大量 CPU 资源
违规后台行为：未声明后台模式却尝试执行后台操作

后台任务正确用法

- (void)applicationDidEnterBackground:(UIApplication *)application {
    __block UIBackgroundTaskIdentifier taskID = UIBackgroundTaskInvalid;
    taskID = [application beginBackgroundTaskWithName:@"SaveData"
                                   expirationHandler:^{
        // 必须在 handler 中结束任务，否则系统直接杀进程
        [application endBackgroundTask:taskID];
        taskID = UIBackgroundTaskInvalid;
    }];
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self saveDataToDisk];
        // 任务完成后立即结束
        [application endBackgroundTask:taskID];
        taskID = UIBackgroundTaskInvalid;
    });
}

常见错误

忘记调用 endBackgroundTask: → 超时后系统杀进程并标记为 Watchdog 异常
expirationHandler 中没有结束任务
申请了后台任务但实际已经完成了操作，未及时结束

11. Method Swizzling 在稳定性防护中的应用

Q: Method Swizzling 的原理是什么？在稳定性防护中使用有哪些坑和最佳实践？

原理

OC 方法调用通过 objc_msgSend 查找 IMP（方法实现），Swizzling 就是交换两个方法的 IMP 指针。

交换前：
SEL_A → IMP_A
SEL_B → IMP_B

交换后：
SEL_A → IMP_B
SEL_B → IMP_A

标准实现

void swizzle(Class class, SEL originalSEL, SEL swizzledSEL) {
    Method originalMethod = class_getInstanceMethod(class, originalSEL);
    Method swizzledMethod = class_getInstanceMethod(class, swizzledSEL);
    
    // 先尝试添加（处理原方法来自父类的情况）
    BOOL didAdd = class_addMethod(class,
                                   originalSEL,
                                   method_getImplementation(swizzledMethod),
                                   method_getTypeEncoding(swizzledMethod));
    if (didAdd) {
        class_replaceMethod(class,
                           swizzledSEL,
                           method_getImplementation(originalMethod),
                           method_getTypeEncoding(originalMethod));
    } else {
        method_exchangeImplementations(originalMethod, swizzledMethod);
    }
}

为什么要先 `class_addMethod`？

如果子类没有 override 父类方法，直接 method_exchangeImplementations 会修改父类的方法列表，影响所有子类。先 class_addMethod 确保只在当前类上操作。

最佳实践

在 +load 中执行，配合 dispatch_once：+load 在类加载时调用，时机最早最安全；dispatch_once 确保只执行一次。
Swizzled 方法中调用"自己"：看起来像递归但实际是调用原始实现（因为 IMP 已交换）。
不要在 +initialize 中 Swizzle：+initialize 可能被子类继承调用多次。
注意 Swizzle 顺序：多个 Category 都 Swizzle 同一个方法时，+load 调用顺序取决于编译顺序。
线上慎用：提供开关机制，可以通过配置中心远程关闭防护。

12. 符号化与 Crash 日志分析

Q: 拿到一份 Crash 日志后，如何分析和符号化？

Crash 日志结构

Incident Identifier: xxxxxx
Hardware Model:      iPhone12,1
Process:             MyApp [1234]
Exception Type:      EXC_BAD_ACCESS (SIGSEGV)
Exception Subtype:   KERN_INVALID_ADDRESS at 0x0000000000000010

Thread 0 Crashed:
0   libobjc.A.dylib    0x1a2b3c4d5  objc_msgSend + 32
1   MyApp              0x1000abcde  0x100000000 + 703710
2   UIKitCore          0x1b2c3d4e5  -[UIViewController viewDidLoad] + 100

符号化步骤

获取 dSYM 文件：Xcode Archive 时自动生成，UUID 必须和二进制匹配。
验证 UUID 匹配：

# 查看 dSYM UUID
dwarfdump --uuid MyApp.app.dSYM
# 查看二进制 UUID
dwarfdump --uuid MyApp.app/MyApp

使用 atos 符号化：

atos -arch arm64 -o MyApp.app.dSYM/Contents/Resources/DWARF/MyApp -l 0x100000000 0x1000abcde
# 输出: -[MyViewController handleTap:] (MyViewController.m:42)

使用 symbolicatecrash：

export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
symbolicatecrash MyApp.crash MyApp.app.dSYM > symbolicated.crash

关键信息分析

Exception Type：确定 Crash 类型
Exception Code：0x8badf00d = Watchdog，0xd00d2bad = OOM
Crashed Thread 的堆栈：定位 Crash 发生的代码位置
Last Exception Backtrace：OC 异常的堆栈（NSException）
Binary Images：用于计算符号偏移

13. APM 与 Crash 监控体系搭建

Q: 如何设计一个完整的 Crash 监控体系？

三层捕获架构

┌──────────────────────────────────────┐
│  Layer 1: OC 异常捕获                │
│  NSSetUncaughtExceptionHandler       │
├──────────────────────────────────────┤
│  Layer 2: Mach 异常捕获              │
│  task_set_exception_ports            │
├──────────────────────────────────────┤
│  Layer 3: Unix Signal 捕获           │
│  sigaction(SIGSEGV/SIGABRT/...)     │
└──────────────────────────────────────┘

捕获后的处理流程

Crash 发生
    ↓
1. 收集上下文信息（线程堆栈、寄存器、设备信息）
    ↓
2. 持久化到沙盒（写磁盘，不能用 OC/高级 API，用 C 的 write()）
    ↓
3. 下次启动读取并上报到服务端
    ↓
4. 服务端符号化 + 聚合 + 报警

Crash 回调中的安全限制

Crash handler 运行在**异步信号不安全（Async-Signal-Unsafe）**环境中：

不能使用 malloc（可能死锁，因为 malloc 内部有锁）
不能使用 Objective-C 消息发送（objc_msgSend 可能死锁）
不能使用 NSLog、NSString 等高级 API
应使用 write() 直接写文件
预分配好写入 buffer

开源框架对比

框架	Mach 异常	Signal	OC 异常	C++ 异常	符号化
PLCrashReporter	✅	✅	✅	❌	本地
KSCrash	✅	✅	✅	✅	本地+服务端
Bugly	✅	✅	✅	✅	服务端
Firebase Crashlytics	✅	✅	✅	✅	服务端

14. 多线程 Crash

Q: 多线程场景下有哪些常见 Crash？如何防护？

常见场景

1. 容器的非线程安全读写

// 线程 A：写
[self.mutableArray addObject:obj];

// 线程 B：读（或同时写）
NSLog(@"%@", self.mutableArray[0]);

// 可能触发 EXC_BAD_ACCESS

2. 属性的非原子访问

nonatomic 属性在多线程读写时可能读到"半成品"指针（写入时只完成了部分字节的赋值），导致野指针。

3. CoreData 多线程访问

NSManagedObjectContext 不是线程安全的，跨线程访问会导致不可预期的行为。

防护方案

方案 1：加锁

// 读写锁 pthread_rwlock（读多写少场景最优）
pthread_rwlock_t lock;
pthread_rwlock_init(&lock, NULL);

// 读
pthread_rwlock_rdlock(&lock);
id obj = self.array[index];
pthread_rwlock_unlock(&lock);

// 写
pthread_rwlock_wrlock(&lock);
[self.mutableArray addObject:obj];
pthread_rwlock_unlock(&lock);

方案 2：GCD 并发队列 + barrier

dispatch_queue_t queue = dispatch_queue_create("com.app.safe",
                                                DISPATCH_QUEUE_CONCURRENT);

// 读
dispatch_sync(queue, ^{
    id obj = self.array[index];
});

// 写（barrier 确保写操作独占）
dispatch_barrier_async(queue, ^{
    [self.mutableArray addObject:obj];
});

方案 3：使用线程安全容器

@synchronized（简单但性能差）
使用 NSCache（线程安全）替代 NSMutableDictionary 做缓存
CoreData 使用 performBlock: 确保在正确线程操作

Thread Sanitizer (TSan)

Xcode 内置的多线程问题检测工具，编译时插桩，可以检测：

数据竞争（Data Race）
线程间通过非同步方式共享数据

开启方式：Edit Scheme → Run → Diagnostics → Thread Sanitizer

15. Fishhook 与系统函数 Hook

Q: fishhook 的原理是什么？与 Method Swizzling 有何区别？在稳定性领域有什么应用？

Method Swizzling vs fishhook

特性	Method Swizzling	fishhook
目标	OC 方法（SEL → IMP）	C 函数（系统库）
原理	交换方法列表中的 IMP	修改 `__DATA` 段中的符号指针
范围	OC 对象方法/类方法	动态链接的 C 函数（如 malloc、objc_msgSend）
限制	只能 Hook OC 方法	只能 Hook 通过 dyld 动态绑定的函数

fishhook 原理

Mach-O 二进制使用 PIC（位置无关代码）调用外部函数：

代码段（__TEXT，只读）
    call → 桩函数（stub）
              ↓
间接符号指针表（__DATA.__la_symbol_ptr，可写）
    存储实际函数地址
              ↓
dyld 在运行时绑定真实地址

fishhook 的做法：遍历间接符号表，找到目标符号，将其指针替换为自定义函数。

稳定性应用

1. Hook objc_msgSend 做方法耗时监控

// 记录每个 OC 方法的调用耗时，发现卡顿方法
rebind_symbols((struct rebinding[1]){
    {"objc_msgSend", my_objc_msgSend, (void *)&orig_objc_msgSend}
}, 1);

2. Hook malloc/free 做内存分配监控

追踪大内存分配，帮助定位 OOM 问题。

3. Hook NSLog 减少线上日志开销

static void (*orig_NSLog)(NSString *format, ...);
void my_NSLog(NSString *format, ...) {
    // 线上环境直接跳过 NSLog，减少性能开销
    #ifdef DEBUG
    va_list args;
    va_start(args, format);
    orig_NSLog(format, args);
    va_end(args);
    #endif
}

16. 线上 Crash 率治理实践

Q: 如何系统性地降低线上 Crash 率？

Crash 率指标

Crash Rate = Crash UV / DAU × 100%

行业参考：
- 优秀：< 0.1%（千分之一）
- 合格：< 0.3%
- 需治理：> 0.5%

治理策略分层

第一层：防护兜底（短期见效）

防护类型	手段
Unrecognized Selector	Hook `forwardingTargetForSelector:`
容器越界/nil	Hook 容器类方法
KVO	KVO 代理层
NSTimer	弱引用 target 防循环引用
NSNotification	dealloc 自动 removeObserver

第二层：根因修复（中期）

Top Crash 排序：按影响用户数排序，优先修复 Top 10
分版本分析：某版本新增的 Crash 优先处理
分设备/系统版本：特定设备或系统的 Crash 单独适配
堆栈聚合：相同 Crash 合并，避免重复分析

第三层：预防机制（长期）

CI/CD 集成静态分析（Clang Static Analyzer / Infer）
Code Review 重点关注多线程、内存管理
灰度发布 + Crash 率实时监控
A/B 实验关联 Crash 率指标
单元测试覆盖边界条件

17. 启动阶段 Crash 的特殊处理

Q: 如果 App 在启动阶段反复 Crash，如何处理？

难点

启动阶段的 Crash 用户无法操作，导致 App 完全不可用
Crash 日志可能来不及上报
如果是配置/数据导致的 Crash，每次启动都会重复

连续启动 Crash 保护方案

// 启动时记录
NSInteger crashCount = [[NSUserDefaults standardUserDefaults] 
                         integerForKey:@"launch_crash_count"];

// 标记启动中
[[NSUserDefaults standardUserDefaults] setInteger:crashCount + 1
                                           forKey:@"launch_crash_count"];
[[NSUserDefaults standardUserDefaults] synchronize];

if (crashCount >= 3) {
    // 连续 3 次启动 crash，执行修复策略
    [self performRecovery];
}

// 启动成功后（如 didBecomeActive 或首页展示后）重置计数
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC),
               dispatch_get_main_queue(), ^{
    [[NSUserDefaults standardUserDefaults] setInteger:0
                                               forKey:@"launch_crash_count"];
});

修复策略

清除缓存数据：可能是脏数据导致
清除 UserDefaults：可能是错误配置导致
重置数据库：可能是数据库损坏
回退到安全模式：使用最小化功能启动
关闭防护框架：防护框架本身可能导致启动 Crash，因此防护框架应设计远程开关以便紧急关闭

18. 堆栈回溯原理

Q: iOS Crash 时如何获取线程堆栈？有哪些回溯方式？

三种堆栈回溯方式

1. Frame Pointer 回溯（FP-Based）

ARM64 架构下，x29（FP）指向当前栈帧，栈帧中保存了上一帧的 FP 和返回地址（LR）：

┌─────────────────┐  高地址
│  上层 FP（x29）  │ ← 当前 FP 指向这里
├─────────────────┤
│  返回地址 (LR)   │
├─────────────────┤
│  局部变量        │
└─────────────────┘  低地址

遍历链表即可回溯整个调用栈。性能高，但需要编译时不优化掉 Frame Pointer（-fno-omit-frame-pointer）。

2. DWARF Unwind

使用 DWARF 调试信息中的 .eh_frame / .debug_frame 段进行回溯。信息更准确，但性能开销大。

3. Compact Unwind

Apple 平台特有的压缩格式，__TEXT.__unwind_info 段存储，比 DWARF 更紧凑高效。

实际获取堆栈

// OC 层（简单但信息有限）
NSArray *symbols = [NSThread callStackSymbols];
NSArray *addresses = [NSThread callStackReturnAddresses];

// C 层（更底层）
#include <execinfo.h>
void *callstack[128];
int frames = backtrace(callstack, 128);
char **symbols = backtrace_symbols(callstack, frames);

// 获取所有线程堆栈（Mach API）
thread_act_array_t threads;
mach_msg_type_number_t threadCount;
task_threads(mach_task_self(), &threads, &threadCount);

for (int i = 0; i < threadCount; i++) {
    _STRUCT_MCONTEXT machineContext;
    mach_msg_type_number_t stateCount = ARM_THREAD_STATE64_COUNT;
    thread_get_state(threads[i], ARM_THREAD_STATE64,
                     (thread_state_t)&machineContext.__ss, &stateCount);
    // 从 machineContext 中获取 PC、LR、FP 进行回溯
}

19. 卡顿监控与治理

Q: 如何监控主线程卡顿？常用方案有哪些？

方案 1：RunLoop Observer 监控

原理：监听 RunLoop 的状态切换，如果长时间停留在某个状态（如 kCFRunLoopBeforeSources 到 kCFRunLoopAfterWaiting），说明主线程被阻塞。

static void runLoopObserverCallback(CFRunLoopObserverRef observer,
                                     CFRunLoopActivity activity,
                                     void *info) {
    // 记录 RunLoop 状态变化时间
    switch (activity) {
        case kCFRunLoopBeforeSources:
            // 开始处理事件
            break;
        case kCFRunLoopAfterWaiting:
            // 唤醒后开始执行
            break;
    }
}

// 子线程定时检查状态是否长时间未变化
// 超过阈值（如 200ms）则记录堆栈

方案 2：子线程 Ping 主线程

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    while (YES) {
        __block BOOL responded = NO;
        dispatch_async(dispatch_get_main_queue(), ^{
            responded = YES;
        });
        
        [NSThread sleepForTimeInterval:0.2]; // 等待 200ms
        
        if (!responded) {
            // 主线程卡顿，抓取主线程堆栈
            [self captureMainThreadStack];
        }
    }
});

方案 3：Hook `objc_msgSend`（方法级耗时统计）

通过 fishhook 替换 objc_msgSend，在前后记录时间戳，精确到每个方法的耗时。适合线下 profiling，线上开销过大。

卡顿治理方向

问题	优化方案
主线程 I/O	移到子线程（网络、文件读写、数据库）
主线程大量计算	拆分任务或移到子线程
过度布局计算	缓存 cell 高度，使用 `estimatedRowHeight`
离屏渲染	减少 `cornerRadius + masksToBounds`，使用预渲染
图片解码	子线程预解码（SDWebImage 默认处理）
锁竞争	减小锁粒度，避免主线程等待子线程锁

20. 磁盘与数据库稳定性

Q: 磁盘写入和数据库操作在稳定性方面需要注意什么？

磁盘写入

1. 沙盒空间不足

iOS 设备存储满时写入失败，需要：

写入前检查可用空间
捕获写入错误并上报
清理过期缓存释放空间

NSError *error;
NSDictionary *attrs = [[NSFileManager defaultManager]
                        attributesOfFileSystemForPath:NSHomeDirectory()
                        error:&error];
uint64_t freeSpace = [attrs[NSFileSystemFreeSize] unsignedLongLongValue];

2. 原子写入

NSData writeToFile:atomically:YES 先写临时文件再 rename，确保写入的原子性。如果写入过程中 Crash，原文件不会损坏。

SQLite / CoreData 稳定性

1. 数据库损坏

原因：

写入过程中异常中断（crash / 断电）
多进程/多线程并发写入冲突
磁盘空间不足

防护：

-- 开启 WAL 模式，提高并发性能和安全性
PRAGMA journal_mode=WAL;

-- 定期完整性检查
PRAGMA integrity_check;

2. 损坏后恢复策略

if (![self openDatabase]) {
    // 数据库损坏
    // 方案 1：删除重建
    [[NSFileManager defaultManager] removeItemAtPath:dbPath error:nil];
    [self openDatabase];
    
    // 方案 2：从备份恢复
    [self restoreFromBackup];
    
    // 方案 3：尝试 dump 并重建
    // 使用 ".dump" 命令导出可恢复数据
}

3. CoreData 的轻量级迁移

模型升级时使用轻量级迁移，失败时降级处理：

NSDictionary *options = @{
    NSMigratePersistentStoresAutomaticallyOption: @YES,
    NSInferMappingModelAutomaticallyOption: @YES
};

NSError *error;
if (![coordinator addPersistentStoreWithType:NSSQLiteStoreType
                               configuration:nil
                                         URL:storeURL
                                     options:options
                                       error:&error]) {
    // 迁移失败，删除旧数据库重建
    [[NSFileManager defaultManager] removeItemAtURL:storeURL error:nil];
    [coordinator addPersistentStoreWithType:NSSQLiteStoreType
                             configuration:nil
                                       URL:storeURL
                                   options:options
                                     error:nil];
}

附录：高频追问

Q: `@try-@catch` 能捕获所有 Crash 吗？

不能。@try-@catch 只能捕获 OC 异常（NSException），无法捕获：

EXC_BAD_ACCESS（野指针、内存越界）
SIGABRT（非 NSException 触发的）
SIGSEGV
其他系统级异常

而且 @try-@catch 在 ARC 下有额外开销（需要维护异常处理的 cleanup 表）。

Q: App 的 Crash 日志存储在哪里？

设备上：设置 → 隐私 → 分析与改进 → 分析数据
Xcode：Window → Devices and Simulators → View Device Logs
通过 MetricKit 框架：iOS 13+ 可以在 App 内接收系统级 Crash 和性能数据

Q: `+load` 和 `+initialize` 的区别是什么？为什么 Swizzle 要放在 `+load`？

特性	+load	+initialize
调用时机	dyld 加载类时（main 之前）	类第一次收到消息时
调用次数	每个类/分类各调用一次	可能多次（子类未实现会调用父类的）
线程安全	系统加锁保证线程安全	系统加锁保证线程安全
是否继承	不继承	继承
影响启动	过多 +load 会拖慢启动	惰性调用不影响启动

Swizzle 放在 +load 的原因：

时机最早，确保方法被调用前已经完成交换
不会被子类继承导致多次调用
+initialize 有被多次调用的风险，可能导致重复 Swizzle（偶数次交换等于没交换）

Q: Swift 中的 Crash 有什么不同？

强制解包 nil：let value: String = optional!，Optional 为 nil 时触发 SIGTRAP
数组越界：Swift 数组越界直接触发 SIGTRAP（不像 OC 可以 Hook）
fatalError / preconditionFailure：直接 SIGTRAP
as! 类型转换失败
Swift Crash 更难做运行时防护（缺少 OC 的消息转发机制），更依赖编译期检查和代码质量

最后更新: 2026-04-16

昨天以前掘金 iOS

第2章：声明式 UI 基础

掘金 iOS

作者 90后晨仔

2026年4月15日 22:22

2.1 声明式 vs 命令式 UI 对比

命令式 UI（UIKit）

命令式编程是一种传统的编程范式，开发者需要明确告诉计算机“如何”完成任务。在 UIKit 中，你需要：

创建视图对象
配置视图属性
添加视图到视图层级
设置布局约束
手动更新视图状态

示例代码（UIKit）：

import UIKit

class ProfileViewController: UIViewController {
    private let nameLabel = UILabel()
    private let avatarImageView = UIImageView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 1. 创建视图
        view.backgroundColor = .white
        
        // 2. 配置 nameLabel
        nameLabel.text = "张三"
        nameLabel.font = UIFont.systemFont(ofSize: 18, weight: .medium)
        nameLabel.textColor = .black
        nameLabel.textAlignment = .center
        
        // 3. 配置 avatarImageView
        avatarImageView.image = UIImage(named: "avatar")
        avatarImageView.contentMode = .scaleAspectFill
        avatarImageView.layer.cornerRadius = 40
        avatarImageView.clipsToBounds = true
        
        // 4. 添加到视图层级
        view.addSubview(avatarImageView)
        view.addSubview(nameLabel)
        
        // 5. 设置约束
        avatarImageView.translatesAutoresizingMaskIntoConstraints = false
        nameLabel.translatesAutoresizingMaskIntoConstraints = false
        
        NSLayoutConstraint.activate([
            avatarImageView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            avatarImageView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 100),
            avatarImageView.widthAnchor.constraint(equalToConstant: 80),
            avatarImageView.heightAnchor.constraint(equalToConstant: 80),
            
            nameLabel.topAnchor.constraint(equalTo: avatarImageView.bottomAnchor, constant: 20),
            nameLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor)
        ])
    }
    
    // 6. 更新数据时需要手动刷新 UI
    func updateProfile(name: String, avatar: String) {
        nameLabel.text = name
        avatarImageView.image = UIImage(named: avatar)
    }
}

声明式 UI（SwiftUI）

声明式编程是一种现代的编程范式，开发者只需要描述“是什么”，而不需要关心“如何”实现。在 SwiftUI 中，你只需要：

描述界面的结构
绑定状态
系统自动处理更新

示例代码（SwiftUI）：

import SwiftUI

struct ProfileView: View {
    let name: String
    let avatar: String
    
    var body: some View {
        VStack(spacing: 20) {
            // 1. 头像
            Image(avatar)
                .resizable()
                .aspectRatio(contentMode: .fill)
                .frame(width: 80, height: 80)
                .clipShape(Circle())
            
            // 2. 姓名
            Text(name)
                .font(.system(size: 18, weight: .medium))
                .foregroundStyle(.primary)
        }
        .padding()
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(Color(.systemBackground))
    }
}

// 使用示例
ProfileView(name: "张三", avatar: "avatar")

核心差异

维度	命令式 UI（UIKit）	声明式 UI（SwiftUI）
代码量	多（需要手动管理所有细节）	少（只描述结果）
状态同步	手动更新 UI	自动同步状态
可读性	较低（逻辑分散）	高（逻辑集中）
维护性	较低（容易遗漏更新）	高（状态驱动自动更新）
错误率	较高（手动操作容易出错）	较低（框架保证一致性）
开发效率	低（重复代码多）	高（简洁明了）

2.2 View 协议与 body 计算属性

View 协议

在 SwiftUI 中，所有的视图都必须遵循 View 协议：

public protocol View {
    associatedtype Body : View
    @ViewBuilder var body: Self.Body { get }
}

核心概念：

associatedtype Body：关联类型，表示视图的内容类型
body：计算属性，返回视图的内容
@ViewBuilder：属性包装器，允许使用声明式语法组合多个视图

body 计算属性

body 是 SwiftUI 视图的核心，它是一个计算属性，每次状态变化时都会重新计算。

重要特性：

计算属性：不是存储属性，每次访问都会重新计算
轻量级：应该保持简洁，避免复杂计算
返回类型：必须返回一个遵循 View 协议的类型
自动合成：@ViewBuilder 允许使用简洁的语法组合多个视图

示例：

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, SwiftUI!")
            Button("Tap Me") {}
        }
    }
}

理解 some View

some View 是一个不透明类型（Opaque Type），它表示：

这个函数返回一个遵循 View 协议的类型
但具体是什么类型，不需要暴露给调用者
编译器可以进行更多的优化

2.3 结构体视图与值类型

视图是结构体

在 SwiftUI 中，视图是使用结构体（struct）实现的，这与 UIKit 中的类（class）不同。

结构体的优势：

值类型：传递时会复制，避免引用计数问题
轻量级：分配在栈内存上，创建和销毁成本低
不可变：默认不可变，状态通过 @State 等包装器管理
线程安全：值类型天生线程安全

结构体的生命周期

SwiftUI 视图的生命周期与结构体的实例化无关：

结构体可能被频繁创建和销毁
但底层的真实视图对象由 SwiftUI 管理
视图的身份（Identity）由其在视图树中的位置决定

示例：

struct CounterView: View {
    @State private var count = 0
    
    var body: some View {
        VStack {
            Text("Count: \(count)")
            Button("Increment") {
                count += 1
            }
        }
    }
}

当 count 改变时：

SwiftUI 检测到状态变化
重新创建 CounterView 结构体实例
调用 body 计算属性生成新的视图树
与旧视图树对比，只更新变化的部分

2.4 修饰符（Modifier）的使用

什么是修饰符？

修饰符是 SwiftUI 中用于修改视图属性和行为的方法。它们通常以点语法链式调用。

修饰符的工作原理

修饰符不是直接修改原视图，而是返回一个新的视图，这个新视图包含了原视图和应用的修改。

示例：

Text("Hello")
    .font(.largeTitle)        // 返回一个新的 Text 视图，字体为 largeTitle
    .foregroundStyle(.blue)    // 返回一个新的视图，文本颜色为蓝色
    .padding()                // 返回一个新的视图，带有内边距

常用修饰符

布局修饰符

padding()：添加内边距
frame()：设置视图大小和对齐方式
background()：设置背景
foregroundStyle()：设置前景样式（颜色、渐变等）
clipShape()：裁剪视图形状
overlay()：在视图上叠加内容

排版修饰符

font()：设置字体
bold()：加粗文本
italic()：斜体文本
multilineTextAlignment()：多行文本对齐
lineLimit()：限制文本行数

交互修饰符

onTapGesture()：添加点击手势
disabled()：禁用视图
accessibility()：添加无障碍支持

动画修饰符

animation()：添加动画
transition()：添加转场动画

修饰符的顺序

修饰符的顺序很重要，因为每个修饰符都会作用于前一个修饰符返回的视图。

示例：

// 先设置背景，再添加内边距
Text("Hello")
    .background(Color.blue)
    .padding()

// 先添加内边距，再设置背景
Text("Hello")
    .padding()
    .background(Color.blue)

这两种写法会产生不同的效果，第一种背景只覆盖文本区域，第二种背景会覆盖整个内边距区域。

实战：创建一个信息卡片

需求分析

创建一个包含以下元素的信息卡片：

标题
副标题
描述文本
图标
卡片样式（圆角、阴影）

代码实现

import SwiftUI

struct InfoCardView: View {
    // 卡片数据
    let title: String
    let subtitle: String
    let description: String
    let iconName: String
    let iconColor: Color
    
    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            // 图标和标题区域
            HStack(alignment: .center, spacing: 12) {
                // 图标
                Circle()
                    .fill(iconColor.opacity(0.1))
                    .frame(width: 48, height: 48)
                    .overlay {
                        Image(systemName: iconName)
                            .resizable()
                            .scaledToFit()
                            .frame(width: 24, height: 24)
                            .foregroundStyle(iconColor)
                    }
                
                // 标题和副标题
                VStack(alignment: .leading, spacing: 4) {
                    Text(title)
                        .font(.headline)
                        .fontWeight(.semibold)
                    Text(subtitle)
                        .font(.subheadline)
                        .foregroundStyle(.secondary)
                }
            }
            
            // 描述文本
            Text(description)
                .font(.body)
                .foregroundStyle(.primary)
                .lineLimit(nil) // 不限制行数
        }
        .padding(16) // 卡片内边距
        .background(
            RoundedRectangle(cornerRadius: 12)
                .fill(Color(.systemBackground))
                .shadow(color: .black.opacity(0.1), radius: 4, x: 0, y: 2)
        )
        .padding(.horizontal, 16) // 卡片外边距
    }
}

// 使用示例
struct ContentView: View {
    var body: some View {
        VStack(spacing: 16) {
            InfoCardView(
                title: "SwiftUI 简介",
                subtitle: "现代 UI 框架",
                description: "SwiftUI 是一个声明式 UI 框架，允许开发者使用 Swift 语言创建跨 Apple 平台的用户界面。它提供了简洁、直观的语法，使 UI 开发变得更加高效。",
                iconName: "star.fill",
                iconColor: .yellow
            )
            
            InfoCardView(
                title: "声明式编程",
                subtitle: "现代编程范式",
                description: "声明式编程让开发者只需要描述界面的样子，而不需要关心如何实现。系统会自动处理视图的创建、更新和销毁。",
                iconName: "code",
                iconColor: .blue
            )
            
            InfoCardView(
                title: "跨平台",
                subtitle: "一次编写，多处运行",
                description: "SwiftUI 支持 iOS、iPadOS、macOS、watchOS 和 tvOS，让你的代码可以在所有 Apple 平台上运行。",
                iconName: "globe",
                iconColor: .green
            )
        }
        .padding(.vertical, 16)
        .background(Color(.systemGroupedBackground))
    }
}

#Preview {
    ContentView()
}

代码解析

结构体参数：通过参数传递卡片数据，使视图可复用
VStack 和 HStack：使用栈布局组织视图
Circle：创建圆形背景
overlay：在圆形上叠加图标
RoundedRectangle：创建圆角矩形背景
shadow：添加阴影效果
spacing：设置栈视图的间距
alignment：设置栈视图的对齐方式

小结

本章介绍了声明式 UI 的基础概念，包括：

声明式 vs 命令式 UI 的对比
View 协议与 body 计算属性
结构体视图与值类型的特性
修饰符的使用方法和顺序
一个信息卡片的实战实现

通过本章的学习，你已经了解了 SwiftUI 的基本工作原理和核心概念，为后续的学习打下了坚实的基础。

参考资料

第1章：SwiftUI 与开发环境简介

掘金 iOS

作者 90后晨仔

2026年4月15日 21:55

距离上一次学习SwiftUI已经过去几年的时间了，好多知识点都些忘记了，最近刚好有有一些时间就好好的在从零回顾一下吧。

1.1 什么是 SwiftUI？

官方定义

根据 Apple 官方文档，SwiftUI 是一个现代的声明式 UI 框架，它允许开发者使用 Swift 语言创建跨 Apple 平台的用户界面。

SwiftUI 的核心优势

声明式语法：描述界面“是什么”而不是“怎么做”
跨平台：一次编写，在 iOS、iPadOS、macOS、watchOS 和 tvOS 上运行
实时预览：在 Xcode 中实时查看界面效果
与 Swift 语言深度集成：充分利用 Swift 的类型安全和现代特性
自动适配：自动处理不同尺寸设备的布局

与 UIKit 的对比

特性	SwiftUI	UIKit
编程范式	声明式	命令式
代码风格	简洁、直观	冗长、命令式
布局系统	自动布局，基于栈	Auto Layout，需要手动设置约束
状态管理	自动状态同步	手动更新 UI
跨平台	支持所有 Apple 平台	主要针对 iOS/tvOS
开发效率	高	相对较低

1.2 Xcode 开发环境配置

系统要求

macOS：最新版本（推荐 macOS Sonoma 或更高）
Xcode：最新版本（推荐 Xcode 15 或更高）
Swift：Swift 5.7 或更高
iOS：iOS 15.0 或更高（如果需要支持旧版本，最低可到 iOS 13.0）

安装 Xcode

打开 App Store
搜索 “Xcode”
点击 “获取” 进行安装
安装完成后，打开 Xcode 并同意许可协议

安装额外组件

首次打开 Xcode 时，会提示安装额外的组件，包括：

命令行工具
模拟器运行时
其他必要的开发工具

1.3 创建你的第一个 SwiftUI 项目

步骤 1：打开 Xcode

步骤 2：创建新项目

点击 “Create a new Xcode project”
选择 “iOS” 标签页
选择 “App” 模板
点击 “Next”

步骤 3：配置项目信息

Product Name：输入项目名称，例如 “SwiftUIHelloWorld”
Team：选择你的开发团队（如果没有，可以选择 “None”）
Organization Identifier：输入你的组织标识符，例如 “com.yourname”
Interface：选择 “SwiftUI”
Language：选择 “Swift”
Life Cycle：选择 “SwiftUI App”
取消勾选 “Use Core Data”（暂时不需要）
点击 “Next”

步骤 4：选择保存位置

选择一个合适的文件夹保存项目，然后点击 “Create”

步骤 5：项目结构介绍

创建完成后，你会看到以下文件结构：

SwiftUIHelloWorldApp.swift：应用程序入口
ContentView.swift：主视图
Assets.xcassets：资源文件
Info.plist：应用配置

1.4 认识 Xcode 预览功能

预览面板

Xcode 右侧的预览面板是 SwiftUI 最强大的特性之一，它允许你实时查看界面效果。

使用预览

打开 ContentView.swift 文件
确保右侧的预览面板可见（如果不可见，点击 Xcode 顶部的 “Editor” → “Canvas”）
你会看到 ContentView 的实时预览
修改代码，预览会自动更新

预览配置

你可以在预览代码中添加多个预览，例如：

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        Group {
            ContentView()
                .previewDisplayName("默认预览")
            
            ContentView()
                .previewDisplayName("暗黑模式")
                .preferredColorScheme(.dark)
            
            ContentView()
                .previewDisplayName("iPhone 15 Pro")
                .previewDevice(PreviewDevice(rawValue: "iPhone 15 Pro"))
        }
    }
}

预览快捷键

Option + Command + P：刷新预览
Command + K：清除构建

1.5 SwiftUI 项目结构解析

应用程序入口

SwiftUIHelloWorldApp.swift 是应用的入口点，它定义了应用的结构：

import SwiftUI

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

主视图

ContentView.swift 是应用的主视图：

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
    }
}

#Preview {
    ContentView()
}

关键概念解析

@main：标记应用程序的入口点
App 协议：定义应用的结构
Scene：表示应用的一个场景
WindowGroup：创建应用的窗口
View 协议：所有 SwiftUI 视图必须遵循的协议
body：计算属性，返回视图的内容
#Preview：Xcode 15+ 的新语法，用于创建预览

资源管理

Assets.xcassets：管理应用的图片、颜色等资源
Info.plist：应用的配置信息，如应用名称、版本号等

实战：创建一个简单的欢迎页面

需求分析

创建一个包含以下元素的欢迎页面：

应用图标
应用名称
欢迎标语
开始按钮

代码实现

import SwiftUI

struct WelcomeView: View {
    // 状态变量，用于控制是否显示欢迎页面
    @State private var isWelcomeShown = true
    
    var body: some View {
        if isWelcomeShown {
            VStack(spacing: 20) {
                // 应用图标
                Image(systemName: "star.fill")
                    .resizable()
                    .aspectRatio(contentMode: .fit)
                    .frame(width: 100, height: 100)
                    .foregroundStyle(.yellow)
                
                // 应用名称
                Text("欢迎使用 SwiftUI")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                
                // 欢迎标语
                Text("一个现代、简洁的 UI 框架")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)
                
                // 开始按钮
                Button("开始探索") {
                    // 点击按钮后隐藏欢迎页面
                    isWelcomeShown = false
                }
                .buttonStyle(.borderedProminent)
                .tint(.blue)
            }
            .padding()
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .background(
                LinearGradient(
                    colors: [.blue.opacity(0.1), .purple.opacity(0.1)],
                    startPoint: .top,
                    endPoint: .bottom
                )
            )
        } else {
            // 主内容页面
            VStack {
                Text("探索 SwiftUI 的世界！")
                    .font(.title)
                Text("这里是你的应用主界面")
                    .foregroundStyle(.secondary)
            }
            .padding()
        }
    }
}

#Preview {
    WelcomeView()
}

代码解析

@State：用于创建视图的本地状态
VStack：垂直堆叠视图
Image：显示图片，使用系统图标
Text：显示文本
Button：创建按钮，带有点击动作
LinearGradient：创建线性渐变背景
条件渲染：使用 if-else 控制显示不同的内容

小结

本章介绍了 SwiftUI 的基本概念和开发环境搭建，包括：

SwiftUI 的核心优势和与 UIKit 的对比
Xcode 的安装和配置
创建第一个 SwiftUI 项目的步骤
Xcode 预览功能的使用
SwiftUI 项目的基本结构
一个简单欢迎页面的实现

通过本章的学习，你已经了解了 SwiftUI 的基本概念和开发环境，为后续的学习打下了基础。

参考资料

Xcode 26.4 下老项目与 Pod 兼容性修复指南

掘金 iOS

作者 Ox8BADFOOD

2026年4月14日 10:20

Xcode 26.4 下老项目与 Pod 兼容性修复指南

救命！Xcode 26.4 把我的老项目按在地上摩擦😭

谁懂啊家人们！更新完 Xcode 26.4 本想体验新功能，结果一编译直接红一片，全是老旧 Pod 库搞的鬼！AFNetworking、ZFPlayer、YYText 这些曾经的 iOS 开发神器，如今没人维护，遇上新版 Xcode 直接摆烂，留我们打工人疯狂擦屁股！

第一波暴击：私有头文件硬闯，直接被锁死

老旧 Pod 里还在无脑引用 <netinet6/in6.h> 这个 Darwin 私有头，Xcode 26.4 直接重拳出击，毫不留情甩报错：

Use of private header from outside its module: 'netinet6/in6.h'

说白了就是苹果把私有头锁门了，老库还硬要闯，纯纯作死！关键这头文件完全多余，<netinet6/in6.h> 早就把所有需要的内容都包含了，纯纯无用代码坑后人！

第二波暴击：YYText 逆天语法，数学式比较被制裁

YYText 里的链式比较 X < Y < Z 真的离大谱！照着数学公式写代码，以前 Xcode 睁一只眼闭一只眼，现在 26.4 直接较真报错：

Chained comparison 'X < Y < Z' does not behave the same as a mathematical expression

OC 根本不支持这种写法，老库不维护，bug 全留给我们，新版 Xcode 一严格，直接编译失败，血压瞬间拉满！

终极救星！一键脚本全自动修复

别手动改 Pod 源码了！直接把这段脚本塞进 Podfile，pod install 一键搞定所有报错，懒人狂喜，专治各种老库适配不服！

post_install do |installer|
 # Xcode 26 Explicit Modules：不允许直接 #import Darwin 私有头 <netinet6/in6.h>，
  # 相关类型已由 <netinet/in.h> 间接提供，移除即可（AFNetworking、ZFPlayer 等旧版 Pod 常见）。
  pods_dir = File.join(installer.sandbox.root, 'Pods')
  Dir.glob(File.join(pods_dir, '**', '*.{h,m,mm,c}')).each do |file|
    begin
      content = File.read(file)
      next unless content.include?('#import <netinet6/in6.h>')

      File.chmod(0644, file)
      new_content = content.gsub(/^\s*#import\s+<netinet6\/in6\.h>\s*\n/, '')
      File.write(file, new_content)
      puts "[Podfile] Removed #import <netinet6/in6.h> from #{file}"
    rescue => e
      puts "[Podfile] Warning: failed to patch #{file}: #{e.message}"
    end
  end

# Xcode 26：修复 YYText 中 YYTextLayout.m 文件的非法链式比较问题
  # 问题：Objective-C 中的链式比较语法 `a < b < c` 在 Xcode 较新版本中会产生编译错误
  # 修复方法：将链式比较转换为使用三元运算符的明确比较 `(a < b) ? x : y`
  yytext_layout_file = File.join(pods_dir, 'YYText', 'YYText', 'Component', 'YYTextLayout.m')
  if File.exist?(yytext_layout_file)
    begin
      content = File.read(yytext_layout_file)
      new_content = content
        # 修复垂直方向的链式比较
        .gsub(
          # gsub："global substitute"（全局替换）
          # 基本语法 string.gsub(pattern, replacement)
          'position = fabs(left - point.y) < fabs(right - point.y) < (right ? prev : next);',
          'position = (fabs(left - point.y) < fabs(right - point.y)) ? prev : next;'
        )
        # 修复水平方向的链式比较
        .gsub(
          'position = fabs(left - point.x) < fabs(right - point.x) < (right ? prev : next);',
          'position = (fabs(left - point.x) < fabs(right - point.x)) ? prev : next;'
        )

      if new_content != content
        File.chmod(0644, yytext_layout_file)  # 添加写权限
        File.write(yytext_layout_file, new_content)  # 写入修复后的内容
        puts "[Podfile] Fixed chained comparison in #{yytext_layout_file}"
      end
    rescue => e
      puts "[Podfile] Warning: failed to patch #{yytext_layout_file}: #{e.message}"
    end
  end
end

最后疯狂吐槽

苹果更新 Xcode 爽歪歪，我们适配老项目苦哈哈！经典三方库集体停更，技术栈无人维护，Xcode 规则一收紧，全是编译坑。打工人的命也是命啊！

还好有这个一键脚本，复制粘贴就能解决所有报错，赶紧给你的老项目续命吧！

总结

Xcode 26.4 严格校验私有头和语法，老旧未维护 Pod 库必报错
核心问题：netinet6/in6\.h 私有头引用、YYText 链式比较语法错误
粘贴脚本 → pod install → 编译成功，三步搞定，无需手动修改库源码

掘金 iOS
iOS逆向工程：详细解析ptrace反调试机制的破解方法与实战步骤iOS开发上架哦
2026年4月15日 11:44

iOS逆向工程：详细解析ptrace反调试机制的破解方法与实战步骤

掘金 iOS

作者 iOS开发上架哦

2026年4月15日 11:44

Ptrace 提供了一种父进程可以控制子进程运行的机制，并可以检查和改变它的核心image。

它主要用于实现断点调试。

1、一个被跟踪的进程运行中，直到发生一个信号，则进程被中止，并且通知其父进程。 2、在进程中止的状态下，进程的内存空间可以被读写。父进程还可以使子进程继续执行，并选择是否是否忽略引起中止的信号。

本文采用tweak 的方式进行MSHookFunction

在iOS应用安全中，除了反调试机制，代码混淆也是一种重要的保护手段。IpaGuard是一款强大的iOS IPA文件混淆工具，无需源码即可对代码和资源进行混淆加密，支持多种开发平台，有效增加反编译难度。它提供代码混淆、资源文件混淆、调试信息清理等功能，可以帮助开发者保护应用免受逆向工程攻击。

软件环境：Xcode 硬件环境：iPhone5越狱手机、Mac 开发工具：Cycript、LLDB、logos Tweak、hopper、MonkeyDev、AFLEXLoader、dumpdecrypted、debugserver、ssh、class_dump、hook

破解方案

1、运行时期，断点ptrace，直接返回 2、分析如何调用的ptrace，hook ptrace 3、通过tweak，替换disable_gdb函数 4、修改 PT_DENY_ATTACH

I、运行时期，断点ptrace，直接返回

初始化应用程序，而不是运行中附着

iPhone:~ root#  debugserver -x posix *:12345  /var/mobile/Containers/Bundle/Application/A612F542-81EF-456A-A6A0-B23046EF57BA/AlipayWallet.app/AlipayWallet

初始化程序，目的是从程序入口就开始进行附着，这样我们就可以在一些安全防护代码执行之前，进行破解。

跳过ptrace：过命令thread return直接返回，以跳过函数的逻辑。

 (lldb) br set -n ptrace
 Breakpoint 2: where = libsystem_kernel.dylib`__ptrace, address = 0x00000001966af2d4
 (lldb) br command add 2
 Enter your debugger command(s).  Type 'DONE' to end.
 > thread return
 > c
 > DONE

II、分析如何调用的ptrace，hook ptrace

去掉ptrace的思路

当程序运行后，使用 debugserver *:1234 -a BinaryName 附加进程出现 segmentfault 11 时，一般说明程序内部调用了ptrace 。
为验证是否调用了ptrace 可以 debugserver -x backboard *:1234 /BinaryPath（这里是完整路径），然后下符号断点 b ptrace，c 之后看ptrace第一行代码的位置，然后 p $lr 找到函数返回地址，再根据 image list -o -f 的ASLR偏移，计算出原始地址。最后在 IDA 中找到调用ptrace的代码，分析如何调用的ptrace。
开始hook ptrace。

2.0 准备工作：砸壳

砸壳

blog.csdn.net/z929118967/…

查找app路径

iPhone:~ root# ps -e |grep AlipayWallet
  714 ??         0:26.44 /var/mobile/Containers/Bundle/Application/A612F542-81EF-456A-A6A0-B23046EF57BA/AlipayWallet.app/AlipayWallet
  736 ttys000    0:00.01 grep AlipayWallet

获取NSDocumentDirectory

iPhone:~ root# cycript -p AlipayWallet
cy# [[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask][0]
#"file:///var/mobile/Containers/Data/Application/89313E1C-76C2-41E3-8ECD-F4BDC1A78524/Documents/"

scp 拷贝文件

devzkndeMacBook-Pro:decrypted devzkn$ scp /Users/devzkn/Downloads/kevin－software/ios-Reverse_Engineering/dumpdecrypted-master/dumpdecrypted.dylib iphone150:/var/mobile/Containers/Data/Application/89313E1C-76C2-41E3-8ECD-F4BDC1A78524/Documents/

devzkndeMacBook-Pro:decrypted devzkn$ scp iphone150:/var/mobile/Containers/Data/Application/89313E1C-76C2-41E3-8ECD-F4BDC1A78524/Documents/AlipayWallet.decrypted /Users/devzkn/decrypted/AlipayWallet

class-dump

devzkndeMacBook-Pro:bin devzkn$ class-dump --arch armv7 /Users/devzkn/decrypted/AlipayWallet10.1.8/AlipayWallet.decrypted -H -o /Users/devzkn/decrypted/AlipayWallet10.1.8/head

-查看 bundleIdentifier

iPhone:~ root# cycript -p AlipayWallet
cy# [[NSBundle mainBundle] bundleIdentifier]
@"com.alipay.iphoneclient"

2.1 编写 tweak 分析

%hook DFClientDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    %log();

    // 打印某个类的所有方法的，查看所有方法的执行顺序

     [KNHook hookClass:@"H5WebViewController"];//aluLoginViewController
     [KNHook hookClass:@"TBSDKServer"];//getUaPageName    aluMTopService _tokenLoginInvoker

     [KNHook hookClass:@"TBSDKMTOPServer"];//getUaPageName    aluMTopService _tokenLoginInvoker

    return %orig;
}
%end

2.2 具体步骤

2.2.1 debugserver

iPhone:~ root#  debugserver *:12345 -a AlipayWallet
debugserver-@(#)PROGRAM:debugserver  PROJECT:debugserver-320.2.89
 for armv7.
Attaching to process AlipayWallet...
Segmentation fault: 11

当程序运行后，使用 debugserver *:1234 -a BinaryName 附加进程出现 segmentfault 11 时，一般说明程序内部调用了ptrace 。

iPhone:~ root#  debugserver *:12345 -x backboard /var/mobile/Containers/Bundle/Application/A612F542-81EF-456A-A6A0-B23046EF57BA/AlipayWallet.app/AlipayWallet
debugserver-@(#)PROGRAM:debugserver  PROJECT:debugserver-320.2.89
 for armv7.
Segmentation fault: 11

2.2.2 分析如何调用的ptrace

debugserver -x

iPhone:~ root# debugserver -x *:12345 /var/mobile/Containers/Bundle/Application/A612F542-81EF-456A-A6A0-B23046EF57BA/AlipayWallet.app/AlipayWallet
error: invalid TYPE for the --launch=TYPE (-x TYPE) option: '*:12345'
Valid values TYPE are:
  auto       Auto-detect the best launch method to use.
  posix      Launch the executable using posix_spawn.
  fork       Launch the executable using fork and exec.
  backboard  Launch the executable through BackBoard Services.

总共有四种类型

debugserver -x backboard *:1234 /var/mobile/...... 把这个backboard改成posix试试

iPhone:~ root#  debugserver -x posix *:12345  /var/mobile/Containers/Bundle/Application/A612F542-81EF-456A-A6A0-B23046EF57BA/AlipayWallet.app/AlipayWallet
debugserver-@(#)PROGRAM:debugserver  PROJECT:debugserver-320.2.89
 for armv7.
Listening to port 12345 for a connection from *...

在ptrace上下断点，找到调用ptrace的地方

(lldb)  b ptrace
Breakpoint 1: no locations (pending).
WARNING:  Unable to resolve breakpoint to any actual locations.

(lldb) c
Process 1657 resuming

关闭Target，重新启动Target

1 location added to breakpoint 1
Process 1657 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x37a13e64 libsystem_kernel.dylib`__ptrace
libsystem_kernel.dylib`__ptrace:
->  0x37a13e64 <+0>:  ldr    r12, [pc, #0x4]           ; <+12>
    0x37a13e68 <+4>:  ldr    r12, [pc, r12]
    0x37a13e6c <+8>:  b      0x37a13e74                ; <+16>
    0x37a13e70 <+12>: rsbeq  r9, r11, #192, #2
Target 0: (AlipayWallet) stopped.
(lldb)  p/x $lr
(unsigned int) $0 = 0x0000bfbb

由此可见ptrace函数在libsystem_kernel.dylib这个动态库中，使用时才进行加载，不是静态放在本地的，所以我们不能简单地去tweak ptrace函数。

(lldb) image list -o -f |grep AlipayWallet
[  0] 0x00000000 /private/var/mobile/Containers/Bundle/Application/A612F542-81EF-456A-A6A0-B23046EF57BA/AlipayWallet.app/AlipayWallet(0x0000000000004000)

所以ptrace的调用者位于0x0000bfbb - 0x00000000 = 0x0000bfbb处，如图所示：

在hopper使用go to add ,快捷键G

掘金 iOS
Flutter应用代码混淆完整指南：Android与iOS平台配置详解疯狂的程序猴
2026年4月14日 14:37

Flutter应用代码混淆完整指南：Android与iOS平台配置详解

掘金 iOS

作者疯狂的程序猴

2026年4月14日 14:37

Flutter中的代码混淆

代码混淆可以隐藏你的Dart代码中的函数和类名，让反编译 App变得困难。对于更全面的混淆需求，特别是针对iOS IPA文件，可以使用专业工具如IpaGuard，它支持无需源码的代码和资源混淆，兼容Flutter等多种开发平台，有效增加反编译难度。

注：Dart的混淆还没有经过完全的测试，如果发现问题请到GitHub上提 issue 。关于混淆的问题，还可以参考 Stack Overflow 上的这个问题。

Flutter中的混淆配置其实是在Android和iOS端分别配置的。

Android

在 <ProjectRoot>/android/gradle.properties 文件中添加如下代码：

extra-gen-snapshot-options=--obfuscate

默认情况下，Flutter不会混淆或者缩减Android host，如果你使用了第三方的Java或者Android库，那么你可能需要减小APK体积，或者防止你的App被反编译。

Step 1：配置Proguard文件

新建 /android/app/proguard-rules.pro 文件，然后添加如下配置：


#Flutter Wrapper
-keep class io.flutter.app.** { *; }
-keep class io.flutter.plugin.**  { *; }
-keep class io.flutter.util.**  { *; }
-keep class io.flutter.view.**  { *; }
-keep class io.flutter.**  { *; }
-keep class io.flutter.plugins.**  { *; }

上面的配置只保护Flutter库，其他额外的库（比如Firebase）需要你自己添加配置。

Step 2：

打开 /android/app/build.gradle 文件，定位到 buildTypes 处，在 release 配置中将 minifiyEnabled 和 useProguard 标志设为true，同时还需要指向Step1中创建的ProGuard文件：


android {
    ...
    buildTypes {
        release {
            signingConfig signingConfigs.debug
            minifyEnabled true
            useProguard true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

注意混淆和缩减无用代码会加长App的编译时间。

iOS

Step 1：修改 "build aot"

在 <ProjectRoot>/packages/flutter_tools/bin/xcode_backend.sh 文件中添加 build aot flag：

${extra_gen_snapshot_options_or_none}

然后定义这个flag：


local extra_gen_snapshot_options_or_none=""
if [[ -n "$EXTRA_GEN_SNAPSHOT_OPTIONS" ]]; then
  extra_gen_snapshot_options_or_none="--extra-gen-snapshot-options=$EXTRA_GEN_SNAPSHOT_OPTIONS"
fi

Step 2：应用你的修改

在你的App的根目录下运行以下两条命令：


git commit -am "Enable obfuscation on iOS"
flutter

Step 3：更改release配置

在 <ProjectRoot>/ios/Flutter/Release.xcconfig 中添加下面这行：

EXTRA_GEN_SNAPSHOT_OPTIONS=--obfuscate

对于iOS平台，如果需要更强大的混淆保护，可以考虑使用IpaGuard这样的工具，它可以直接对IPA文件进行混淆加密，支持代码和资源文件的全面混淆，无需源码即可操作，并兼容Flutter应用，提供即时测试功能。

AI没我们想的那么聪明！复盘我的Vibe Coding翻车案例

掘金 iOS

作者吴就业

2026年4月14日 13:17

我已经失去了编写代码的能力，变成只会写提示词的提示词工程师。但也没有完全丧失，我还会Review代码，偶尔手动改几行代码。

比如用Swift写UI，我在完全不复制粘贴的情况下，已经不会从0行代码写出一个页面，只会在AI生成的代码微调布局。

准确的说，不是丧失了能力，而是丧失了记忆！

回顾最近在开发ApiCatcher这款iOS端HTTPS抓包和调试工具的过程中，除了用AI开发核心功能遇到困难，其实在开发UI过程中也遇到一些困难。

今天分享我用AI开发ApiCatcher UI遇到的两个问题。解决这两个问题，我从Gemini 3.1 Pro模型，升级到Claude Opus 4.6模型，又从Claude Opus 4.6模型降到Gemini 3 Flash，最新只用Gemini 3 Flash就解决了问题。

第一个案例，我让AI帮我开发ApiCatcher的“AI对话生成脚本”功能，这里遇到的问题就是Markdown渲染。AI响应的消息里面包含代码。

关于UI，我的提示词大概是这样的：

页面做成聊天对话界面，底部是输入框和发送按钮，其余空间是显示聊天记录，用户只能发送文本消息，AI响应的消息是Markdown格式，AI响应的消息包含代码块，需要能高亮渲染代码块，代码不自动换行，而是代码块可以左右滚动。

这里的难点就是要支持代码块的高亮和代码块可以水平滚动。

无论是Gemini还是Claude，他们的思路都是先用开源的Swift语言编写的Markdown渲染开源库，怎么调都调不出令我满意的效果，渲染结果太丑了。在尝试完几个开源库后，Gemini和Claude会走向自己实现，写得非常复杂，然后实现的效果更加糟糕！

在无数次挫败后，我开始自己思考解决方案。我告诉Claude，SwiftUI的Markdown渲染开源库不好用，我们可以用Web技术栈，找JS开源库，然后用WebView来渲染Markdown消息。

这次Claude终于开窍了，但也没完全开窍。他把每个Markdown消息，都用一个WebView来渲染....

我再告诉他，为什么不是只用一个WebView来渲染所有消息呢？这时候Claude限制额度了......

我降回了Gemini 3 Flash。终于在几次调整后，Gemini做出了我想要的效果。

最终用到的技术栈：WebView、CodeMirror、Highlight.js。

第二个案例，JSON可折叠可搜索。

这次一上来就用Claude Sonnet 4.6模型，提示词：帮我实现JSON全屏预览页面，要求：JSON高亮显示，路径可以折叠和展开，可以搜索，搜索结果高亮，可以点击“下一个”按钮跳转到下一个搜索结果的位置。

Claude还是一样的思路，先找SwiftUI的开源库，但折腾半天卡在了搜索功能。还是一样折腾到耗尽Claude额度。

SwiftUI没有好用的开源库，那就换个思路，于是我又想到了WebView。最后选择WebView+CodeMirror+Highlight.js，加上CodeMirror的一个行号插件、搜索插件，用Gemini 3 Flash开发，完美实现！

在这两个案例中，无论是Claude还是Gemini，他们的思考方式都是先找SwiftUI可以使用的开源库，如果达不到目的，就改变策略，自己实现，但这种复杂的任务，他们根本没能力实现好。他们无法变通到通过WebView去乔接，从使用Swift技术栈，转变为使用Web开发技术栈。

我们只要告诉AI方法，他们就能实现，所以，目前AI的能力，其实受限于使用者的能力、认知。初级程序员+AI 无法超越高级程序员+AI！

未来提示词会替代编程语言，程序员从写代码变成写提示词，但我们依然需要学习提升写提示词的能力。编程能力从来不是指代码写得多漂亮，而是对底层原理的认知深度，同样写提示词的能力也并非是指表达能力，同样是对底层原理的认知深度和广度。

以上面两个案例为例，我们需要认识到Swift原生开发并不是只能使用Swift，SwiftUI开发的原生应用也可以使用WebView来渲染网页，可以Swift生成网页代码传递给WebView渲染，并且可以生成JS代码让WebView执行。我们可以不懂怎么去写代码实现，只需要知道可以这样做，这极大降低了学习难度！

AI放大了我们个人的能力：从需要学会如何编码实现，了解具体的底层原理，到只需要知道可以这样实现。

但只是放大个人能力，AI遇强则强，遇弱则弱，我们依然需要保持学习。

掘金 iOS
【AFNetworking】OC 时代网络请求事实标准，Alamofire 的前身探索者dx
2026年4月14日 00:39

【AFNetworking】OC 时代网络请求事实标准，Alamofire 的前身

掘金 iOS

作者探索者dx

2026年4月14日 00:39

【AFNetworking】OC 时代网络请求事实标准，Alamofire 的前身

iOS三方库精读 · 第 9 期

一、一句话介绍

AFNetworking 是 iOS / macOS 平台上最早也是最成功的 Objective-C HTTP 网络库，它让网络请求从繁琐的 NSURLConnection / NSURLSession API 变得简洁优雅，成为 OC 时代的事实标准。

属性	值
GitHub Stars	33k+
最新版本	4.0.0
License	MIT
支持平台	iOS 9+ / macOS 10.10+ / watchOS / tvOS
维护状态	维护模式（Maintenance Mode）

二、为什么选择它

原生痛点（2011 年的 iOS 世界）

在没有 AFNetworking 之前，iOS 开发者不得不面对：

NSURLConnection 样板代码：每次请求都要实现 delegate 回调，代码分散难以维护
JSON 解析手动处理：iOS 5 之前没有 NSJSONSerialization，需要第三方库
图片加载无缓存：网络图片每次都要重新下载，没有内存/磁盘缓存
网络状态监听复杂：Reachability API 繁琐，代码量大
HTTPS 配置困难：自签名证书、SSL Pinning 需要深入了解安全 API

AFNetworking 核心优势

一行代码发起请求：GET / POST / PUT / DELETE 统一 API，无需 delegate
自动序列化：JSON / XML / Plist / Image 响应自动解析
UIImageView Category：setImageWithURL: 一行搞定网络图片加载
Reachability 内建：实时监听网络状态，断网自动提示
SSL Pinning 支持：证书校验一行配置，安全合规
Block 回调：告别分散的 delegate，代码逻辑更清晰

原生 API vs AFNetworking

场景	原生 NSURLSession	AFNetworking
GET 请求	10+ 行代码 + delegate	`[manager GET:success:failure:]`
JSON 解析	`NSJSONSerialization` 手动调用	自动解析为 NSDictionary / NSArray
图片加载	需自行实现缓存	`setImageWithURL:` 一行
网络监听	Reachability 复杂 API	`setReachabilityStatusChangeBlock:`
文件上传	构造 multipart 请求繁琐	`POST:constructingBodyWithBlock:`

三、核心功能速览

基础层 概念解释、环境配置、基础用法

环境配置

CocoaPods（OC 项目首选）

pod 'AFNetworking', '~> 4.0'

Swift Package Manager

// Package.swift
dependencies: [
    .package(url: "https://github.com/AFNetworking/AFNetworking.git", from: "4.0.0")
]

Swift 项目桥接

// {ProjectName}-Bridging-Header.h
#import <AFNetworking/AFNetworking.h>
#import "UIImageView+AFNetworking.h"

基础 GET 请求

// AFNetworking 4.x (OC)
AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];

[manager GET:@"https://jsonplaceholder.typicode.com/users"
  parameters:nil
    progress:nil
     success:^(NSURLSessionDataTask *task, id responseObject) {
         NSLog(@"成功: %@", responseObject);
     }
     failure:^(NSURLSessionDataTask *task, NSError *error) {
         NSLog(@"失败: %@", error.localizedDescription);
     }];

进阶层 最佳实践、性能优化、线程安全

POST 请求带参数

NSDictionary *params = @{
    @"name": @"张三",
    @"email": @"zhangsan@example.com",
    @"age": @28
};

[manager POST:@"https://api.example.com/users"
   parameters:params
     progress:nil
      success:^(NSURLSessionDataTask *task, id responseObject) {
          NSLog(@"创建成功: %@", responseObject);
      }
      failure:^(NSURLSessionDataTask *task, NSError *error) {
          NSLog(@"创建失败: %@", error);
      }];

文件上传

NSData *imageData = UIImageJPEGRepresentation(image, 0.8);

[manager POST:@"https://api.example.com/upload"
   parameters:nil
    constructingBodyWithBlock:^(id<AFMultipartFormData> formData) {
        [formData appendPartWithFileData:imageData
                                    name:@"file"
                                fileName:@"photo.jpg"
                               mimeType:@"image/jpeg"];
    }
     progress:^(NSProgress *progress) {
         NSLog(@"上传进度: %.0f%%", progress.fractionCompleted * 100);
     }
      success:^(NSURLSessionDataTask *task, id responseObject) {
          NSLog(@"上传成功");
      }
      failure:^(NSURLSessionDataTask *task, NSError *error) {
          NSLog(@"上传失败: %@", error);
      }];

图片加载（UIImageView Category）

#import "UIImageView+AFNetworking.h"

// 基础用法
[imageView setImageWithURL:[NSURL URLWithString:@"https://example.com/avatar.jpg"]];

// 带占位图
[imageView setImageWithURL:[NSURL URLWithString:@"https://example.com/avatar.jpg"]
         placeholderImage:[UIImage imageNamed:@"default_avatar"]];

// 取消加载（cell 复用场景）
[imageView cancelImageDownloadTask];

网络状态监听

[[AFNetworkReachabilityManager sharedManager] setReachabilityStatusChangeBlock:
    ^(AFNetworkReachabilityStatus status) {
        switch (status) {
            case AFNetworkReachabilityStatusNotReachable:
                NSLog(@"无网络连接");
                break;
            case AFNetworkReachabilityStatusReachableViaWiFi:
                NSLog(@"WiFi 连接");
                break;
            case AFNetworkReachabilityStatusReachableViaWWAN:
                NSLog(@"蜂窝网络");
                break;
            default:
                break;
        }
    }];

[[AFNetworkReachabilityManager sharedManager] startMonitoring];

HTTPS 证书校验

manager.securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeCertificate];
manager.securityPolicy.allowInvalidCertificates = YES;  // 允许自签名
manager.securityPolicy.validatesDomainName = YES;

深入层 源码解析、设计思想、扩展定制

核心类关系

AFURLSessionManager (核心)
    ├── AFHTTPSessionManager (HTTP 封装)
    │       ├── requestSerializer (请求序列化)
    │       └── responseSerializer (响应序列化)
    ├── AFSecurityPolicy (安全策略)
    └── AFNetworkReachabilityManager (网络监听)

Category 扩展:
    UIImageView+AFNetworking (图片加载)
    UIProgressView+AFNetworking (进度条)
    AFNetworkActivityIndicatorManager (状态栏网络指示器)

Session Manager 核心设计

// AFHTTPSessionManager 继承 AFURLSessionManager
// 职责分离：网络层、请求构建、响应解析各自独立

@interface AFHTTPSessionManager : AFURLSessionManager
@property (nonatomic, strong) AFHTTPRequestSerializer <AFURLRequestSerialization> *requestSerializer;
@property (nonatomic, strong) AFHTTPResponseSerializer <AFURLResponseSerialization> *responseSerializer;
@end

// 序列化协议设计
@protocol AFURLRequestSerialization <NSObject>
- (NSURLRequest *)requestBySerializingRequest:(NSURLRequest *)request
                                withParameters:(id)parameters
                                         error:(NSError * __autoreleasing *)error;
@end

四、实战演示

场景：完整的网络请求封装

// APIClient.h - 统一网络请求封装
#import <AFNetworking/AFNetworking.h>

@interface APIClient : AFHTTPSessionManager
+ (instancetype)sharedClient;

// 业务方法
- (void)fetchUsers:(void(^)(NSArray *users, NSError *error))completion;
- (void)createUser:(NSDictionary *)params
        completion:(void(^)(NSDictionary *user, NSError *error))completion;
- (void)uploadAvatar:(UIImage *)image
           completion:(void(^)(NSString *url, NSError *error))completion;
@end

// APIClient.m
@implementation APIClient

+ (instancetype)sharedClient {
    static APIClient *instance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSURL *baseURL = [NSURL URLWithString:@"https://api.example.com/"];
        instance = [[self alloc] initWithBaseURL:baseURL];
        
        // 配置请求/响应序列化
        instance.requestSerializer = [AFJSONRequestSerializer serializer];
        instance.responseSerializer = [AFJSONResponseSerializer serializer];
        instance.requestSerializer.timeoutInterval = 30;
        
        // 添加通用请求头
        [instance.requestSerializer setValue:@"application/json"
                             forHTTPHeaderField:@"Content-Type"];
        
        // HTTPS 配置
        instance.securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeNone];
    });
    return instance;
}

- (void)fetchUsers:(void(^)(NSArray *users, NSError *error))completion {
    [self GET:@"users"
      parameters:nil
        progress:nil
         success:^(NSURLSessionDataTask *task, id responseObject) {
             completion(responseObject, nil);
         }
         failure:^(NSURLSessionDataTask *task, NSError *error) {
             completion(nil, error);
         }];
}

- (void)createUser:(NSDictionary *)params
        completion:(void(^)(NSDictionary *user, NSError *error))completion {
    [self POST:@"users"
   parameters:params
     progress:nil
      success:^(NSURLSessionDataTask *task, id responseObject) {
          completion(responseObject, nil);
      }
      failure:^(NSURLSessionDataTask *task, NSError *error) {
          completion(nil, error);
      }];
}

- (void)uploadAvatar:(UIImage *)image
           completion:(void(^)(NSString *url, NSError *error))completion {
    NSData *data = UIImageJPEGRepresentation(image, 0.8);
    
    [self POST:@"upload"
   parameters:nil
    constructingBodyWithBlock:^(id<AFMultipartFormData> formData) {
        [formData appendPartWithFileData:data
                                    name:@"avatar"
                                fileName:@"avatar.jpg"
                               mimeType:@"image/jpeg"];
    }
     progress:nil
      success:^(NSURLSessionDataTask *task, id responseObject) {
          NSString *url = responseObject[@"url"];
          completion(url, nil);
      }
      failure:^(NSURLSessionDataTask *task, NSError *error) {
          completion(nil, error);
      }];
}

@end

五、源码亮点

进阶层 值得借鉴的用法

序列化器组合模式

// 请求序列化器可插拔
manager.requestSerializer = [AFJSONRequestSerializer serializer];   // JSON
manager.requestSerializer = [AFPropertyListRequestSerializer serializer];  // Plist

// 响应序列化器可插拔
manager.responseSerializer = [AFJSONResponseSerializer serializer];  // JSON
manager.responseSerializer = [AFXMLParserResponseSerializer serializer];  // XML
manager.responseSerializer = [AFImageResponseSerializer serializer];  // Image

Block 回调替代 Delegate

// 传统 delegate 分散在多个方法
// AFNetworking 用 block 聚合逻辑
[manager GET:url
  parameters:params
    progress:^(NSProgress *progress) {
        // 进度回调
    }
     success:^(NSURLSessionDataTask *task, id responseObject) {
        // 成功回调
    }
     failure:^(NSURLSessionDataTask *task, NSError *error) {
        // 失败回调
    }];

深入层 设计思想解析

NSURLSession 封装架构

// AFURLSessionManager 核心方法
- (NSURLSessionDataTask *)dataTaskWithRequest:(NSURLRequest *)request
                            completionHandler:(void (^)(NSURLResponse *, id, NSError *))handler {
    // 1. 创建 task
    NSURLSessionDataTask *task = [self.session dataTaskWithRequest:request];
    
    // 2. 存储 task delegate（用于回调）
    self.mutableTaskDelegatesKeyedByTaskIdentifier[@(task.taskIdentifier)] = delegate;
    
    // 3. 返回 task
    return task;
}

// task delegate 处理各种回调
- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
    didReceiveData:(NSData *)data {
    // 累积数据，最终一次性回调
    [mutableData appendData:data];
}

UIImageView Category 的缓存设计

// UIImageView+AFNetworking 内部使用 AFImageDownloader
// 自动实现内存缓存 + 磁盘缓存

@interface AFImageDownloader : NSObject
@property (nonatomic, strong) AFImageCache *imageCache;  // 内存缓存
@property (nonatomic, strong) NSURLCache *urlCache;       // 磁盘缓存
@end

// 缓存策略
- (void)downloadImageForURLRequest:(NSURLRequest *)request
                        completion:(void (^)(UIImage *, NSError *))completion {
    // 1. 先查内存缓存
    // 2. 再查磁盘缓存
    // 3. 最后发起网络请求
}

六、踩坑记录

问题 1：iOS 9+ ATS 限制

问题：iOS 9 默认要求 HTTPS，HTTP 请求被阻止。

原因：App Transport Security (ATS) 默认禁止明文 HTTP。

解决：

<!-- Info.plist 添加例外 -->
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <true/>
</dict>

问题 2：Response Serializer 编码问题

问题：返回中文乱码或解析失败。

原因：服务器返回非 UTF-8 编码，AFJSONResponseSerializer 默认 UTF-8。

解决：

AFHTTPResponseSerializer *serializer = [AFHTTPResponseSerializer serializer];
serializer.stringEncoding = NSUTF8StringEncoding;  // 或其他编码
manager.responseSerializer = serializer;

问题 3：Cell 复用图片错乱

问题：UITableView 快速滚动时，图片显示错误。

原因：Cell 复用时未取消之前的下载任务。

解决：

- (void)prepareForReuse {
    [super prepareForReuse];
    [self.imageView cancelImageDownloadTask];  // 取消之前的下载
    self.imageView.image = nil;
}

问题 4：后台任务未处理

问题：App 进入后台后，下载任务中断。

原因：NSURLSession 默认不支持后台。

解决：

// 使用后台 session configuration
NSURLSessionConfiguration *config = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:@"com.example.background"];
AFHTTPSessionManager *manager = [[AFHTTPSessionManager alloc] initWithSessionConfiguration:config];

问题 5：Swift 混编桥接头文件缺失

问题：Swift 项目中使用 AFNetworking 报找不到模块。

原因：未配置 Objective-C Bridging Header。

解决：

创建 {ProjectName}-Bridging-Header.h 文件
添加 #import <AFNetworking/AFNetworking.h>
Build Settings → Swift Compiler - General → Objective-C Bridging Header 设置路径

七、延伸思考

AFNetworking vs Alamofire 横向对比

维度	AFNetworking	Alamofire
语言	Objective-C	Swift
首发年份	2011	2014
GitHub Stars	33k+	41k+
最低版本	iOS 9.0	iOS 12.0
包体积	~500KB	~300KB
维护状态	维护模式	活跃开发
Combine 集成	❌ 不支持	✅ DataRequest.publisher
async/await	❌ 不支持	✅ async(...)
SwiftUI 支持	❌ 不支持	需自行封装
学习曲线	中等	低（链式 API）
OC 兼容性	原生	需桥接

API 对照迁移表

AFNetworking (OC)	Alamofire (Swift)
`[manager GET:success:failure:]`	`AF.request(url).response()`
`[manager POST:parameters:success:failure:]`	`AF.request(url, method: .post, parameters: params)`
`[manager downloadTaskWithRequest:progress:destination:completion:]`	`AF.download(url).downloadProgress()`
`[manager uploadTaskWithRequest:from:progress:completion:]`	`AF.upload(multipartFormData:)`
`AFNetworkReachabilityManager`	`NWPathMonitor` (系统 API)
`AFSecurityPolicy`	`ServerTrustManager` + `PinnedCertificatesTrustEvaluator`
`UIImageView+AFNetworking`	AlamofireImage / Kingfisher

选型建议

选 AFNetworking：

维护遗留 OC 项目，迁移成本高
项目需要支持 iOS 9 ~ iOS 11
团队 OC 技术栈成熟，Swift 经验少

选 Alamofire：

新项目，Swift 为主要语言
需要 Combine / async-await 集成
想要更活跃的社区和持续更新
最低支持 iOS 12+

渐进式迁移策略

共存阶段：OC 模块继续用 AFNetworking，新 Swift 模块用 Alamofire
抽象层：统一封装 NetworkService 协议，底层可替换
按模块迁移：优先迁移独立的业务模块，而非逐个请求修改
测试覆盖：迁移前后确保集成测试通过

八、参考资源

官方资源

AFNetworking 3.0 迁移指南 - Mattt Thompson | 2015
从 AFNetworking 到 Alamofire - Ash Furrow | 2015

系列 Demo 仓库

github.com/ios-lib-dem… - 本系列配套代码

本期互动

小作业

查看你现有的 OC 项目中 AFNetworking 的使用方式，尝试将一个简单的 GET 请求改写为 Alamofire 版本，对比代码量和可读性变化。

思考题

AFNetworking 从 1.x 到 4.x 经历了 NSURLConnection → NSURLSession 的底层迁移，如果你是核心开发者，你会如何设计 API 以保持向后兼容？

读者征集

你在从 AFNetworking 迁移到 Alamofire 的过程中遇到过哪些坑？欢迎评论区分享，优质回答会收录进下一期《踩坑记录》。

📅 本系列每周五晚更新 · 已学习：[✓ Alamofire] [✓ Kingfisher] [✓ Lottie] [✓ MarkdownUI] [✓ SDWebImage] [✓ SnapKit] [✓ ListDiff] [✓ RxSwift] [→ AFNetworking] [○ Charts]

掘金 iOS
被 Vibe 摧毁的版权壁垒，与开发者的新护城河 -- 肘子的 Swift 周报 #131东坡肘子
2026年4月14日 07:56

被 Vibe 摧毁的版权壁垒，与开发者的新护城河 -- 肘子的 Swift 周报 #131

掘金 iOS

作者东坡肘子

2026年4月14日 07:56

被 Vibe 摧毁的版权壁垒，与开发者的新护城河

Anthropic 不久前宣布，由于其最新模型 Mythos 在网络安全与代码漏洞挖掘方面的能力“过于强大”，已达到令人不安的程度，因此采取了极为罕见的克制措施：仅向 Project Glasswing 内的少数关键基础设施企业开放，不面向公众发布，普通开发者也无法通过 API 调用（当然，也有分析者指出，这一安排同样有助于防止模型蒸馏，并锁定企业级客户）。但即便这头“猛兽”被暂时按住，当前主流 AI 模型的代码能力，已经足以让复制一款产品变得轻而易举。

上周，Reddit 上一位开发者宣称，自己花了一年时间“逆向 SwiftUI API”，打造了一个全新的 Swift Web 框架。帖子行文流畅、术语考究，一度吸引了不少关注。但 Paul Hudson 很快现身评论区打假：所谓“独立研发”，实际上只是将他的 MIT 开源项目 Ignite 做了简单的字符串替换，甚至连原作者带有个人风格的代码注释都原封不动保留，随后将整个仓库压缩为一次提交以抹除历史，并违规改为具有传染性的 GPL 协议。社区中不少开发者都怀疑，这套“逆向 SwiftUI”的叙事本身也是由 AI 生成。更耐人寻味的是，该作者本就是 Ignite 的主要贡献者之一——当 Vibe Coding 将“重新打包一个项目”的成本降至极低时，“我参与过”本身也可能成为一种模糊责任边界的话术。

几乎在同一时间，macOS 上精致的 AI 工作状态监控应用 Vibe Island 在发布后不久便遭遇了像素级仿制。尽管仿制者打着“开源替代品”的旗号公开了代码，这依然对原作者的商业销售与创作热情造成了明显冲击。然而，即便作者希望采取法律手段，也将面临一个新的时代难题：在确权与维权过程中，他可能需要证明其作品具备足够的人类独创性，并说明 AI 生成内容的参与程度，否则将面临更高的不确定性。

事实上，代码的法律壁垒正从“确权端”开始松动。上个月，中国版权保护中心正式启用新版《计算机软件著作权登记申请表》及相关审查新规，明确要求经办人实名承诺“未使用 AI 开发编写代码、撰写文档或生成登记材料”，并在审查中重点评估人类智力投入是否达到著作权法所要求的“独创性”门槛；缺乏实质人类参与的内容，将难以获得确权。违规者还可能被纳入失信名单，并与个人征信挂钩。

这一趋势也与欧美近期的判例方向趋于一致：如果一段代码主要由 AI 根据提示词快速“改写或重组”生成，其获得著作权保护的可能性将显著降低。

我们必须承认一个残酷的事实：“我有一个绝妙的 Idea，并把它 Vibe 成代码”，已经不足以构成商业壁垒。这种名为 Vibe Coding 的新范式，不仅改变了开发流程、显著提升了效率，也从三个方向同时动摇了软件版权体系的基础逻辑：确权门槛提高、侵权举证变难、功能复刻被默许。

令人遗憾的是，即便这些克隆项目饱受争议，它们依然在 GitHub 上收获了不菲的 Star。这说明，在获取成本极低的前提下，仅靠道德呼吁，已经很难阻止人们对“免费平替”的追逐。

或许，正如我们在第 120 期周报中讨论 Skip 的开源举措时所提到的那样——在代码实现成本趋近于零、应用随时可能被 AI 一键克隆的当下，闭门造车“卖工具”将变得愈发困难。与用户建立真实连接，将“出品方的信誉与社区的信任”转化为不可复制的品牌资产，或许才是未来开发者真正的核心竞争力与护城河。

本期内容 | 前一期内容 | 全部周报列表

近期推荐

Swift Blog Carnival: Tiny Languages

Swift 社区正在发起第一届 Blog Carnival，四月的主题是 Tiny Languages。Christian Tietze 邀请开发者围绕这一主题撰写博客：自定义 DSL、Result Builder、脚本解析器、路由规则……任何与“微型语言”相关的思考都可以作为切入点，截止日期为 5 月 1 日。

目前已有三篇投稿：

Matt Massicotte 回顾了他从 Rake 到 Make，再到各类 Swift 任务运行器的探索历程，坦言至今仍未找到理想替代品
Chris Liscio 分享了 Capo 应用内置 DSL 的设计：用于描述键盘与 MIDI 绑定，基于 Point-Free 的 swift-parsing 库构建
Nicolas Zinovieff 则展示了一个符号数学 DSL 的实验：通过协议与运算符重载，让 (1 + 2 * "X") * (3 - "Y")成为合法的 Swift 表达式，并在提供具体值时惰性求值，核心实现不超过 300 行

在 macOS 菜单中清晰显示当前选中状态 (Indicating Selection in macOS Menus Using SwiftUI)

SwiftUI 提供了不少用于表达选择的组件，例如 Picker、Toggle、Menu，但如何清晰地引导用户进行选择，并准确标识当前选中项，并没有想象中那样理所当然。Gabriel Theodoropoulos 从最基础的 Button 出发，一步步演进到 Picker 与 Toggle，系统梳理了几种常见方案及其各自的局限。文章的价值不在于给出“唯一正确解”，而在于提醒开发者：SwiftUI 提供的标准组件，并不会自动带来最佳的用户呈现效果。很多时候，你仍需在“系统一致性”与“实现自由度”之间做出权衡。

构建 List 的替代组件 (Building List replacement in SwiftUI)

如何在 List 与 ScrollView + LazyStack 之间做出选择，一直是困扰不少 SwiftUI 开发者的问题。在本文中，Majid Jabrayilov 在重构其 CardioBot 应用时，选择基于 SwiftUI 的 Container View API（iOS 17+）构建了三个可复用的 UI 组件：ScrollingSurface、DividedCard、SectionedSurface，以替代 List。这些组件在使用方式上与 List + Section 高度相似，但彻底摆脱了 listRowBackground、listItemTint 等仅在 List 中生效的限制。

List 并非只是“有默认样式的 LazyVStack”——两者在底层架构、滚动控制、与导航容器的协同、以及大数据集下的性能表现上均有本质差异。如何在两者之间做出综合判断，可以参考这篇旧文。

AppIntents meet MCP

当大家还在将 AppIntents 视为 Siri 与快捷指令的“配套工具”时，Florian Schweizer 给出了一个更值得关注的方向：将 AppIntents 直接暴露为 MCP（Model Context Protocol）工具，从而让 LLM 能够调用你的应用能力。Florian 基于 SwiftMCP，通过宏构建 MCP Server，并将 AppIntents 无缝映射为 MCP Tools，使 AI Agent 能够直接调用应用中的 Intent，实现跨应用自动化。

去年便有传闻，苹果正在为其生态系统引入 MCP 支持。或许再过两个月，在 WWDC 26 上答案便会揭晓。

创建交互式小组件 (Ride the Lightning Air: Building Interactive WidgetKit Widgets)

很多开发者都会被 WidgetKit 的文档误导，错将 AppIntentTimelineProvider 视为实现交互按钮的关键——实则不然。它是为“用户可配置 Widget”（如长按后编辑设置项）准备的，与交互行为并无直接关系。而真正用于实现交互（按钮点击触发行为）的，依然是最基础的 TimelineProvider。Wesley Matlock 通过一个虚构航空公司的登机状态 Widget，完整演示了正确路径：使用 TimelineProvider + Button(intent:) + AppGroup 共享存储来构建交互式 Widget。

整个数据流形成一个清晰的闭环：用户操作 → Intent 执行 → 状态写入 → Widget 刷新 → UI 更新。

文件存储与 iCloud：从本地到云端的完整认知

在 iOS / macOS 开发和使用中，文件存储往往被当作“基础能力”，但它实际上直接决定了数据的生命周期与系统行为。

在 Working with files and directories in iOS 一文中，Natascha Fadeeva 系统梳理了 App Sandbox 的结构，以及 Documents、Library、Caches 等目录的职责划分，帮助开发者建立“什么数据该放在哪里”的基本认知，并说明如何避免无关文件被 iCloud 备份。

而 Howard Oakley 撰写的 Understanding and Testing iCloud 则从系统层面揭示了这些数据的“后续命运”。iCloud 并非单一服务，而是由 CloudKit、iCloud Drive、系统更新等多个子系统组成，不同数据类型对应不同的同步与备份路径。

文件的存储位置，并不仅仅是组织问题，更是在定义它是否会被备份、同步，以及在设备之间如何流转。

因此，iCloud 问题往往不是“是否开启同步”这么简单，而是涉及客户端、网络、缓存以及服务端限流等多个环节。

工具

Bad Dock: 让你的 Dock 图标动起来

这是一个“离谱但严肃”的 macOS 实验项目。Eric Martz 利用公开的 NSDockTile / NSDockTilePlugin API，绕过 Big Sur 之后 Dock 图标的 squircle 限制，将视频流直接渲染进 Dock 图标。实现思路并不复杂，但非常完整：使用 AVAssetReader 解码视频、主动降帧至约 12fps、通过 ring buffer 控制内存占用，最终将一个“整活想法”打磨成了结构清晰的技术验证。

这类项目的价值不在功能本身，而在于展示：系统 API 的边界，往往比文档写得更远。

补充说明：该项目实现的是运行时动态 Dock 图标（应用运行时持续绘制）；应用退出后，仅能通过 NSDockTilePlugin 保留静态自定义图标。

往期内容

💝 支持与反馈

如果本期周报对你有帮助，请：

👍 点赞 - 让更多开发者看到
💬 评论 - 分享你的看法或问题
🔄 转发 - 帮助同行共同成长

🚀 拓展 Swift 视野

📮 邮件订阅 | weekly.fatbobman.com 获取独家技术洞察

👥 开发者社区 | Discord 实时交流开发经验

📚 原创教程 | fatbobman.com 学习 Swift/SwiftUI 最佳实践

掘金 iOS
iOS 自定义 UICollectionView 拼图布局 + 布局切换动画实践汉秋
2026年4月13日 14:51

iOS 自定义 UICollectionView 拼图布局 + 布局切换动画实践

掘金 iOS

作者汉秋

2026年4月13日 14:51

🧩 iOS 自定义 UICollectionView 拼图布局 + 布局切换动画实践

本文只讲两件事： 👉 如何自定义 UICollectionView 布局 👉 如何优雅地切换布局并处理动画问题

✨ 一、为什么要自定义布局？

系统的 UICollectionViewFlowLayout 有一个明显限制：

👉 只能做规则网格（grid）布局

但很多场景需要：

拼图布局（不规则）
瀑布流变种
卡片混排

例如👇

┌───────────────┐
│       A       │
├───────┬───────┤
│   B   │   C   │
└───────┴───────┘

👉 这种布局 FlowLayout 是做不了的

🧠 二、自定义布局核心原理

自定义布局本质只做三件事：

1️⃣ 计算每个 cell 的 frame

UICollectionViewLayoutAttributes

2️⃣ 返回可见区域的 attributes

override func layoutAttributesForElements(in rect: CGRect)

3️⃣ 告诉 collectionView 内容尺寸

override var collectionViewContentSize: CGSize

🔥 三、实现一个拼图布局（MosaicLayout）

核心代码

class MosaicLayout: UICollectionViewFlowLayout {

    var layoutAttributes: [UICollectionViewLayoutAttributes] = []
    var contentSize: CGSize = .zero

    override func prepare() {
        super.prepare()

        guard let collectionView = collectionView else { return }

        layoutAttributes.removeAll()

        let count = collectionView.numberOfItems(inSection: 0)
        guard count > 0 else { return }

        let width = collectionView.bounds.width
        let height = width

        let frames: [CGRect] = [
            CGRect(x: 0, y: 0, width: 1, height: 0.6),
            CGRect(x: 0, y: 0.6, width: 0.5, height: 0.4),
            CGRect(x: 0.5, y: 0.6, width: 0.5, height: 0.4)
        ]

        for (index, relativeFrame) in frames.enumerated() {

            let frame = CGRect(
                x: relativeFrame.origin.x * width,
                y: relativeFrame.origin.y * height,
                width: relativeFrame.width * width,
                height: relativeFrame.height * height
            )

            let attr = UICollectionViewLayoutAttributes(forCellWith: IndexPath(item: index, section: 0))
            attr.frame = frame
            layoutAttributes.append(attr)
        }

        contentSize = CGSize(width: width, height: height)
    }

    override func layoutAttributesForElements(in rect: CGRect) -> [UICollectionViewLayoutAttributes]? {
        return layoutAttributes.filter { $0.frame.intersects(rect) }
    }

    override var collectionViewContentSize: CGSize {
        return contentSize
    }
}

🎬 五、布局切换动画

collectionView.setCollectionViewLayout(newLayout, animated: true)

⚠️ 六、崩溃问题

The invalidation context is not an instance of UICollectionViewFlowLayoutInvalidationContext

解决方案

collectionView.setCollectionViewLayout(newLayout, animated: false)
collectionView.reloadData()

🎯 七、总结

👉 自定义布局 = 自己控制 frame 👉 动画关键 = 避免同时更新数据源

如果你觉得有用，欢迎点赞 👍

Flutter iOS应用混淆与安全配置详细文档指南

掘金 iOS

作者开心就好2025

2026年4月13日 12:03

Flutter iOS应用混淆与安全配置文档

概述

本文档详细描述了iOS应用的混淆与安全配置过程。这些配置旨在保护应用代码、API密钥和敏感数据，防止逆向工程和恶意攻击。配置包括 Dart 代码混淆、原生代码混淆、运行时安全检查和数据安全措施。

混淆与安全措施

Dart代码混淆

Flutter提供了内置的代码混淆功能，通过以下参数启用：

--obfuscate --split-debug-info=./symbols
1

这将：

重命名代码中的标识符，使反编译后的代码难以理解
将调试信息分离到单独的文件中，减少发布版本中的可读信息
保留符号信息用于崩溃分析，但不包含在发布版本中

此外，使用像IpaGuard这样的专业混淆工具可以进一步增强应用安全性。IpaGuard是一款强大的iOS IPA文件混淆工具，无需源码即可对代码和资源进行混淆加密，支持Flutter等多种开发平台，有效增加反编译难度。

原生代码混淆与安全

在iOS上，我们通过以下配置增强安全性：

BuildSettings.xcconfig 配置：

// 启用代码混淆和优化
GCC_OPTIMIZATION_LEVEL = s
SWIFT_OPTIMIZATION_LEVEL = -O
SWIFT_COMPILATION_MODE = wholemodule
DEAD_CODE_STRIPPING = YES

// 安全设置
ENABLE_STRICT_OBJC_MSGSEND = YES
CLANG_WARN_SUSPICIOUS_MOVE = YES
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES
GCC_NO_COMMON_BLOCKS = YES
STRIP_STYLE = all
STRIP_INSTALLED_PRODUCT = YES
COPY_PHASE_STRIP = YES
DEBUG_INFORMATION_FORMAT = dwarf-with-dsym

// 启用应用传输安全
PRODUCT_SETTINGS_URL_SCHEMES = "$(inherit)"
PRODUCT_SETTINGS_APP_TRANSPORT_SECURITY_ALLOWS_ARBITRARY_LOADS = NO

// 添加其他安全属性
OTHER_LDFLAGS = $(inherited) -Wl,-no_pie
12345678910111213141516171819202122

Xcode构建参数：

xcodebuild -workspace Runner.xcworkspace -scheme Runner -configuration Release clean build \
  ENABLE_BITCODE=YES STRIP_INSTALLED_PRODUCT=YES DEPLOYMENT_POSTPROCESSING=YES \
  -sdk iphoneos -allowProvisioningUpdates
123

这些参数确保：

启用Bitcode，允许App Store进一步优化代码
移除不必要的符号和调试信息
进行部署后处理操作，应用额外的优化

运行时安全检查

通过以下Swift代码实现运行时安全检查：

// 检查设备是否已越狱
func isJailbroken() -> Bool {


    #if targetEnvironment(simulator)
    return false
    #else
    // 检查常见的越狱文件路径
    let jailbreakPaths = [
        "/Applications/Cydia.app",
        "/Library/MobileSubstrate/MobileSubstrate.dylib",
        "/bin/bash",
        "/usr/sbin/sshd",
        "/etc/apt",
        "/private/var/lib/apt/",
        "/usr/bin/ssh"
    ]

    for path in jailbreakPaths {


        if FileManager.default.fileExists(atPath: path) {


            return true
        }
    }

    // 检查是否可以写入私有目录
    let stringToWrite = "Jailbreak Test"
    do {


        try stringToWrite.write(toFile: "/private/jailbreak.txt", atomically: true, encoding: .utf8)
        try FileManager.default.removeItem(atPath: "/private/jailbreak.txt")
        return true
    } catch {


        // 无法写入，说明没有越狱
    }

    return false
    #endif
}

// 检查是否连接调试器
func isDebuggerAttached() -> Bool {


    #if DEBUG
    return false
    #else
    var info = kinfo_proc()
    var mib: [Int32] = [CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()]
    var size = MemoryLayout<kinfo_proc>.stride
    let status = sysctl(&mib, UInt32(mib.1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556

苹果iOS应用开发上架与推广完整教程

掘金 iOS

作者开心就好2025

2026年4月13日 10:38

苹果应用上架与推广详细指南

作为苹果个人开发者，确保用户能够顺畅地下载并安装自己精心开发的应用，是不可或缺的一环。接下来，我们将深入探讨实现这一目标的一系列核心步骤。

01应用上架准备

> 注册开发者账号

注册开发者账号是发布应用的第一步，必须在苹果开发者官网完成信息填写和费用支付。你需要前往苹果开发者官网，填写包括姓名、联系方式在内的个人真实信息，并支付相应费用。完成注册与身份验证后，你将获得发布应用的权限。

> 确保应用符合准则

在用户能够顺畅地下载并安装应用之前，开发者需要完成一系列的准备工作。这些准备工作的目标是确保应用的下载和安装过程尽可能顺畅，从而提升用户体验。

应用需符合苹果的质量与安全标准，不得包含恶意代码，需具备良好的UI设计和正常功能。苹果对应用的质量、功能及安全性都设有严格标准。应用不得包含恶意代码，必须具备良好的用户界面设计，且功能正常、无显著漏洞。此外，应用还需遵守法律法规，如不得侵犯他人知识产权，不得诱导用户进行不合理付费等。只有满足这些准则的应用，才有可能通过审核并上架供用户下载。

> 选用开发工具与测试

接下来，我们就将详细介绍这些准备工作。在着手构建和测试应用之前，有几个关键步骤需要完成。这些步骤旨在为应用的顺畅下载和安装铺平道路，进而优化用户体验。

使用Xcode进行开发，选择合适的编程语言并在多设备和系统版本上进行全面测试，确保功能完备、兼容性和性能。通常，Xcode被视为开发首选，它提供了从代码编写到编译、调试的一站式服务。依据应用特性，选择如Swift或Objective-C等编程语言。以一个简易笔记应用为例，我们可以运用Swift来构建用户界面，并实现笔记的增删改查功能。务必在不同型号的iOS设备和多种系统版本上进行详尽测试。这包括验证功能的完备性，例如确认笔记应用能否顺利存储和读取数据；确保兼容性，以保证应用在iPhone、iPad等设备上的一致性；以及评估性能，如测试应用的启动速度和响应时间。例如，在iPhone 13与iPhone 8上分别运行笔记应用，观察是否存在布局混乱或功能失效的问题。此外，开发者也可以使用AppUploader等工具来简化iOS证书的申请和管理，支持在Windows、Linux或Mac系统中操作，无需依赖Mac电脑。

02向App Store提交与推广

> 准备元数据与分类选择

接下来，就可以将你的应用提交到App Store了。 提交应用前需准备应用名称、描述、截图及视频，并选择合适的分类以提高用户搜索的精准性。

为应用起一个简洁且能体现核心功能的名称，如“速记笔记”，同时撰写详细且吸引人的描述，突出应用特点、功能和优势。此外，还需提供展示关键界面和操作流程的截图及视频预览，使用户能直观了解应用。依此选择合适的分类，如笔记应用可归于“效率”类别。这样能帮助用户在App Store中更精准地搜索到应用。

> 提交审核与推广策略

通过App Store Connect提交审核，积极进行应用推广，包括社交媒体、博主合作及应用内推广，提高用户下载量。

使用Xcode完成应用打包后，通过App Store Connect提交应用进行审核。或者，使用AppUploader工具上传IPA文件到App Store，它支持多平台，比Application Loader更高效，且不携带设备信息。审核过程通常需数日，期间苹果团队将检查应用是否符合各项标准。若审核过程中发现任何问题，将收到反馈通知，需根据反馈进行相应修改后重新提交。同时，积极推广应用也是提高下载量的关键。

社交媒体推广：借助Twitter、Facebook、Instagram等社交媒体平台，广泛宣传您的应用。您可以分享应用截图、详细的功能介绍以及使用教程等，以此吸引更多潜在用户的关注。例如，在Twitter上发布一系列关于您的笔记应用使用技巧的推文，并附上应用的下载链接。
与博主和媒体合作：积极联系相关领域的博主、自媒体或科技媒体，向他们介绍您的应用，并努力争取他们的推荐或报道。例如，与专注于效率类应用评测的博主取得联系，邀请他们体验您的应用并分享他们的使用感受。
应用内推广：如果您还有其他已发布的应用，可以在这些应用内部推广您的新应用，从而引导现有用户下载并体验。

通过上述推广策略，苹果个人开发者可以成功地推动应用的下载安装，并通过广泛的推广活动提高应用的下载量和用户活跃度，从而让您的开发成果得到更多用户的认可和喜爱。

掘金 iOS
【DGCharts】iOS 图表渲染事实标准——8 种图表类型、高度可定制，3 行代码画出一条折线探索者dx
2026年4月13日 10:25

【DGCharts】iOS 图表渲染事实标准——8 种图表类型、高度可定制，3 行代码画出一条折线

掘金 iOS

作者探索者dx

2026年4月13日 10:25

【DGCharts】iOS 图表渲染事实标准——8 种图表类型、高度可定制，3 行代码画出一条折线

iOS三方库精读 · 第 11 期

一、一句话介绍

DGCharts（原名 Charts）是一个用于 iOS/macOS/tvOS 的图表渲染库，它是 Android 端 MPAndroidChart 的 Swift 移植版，让在 UIKit 与 SwiftUI 中绘制专业级折线图、柱状图、饼图等 8 种图表类型变得像配置数据一样简单。

属性	信息
⭐ GitHub Stars	27.5k+
最新稳定版	5.1.0
License	Apache 2.0
支持平台	iOS 13+ / macOS 10.14+ / tvOS 13+
语言	Swift（纯 Swift，无 OC 接口）

二、为什么选择它

原生痛点

苹果官方没有提供专用图表框架（Swift Charts 直到 iOS 16 才随 SwiftUI 一起发布），在此之前，iOS 开发者要想画一条像样的折线图，要么：

用 CoreGraphics 手撸贝塞尔曲线 → 代码量大，动画难实现
用 CALayer + CAAnimation → 正确实现坐标系变换极其麻烦
引入 WebView 渲染 ECharts → 性能差、交互延迟

DGCharts 解决的核心痛点：

零 CoreGraphics 基础可上手：数据 → DataSet → Chart，三行完成
内置 8 种图表类型：折线、柱状、饼、雷达、散点、K 线、气泡、组合图
原生手势支持：缩放、拖拽、高亮点击，全部开箱即用
可定制到像素级别：颜色、字体、轴线、动画均可覆盖
iOS 13+，Swift Charts 的前辈：大量存量 App 仍在使用，理解它有助于迁移评估

与 Swift Charts 的核心区别（一眼对比）

维度	DGCharts	Swift Charts（苹果官方）
平台要求	iOS 13+	iOS 16+
UI 框架	UIKit + SwiftUI	SwiftUI only
图表类型	8 种（含 K 线/雷达）	折/柱/面积/点（4 种）
动画控制	精细帧级控制	声明式，较难定制
手势交互	内置缩放/平移	需自己实现
维护状态	社区维护，活跃	Apple 官方，稳定更新

三、核心功能速览

基础层（新手必读）

环境集成

SPM（推荐）：

// Package.swift 或 Xcode Add Package Dependency
// URL: https://github.com/danielgindi/Charts.git
// from: "5.1.0"

CocoaPods：

pod 'DGCharts', '~> 5.1.0'

最简用法：3 行画折线图

import DGCharts

let chartView = LineChartView(frame: view.bounds)

// 准备数据
let entries = (0..<10).map { ChartDataEntry(x: Double($0), y: Double.random(in: 10...100)) }
let dataSet = LineChartDataSet(entries: entries, label: "销售额")
chartView.data = LineChartData(dataSet: dataSet)

view.addSubview(chartView)

基础层 概念：ChartDataEntry 是最小数据单元（x, y），XxxChartDataSet 是同类数据的集合（样式配置在这里），XxxChartData 是图表的数据容器，XxxChartView 是最终渲染视图。

进阶层（最佳实践）

8 种图表类型一览

类名	用途
`LineChartView`	折线图（支持曲线插值）
`BarChartView`	柱状图（支持堆叠/分组）
`PieChartView`	饼图 / 甜甜圈图
`RadarChartView`	雷达图（蜘蛛网图）
`ScatterChartView`	散点图
`CandleStickChartView`	K 线图（OHLC）
`BubbleChartView`	气泡图
`CombinedChartView`	组合图（折+柱叠加）

常用样式定制

// 折线数据集样式
let dataSet = LineChartDataSet(entries: entries, label: "趋势")
dataSet.colors = [.systemBlue]          // 线条颜色
dataSet.lineWidth = 2.0                  // 线宽
dataSet.circleColors = [.systemBlue]     // 数据点颜色
dataSet.circleRadius = 4.0               // 数据点半径
dataSet.drawFilledEnabled = true         // 开启渐变填充
dataSet.fillColor = .systemBlue
dataSet.fillAlpha = 0.3
dataSet.mode = .cubicBezier              // 贝塞尔平滑曲线

// 图表视图样式
lineChartView.rightAxis.enabled = false  // 隐藏右轴
lineChartView.xAxis.labelPosition = .bottom
lineChartView.animate(xAxisDuration: 1.0, easingOption: .easeInOutQuart)

交互设置

chartView.scaleXEnabled = true           // 允许 X 轴缩放
chartView.scaleYEnabled = false          // 禁止 Y 轴缩放
chartView.dragEnabled = true             // 允许拖拽
chartView.pinchZoomEnabled = true        // 双指缩放
chartView.doubleTapToZoomEnabled = false // 关闭双击缩放

X 轴自定义 Formatter

// 将数字索引转为日期字符串
class DateAxisValueFormatter: AxisValueFormatter {
    private let dates = ["1月", "2月", "3月", "4月", "5月", "6月"]
    func stringForValue(_ value: Double, axis: AxisBase?) -> String {
        let index = Int(value)
        return index < dates.count ? dates[index] : ""
    }
}
chartView.xAxis.valueFormatter = DateAxisValueFormatter()

深入层（源码视角）

DGCharts 的核心渲染架构遵循 Renderer 模式：

ChartView → 入口，持有 ChartData 和多个 DataRenderer
DataRenderer（如 LineChartRenderer）→ 负责具体图形绘制，使用 CGContext
ChartViewBase → 提供手势识别、坐标变换 Transformer
Transformer → 负责将数据坐标系映射到屏幕坐标系（核心矩阵变换）

每次 data 被 set，触发 notifyDataSetChanged() → calcMinMax() → setNeedsDisplay()，最终回调 draw(_ rect:) 由各 Renderer 完成绘制。

四、实战演示

场景：股票日 K 线 + 成交量组合图

// Swift UIKit，iOS 17+
import UIKit
import DGCharts

class StockChartVC: UIViewController {

    private lazy var combinedChart: CombinedChartView = {
        let chart = CombinedChartView()
        chart.legend.enabled = true
        chart.rightAxis.enabled = false
        chart.xAxis.labelPosition = .bottom
        chart.animate(xAxisDuration: 0.8)
        return chart
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .systemBackground
        view.addSubview(combinedChart)
        combinedChart.frame = CGRect(x: 16, y: 100,
                                      width: view.bounds.width - 32,
                                      height: 320)
        setupChart()
    }

    private func setupChart() {
        // ---- K 线数据 ----
        let candleEntries: [CandleChartDataEntry] = [
            CandleChartDataEntry(x: 0, shadowH: 185, shadowL: 162, open: 165, close: 178),
            CandleChartDataEntry(x: 1, shadowH: 190, shadowL: 170, open: 178, close: 188),
            CandleChartDataEntry(x: 2, shadowH: 195, shadowL: 175, open: 188, close: 177),
            CandleChartDataEntry(x: 3, shadowH: 182, shadowL: 165, open: 177, close: 169),
            CandleChartDataEntry(x: 4, shadowH: 175, shadowL: 160, open: 169, close: 172),
        ]
        let candleSet = CandleChartDataSet(entries: candleEntries, label: "K 线")
        candleSet.shadowColor = .darkGray
        candleSet.shadowWidth = 1.5
        candleSet.decreasingColor = .systemRed     // 阴线颜色
        candleSet.decreasingFilled = true
        candleSet.increasingColor = .systemGreen   // 阳线颜色
        candleSet.increasingFilled = true
        candleSet.neutralColor = .systemGray

        // ---- 成交量柱状图 ----
        let barEntries = [
            BarChartDataEntry(x: 0, y: 3200),
            BarChartDataEntry(x: 1, y: 5400),
            BarChartDataEntry(x: 2, y: 4100),
            BarChartDataEntry(x: 3, y: 6800),
            BarChartDataEntry(x: 4, y: 3900),
        ]
        let barSet = BarChartDataSet(entries: barEntries, label: "成交量（手）")
        barSet.colors = [.systemBlue.withAlphaComponent(0.5)]
        barSet.axisDependency = .right  // 绑定右轴（虽然禁用了，仅用于数据缩放）

        // ---- 组合 ----
        let combined = CombinedChartData()
        combined.candleData = CandleChartData(dataSet: candleSet)
        combined.barData = BarChartData(dataSet: barSet)

        // X 轴 Formatter
        combinedChart.xAxis.valueFormatter = IndexAxisValueFormatter(
            values: ["Mon", "Tue", "Wed", "Thu", "Fri"]
        )
        combinedChart.xAxis.granularity = 1
        combinedChart.data = combined
    }
}

五、源码亮点

进阶层：值得借鉴的用法

MarkerView——点击数据点显示气泡

// 自定义 Marker，继承 MarkerView
class BalloonMarker: MarkerView {
    private var label: String = ""

    override func refreshContent(entry: ChartDataEntry, highlight: Highlight) {
        label = String(format: "%.1f", entry.y)
        super.refreshContent(entry: entry, highlight: highlight)
    }

    override func draw(context: CGContext, point: CGPoint) {
        // 用 CoreGraphics 绘制气泡背景 + 文字
        let attrs: [NSAttributedString.Key: Any] = [
            .font: UIFont.systemFont(ofSize: 12),
            .foregroundColor: UIColor.white
        ]
        let attrStr = NSAttributedString(string: label, attributes: attrs)
        let size = attrStr.size()
        let rect = CGRect(x: point.x - size.width / 2 - 8,
                          y: point.y - size.height - 12,
                          width: size.width + 16, height: size.height + 8)
        context.setFillColor(UIColor.systemBlue.cgColor)
        UIBezierPath(roundedRect: rect, cornerRadius: 6).fill()
        attrStr.draw(in: rect.insetBy(dx: 8, dy: 4))
    }
}

// 绑定
chartView.marker = BalloonMarker()
chartView.drawMarkers = true

深入层：设计思想解析

1. Transformer 矩阵变换

DGCharts 用一个 CGAffineTransform 维护数据坐标 → 屏幕坐标的映射：

屏幕坐标 = 数据坐标 × scale + offset + chart padding

每次缩放/平移，只更新 transform 矩阵然后 setNeedsDisplay，避免重新计算所有点，是渲染性能的核心保障。

2. Protocol-Oriented Renderer

// 每种图表有独立 Renderer，统一协议
public protocol DataRenderer: AnyObject {
    func drawData(context: CGContext)
    func drawValues(context: CGContext)
    func drawExtras(context: CGContext)
    func drawHighlighted(context: CGContext, indices: [Highlight])
}

遵循开闭原则，新增图表类型只需实现此协议，不修改任何现有代码。

3. ChartHighlighter — 触摸高亮的寻值逻辑

触摸事件 → getHighlight(x:y:) → 二分查找最近 x → 在该 x 的所有 DataSet 中找最近 y → 返回 Highlight(x:y:dataSetIndex:) → 触发 highlightValue。整套流程在主线程同步完成，保证交互响应 < 16ms。

六、踩坑记录

问题 1：数据更新后图表没有刷新

原因：修改了 entries 数组但没有通知图表

解决：

chartView.data?.notifyDataChanged()
chartView.notifyDataSetChanged()

问题 2：X 轴标签显示 0, 1, 2 而不是自定义文字

原因：没有设置 xAxis.valueFormatter 或者 granularity 不正确

解决：

xAxis.valueFormatter = IndexAxisValueFormatter(values: yourLabels)
xAxis.granularity = 1.0   // 必须设置，否则可能跳步

问题 3：饼图中间的 "洞" 大小无法控制

原因：holeRadiusPercent 默认 0.5（即 50%）

解决：

pieChart.holeRadiusPercent = 0.3  // 调整洞的比例，0 = 实心饼图

问题 4：动画结束后视图突然闪烁

原因：animateX 和 animateY 同时调用，两个动画结束时各触发一次 setNeedsDisplay
解决：使用 animate(xAxisDuration:yAxisDuration:) 合并为一次调用

问题 5：在 SwiftUI 中使用时手势冲突

原因：DGCharts 的 UIPanGestureRecognizer 与 SwiftUI ScrollView 的手势抢夺

解决：

chartView.dragEnabled = false       // 在 ScrollView 内关闭拖拽
chartView.pinchZoomEnabled = false  // 关闭缩放

问题 6：Swift Package Manager 拉取超时

原因：Charts 仓库体积较大（含所有 Demo）
解决：在 package.json 中指定 .upToNextMinor(from: "5.1.0")，避免每次重新解析

七、延伸思考

维度	DGCharts	Swift Charts (Apple)	AAChartKit	Charts.js (WebView)
平台要求	iOS 13+	iOS 16+	iOS 11+	iOS (via WKWebView)
图表类型数	8	4	10+	20+
性能	原生，高	原生，高	原生，良好	WebView，差
K 线图	✅	❌	✅	✅
SwiftUI 支持	UIViewRepresentable	原生	UIViewRepresentable	WKWebViewRepresentable
维护状态	社区活跃	Apple 官方	活跃	Web 项目
学习曲线	中等	低（SwiftUI 声明式）	低	需了解 JS

不推荐场景

❌ 全新 App，最低支持 iOS 16+，且只用 SwiftUI → 直接用 Swift Charts
❌ 只需要一个简单静态饼图/柱图 → 手动 CoreGraphics 更轻量
❌ 需要超复杂的动态可视化（如力导向图）→ 考虑 WebView + D3.js

八、参考资源

GitHub: danielgindi/Charts
官方 Demo App
Apple Swift Charts 官方文档
WWDC 2022 Session 10137 - Hello Swift Charts
MPAndroidChart（Android 原版）
系列 Demo 仓库：github.com/yourname/ios-lib-demos

九、本期互动

小作业

使用 LineChartView 实现一个实时动态折线图：每秒追加一个随机数据点，并保持最多显示最近 20 个点（超出则移除最旧的点），同时保证图表 X 轴自动滚动跟随最新数据。完成后在评论区贴出你的核心更新逻辑。

思考题

DGCharts 的 Transformer 用矩阵变换把数据坐标映射到屏幕坐标，这种设计和 CALayer 的 transform 有何本质区别？如果让你自己实现一套坐标系映射，你会选择哪种方案？为什么？

读者征集

下一期我们将深入 Hero（转场动画库）。你在项目中用过哪些自定义转场方案（Hero / UIViewControllerTransitioningDelegate / NavigationController Push 动画）？欢迎评论区分享你的实践经验，优质回答会收录进下一期《踩坑记录》。

📅 本系列每周五晚更新 ✅ 第1期：Alamofire · ✅ 第2期：SDWebImage · ✅ 第3期：Kingfisher · ✅ 第4期：SnapKit · ✅ 第5期：ListDiff · ✅ 第6期：RxSwift · ✅ 第7期：Lottie · ✅ 第8期：MarkdownUI · ✅ 第9期：AFNetworking · ➡️ 第11期：DGCharts · ○ 第12期：Hero

掘金 iOS
Objective-C Runtime 完整机制：objc_class /cache/bits 源码解析MonkeyKing
2026年4月13日 08:08

Objective-C Runtime 完整机制：objc_class /cache/bits 源码解析

掘金 iOS

作者 MonkeyKing

2026年4月13日 08:08

Objective-C（以下简称 OC）的灵活性、动态性，核心源于其底层的 Runtime 机制。而 Runtime 所有动态行为（消息发送

在 objc_class 的核心字段中，superclass（父类指针）、cache（方法缓存）、bits（类数据指针+标志位）三者缺一不可。其中，cache 决定了方法调用的效率，bits 存储了类的核心数据（方法、属性、协议等），二者是理解 Runtime 动态机制的关键。

很多开发者使用 OC 多年，却只停留在“会用”层面，对objc_class 的底层结构、cache 的缓存机制、bits 的数据存储逻辑一知半解。本文将基于 Apple 开源的 objc4 源码（最新稳定版），逐行解析 objc_class、cache、bits 的底层实现，结合 Runtime 核心流程，让你彻底吃透 OC 类的底层逻辑。

一、前置基础：Runtime 与 objc_class 的核心关联

在解析具体源码前，先明确两个核心前提，避免陷入细节误区：

OC 是“动态语言”，其类和对象的行为并非编译期确定，而是由 Runtime 动态解析——比如方法调用、属性访问，最终都会被 Runtime 转化为底层函数调用（如 objc_msgSend）。

先看最基础的 objc_object 结构体（所有对象的祖宗），它是理解 objc_class 的前提：

// 所有OC对象的底层结构体（精简版，保留核心字段）
struct objc_object {
    isa_t isa; // 64位联合体，存储类指针、引用计数、标志位等信息
};

// isa_t 的核心结构（ARM64架构，iOS真机环境）
union isa_t {
    uintptr_t bits; // 原始64位数值，承载所有信息
    // 位域展开（64位按位分配）
    struct {
        uintptr_t nonpointer : 1;        // bit 0：是否是优化后的isa（0=纯指针，1=包含额外信息）
        uintptr_t has_assoc : 1;         // bit 1：是否有关联对象
        uintptr_t has_cxx_dtor : 1;      // bit 2：是否有C++析构函数
        uintptr_t shiftcls : 33;         // bit 3-35：类指针（右移3位存储，节省空间）
        uintptr_t magic : 6;             // bit 36-41：固定值0x1a，用于调试校验
        uintptr_t weakly_referenced : 1; // bit 42：是否被弱引用
        uintptr_t unused : 1;            // bit 43：未使用
        uintptr_t has_sidetable_rc : 1;  // bit 44：引用计数是否溢出到SideTable
        uintptr_t extra_rc : 19;         // bit 45-63：引用计数-1（存储额外引用计数）
    };
};

简单来说，isa 的核心作用是“标识对象的类型”——通过shiftcls 字段，对象能找到自己对应的类（objc_class），而类的 isa 则指向元类（Meta Class），这是 OC 实现方法调用的基础。

二、核心解析：objc_class 结构体源码拆解

OC 中的“类”（如 NSObject、自定义类），底层本质是 objc_class 结构体的实例。以下是从 objc4 源码中提取的精简版 objc_class 结构体（保留核心字段，省略辅助方法），也是本文的核心分析对象：

// 类的底层结构体（继承自objc_object，因此包含isa字段）
struct objc_class : objc_object {
    // 1. 父类指针：指向当前类的父类（如NSObject的父类是nil）
    Class superclass;
    // 2. 方法缓存：哈希表结构，缓存最近调用的方法，提升调用效率
    cache_t cache;
    // 3. 类数据指针+标志位：存储类的核心数据（方法、属性、协议等）
    class_data_bits_t bits;
    
    // 核心方法：从bits中取出类的可读写数据（class_rw_t）
    class_rw_t *data() const {
        return bits.data();
    }
};

从源码可以看出，objc_class 继承自 objc_object，因此它本身也有 isa 字段（继承而来），同时新增了三个核心字段：superclass、cache、bits。

三者的核心关系的是：superclass 负责继承链的构建，cache 负责方法调用的缓存优化，bits 负责存储类的核心业务数据，三者协同支撑起 OC 类的所有动态行为。

补充：Class 类型的本质

我们日常使用的 Class 类型，本质是 objc_class 的指针别名，源码定义如下：

typedef struct objc_class *Class;

这就是为什么我们可以用 Class cls = [NSObject class]; 获取类对象——本质是获取 objc_class 结构体的指针。

三、深度解析：cache_t（方法缓存）的底层实现

在 OC 中，方法调用是高频操作（如 [self method]），如果每次调用都遍历类的方法列表查找，会严重影响性能。cache_t 的核心作用就是“缓存最近调用的方法”，下次调用时直接从缓存中取出，无需重复查找，这是 Runtime 优化方法调用效率的关键。

1. cache_t 结构体源码（精简版）

// 方法缓存结构体（哈希表实现）
struct cache_t {
    // 缓存存储的数组（数组元素是cache_entry_t类型，存储方法名和函数指针）
    bucket_t *_buckets;
    // 缓存的容量（总是2的幂，如4、8、16，方便哈希计算）
    mask_t _mask;
    // 已缓存的方法数量（当count > mask * 3/4时，会触发缓存扩容）
    mask_t _occupied;
    
    // 核心方法：插入方法缓存
    void insert(SEL sel, IMP imp, id receiver);
    // 核心方法：查找方法缓存
    IMP lookup(SEL sel);
};

其中，bucket_t 是缓存的“桶”，存储单个方法的缓存信息，源码如下：

// 单个缓存项（存储一个方法的信息）
struct bucket_t {
    SEL _sel; // 方法名（选择子，本质是const char*，如@selector(method)）
    IMP _imp; // 函数指针（指向方法的具体实现代码地址）
    
    // 辅助方法：获取方法名和函数指针
    SEL sel() const { return _sel; }
    IMP imp() const { return (IMP)((uintptr_t)_imp ^ (uintptr_t)this); }
};

2. cache_t 的核心特性与工作流程

理解 cache_t，关键要掌握“哈希表存储”“缓存插入”“缓存查找”“缓存扩容”四个核心流程，结合源码逻辑逐一拆解：

（1）哈希表存储逻辑

cache_t 采用“开放寻址法”实现哈希表：

用方法名 SEL 的哈希值，对_mask（缓存容量-1）取模，得到当前方法在 _buckets 数组中的索引；
如果该索引对应的桶为空，直接存入当前方法的 SEL 和 IMP；
如果该索引已被占用（哈希冲突），则顺次查找下一个空桶，直到找到空桶存入。

这里 _mask = 容量 - 1（如容量为8，_mask=7），取模操作可简化为 hash & _mask，效率远高于传统取模运算，这也是缓存容量必须是2的幂的原因。

（2）缓存插入流程（insert 方法核心逻辑）

当我们第一次调用某个方法时，Runtime 会先查找方法列表，找到后将其插入 cache_t，核心步骤如下（结合源码逻辑简化）：

计算方法 SEL 的哈希值 hash = sel_hash(sel)；

注意：IMP 存储时会进行“异或加密”（_imp = (IMP)((uintptr_t)imp ^ (uintptr_t)this)），读取时再解密，这是苹果的安全优化，防止恶意篡改方法实现。

（3）缓存查找流程（lookup 方法核心逻辑）

当我们再次调用该方法时，Runtime 会先从 cache_t 中查找，核心步骤如下：

计算 SEL 的哈希值，得到索引 index = hash & _mask；

（4）缓存扩容机制

当 _occupied（已缓存数量）超过 _mask * 3/4（缓存容量的75%）时，会触发缓存扩容，核心逻辑：

新容量 = 旧容量 * 2（始终保持2的幂）；
创建新的 _buckets 数组（容量为新容量）；
将旧缓存中的所有方法，重新哈希后插入新数组；
更新 _mask（新容量-1）和 _occupied（重置为旧的数量），释放旧数组内存。

3. cache_t 的实战意义

理解 cache_t 的缓存机制，能帮我们解释很多实际开发中的现象：

为什么“首次调用方法比后续调用慢”？—— 首次调用需要查找方法列表，后续调用直接从缓存中获取，效率更高；
为什么分类（Category）的方法会覆盖原类方法？—— 分类方法会在 Runtime 加载时，插入到类的方法列表头部，首次调用时会优先被缓存，后续调用会直接使用分类的方法；
为什么频繁调用不同方法，会导致缓存命中率下降？—— 缓存容量有限，频繁切换方法会导致缓存被覆盖，需要重新查找方法列表。

四、深度解析：class_data_bits_t（bits）的底层实现

如果说 cache_t 是“方法调用的加速器”，那么 bits 就是“类的核心数据仓库”——它存储了类的所有核心信息，包括方法列表、属性列表、协议列表、成员变量列表等，是 Runtime 实现动态特性的核心载体。

bits 的类型是 class_data_bits_t，它本身是一个“64位整数”，低位存储标志位，高位存储指向 class_rw_t 的指针（类的可读写数据），这种设计既能节省内存，又能高效访问数据。

1. class_data_bits_t 结构体源码（精简版）

// bits的类型：存储类数据指针+标志位
struct class_data_bits_t {
private:
    uintptr_t bits; // 64位整数，核心存储载体
    
public:
    // 核心方法：从bits中取出class_rw_t指针（核心数据）
    class_rw_t *data() const {
        // FAST_DATA_MASK：掩码，用于过滤标志位，取出高位的指针地址
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
    
    // 标志位操作方法（示例）
    bool isSwiftLegacy() const { return getBit(FAST_IS_SWIFT_LEGACY); }
    bool isSwiftStable() const { return getBit(FAST_IS_SWIFT_STABLE); }
    
private:
    // 读取指定位置的标志位
    bool getBit(uintptr_t bit) const {
        return (bits & bit) != 0;
    }
};

其中，FAST_DATA_MASK 是关键掩码（ARM64架构下），源码定义如下：

#define FAST_DATA_MASK 0x00007ffffffffff8UL

该掩码的作用是“过滤低位的标志位，保留高位的指针地址”——ARM64架构下，bits 的 bit 3~~46 存储 class_rw_t 指针，bit 0~~2 存储标志位，通过 bits & FAST_DATA_MASK 可快速取出指针。

2. 核心标志位解析（bit 0~2）

bits 的低位（bit 0~2）存储了3个核心标志位，用于标识类的类型和特性，源码定义如下：

FAST_IS_SWIFT_LEGACY = 1 << 0（bit 0）：是否是旧版 Swift 类（OC 类该标志位为0）；
FAST_IS_SWIFT_STABLE = 1 << 1（bit 1）：是否是新版 Swift 类（OC 类该标志位为0）；
FAST_HAS_DEFAULT_RR = 1 << 2（bit 2）：是否有默认的 retain/release 方法（ARC 环境下，OC 类默认有）。

这些标志位的作用是“快速区分类的类型”，Runtime 在处理方法调用、内存管理时，会根据这些标志位执行不同的逻辑。

3. class_rw_t：bits 指向的核心数据

bits.data() 会返回 class_rw_t 指针，class_rw_t 是“类的可读写数据”结构体，存储了类的方法、属性、协议等核心信息，源码精简如下：

// 类的可读写数据（runtime运行时可修改）
struct class_rw_t {
    // 版本号（用于兼容不同的Runtime版本）
    uint32_t version;
    // 类的flags（标志位，如是否是元类、是否有分类等）
    uint32_t flags;
    
    // 方法列表（存储类的所有方法，包括实例方法和类方法）
    method_array_t methods;
    // 属性列表（存储类的所有属性）
    property_array_t properties;
    // 协议列表（存储类遵循的所有协议）
    protocol_array_t protocols;
    
    // 成员变量列表（存储类的所有成员变量）
    ivar_array_t ivars;
};

其中，method_array_t、property_array_t 等都是“动态数组”（本质是指针数组），支持 Runtime 运行时动态添加（比如分类添加方法、属性），这也是 OC 支持“动态扩展”的核心原因。

4. bits 的核心工作流程

bits 的工作流程非常简单，核心是“通过掩码取出数据指针，访问类的核心信息”，结合 Runtime 方法查找流程，可总结为：

当 Runtime 需要查找类的方法时，先通过 objc_class->bits.data() 取出 class_rw_t 指针；

五、三者协同：objc_class / cache / bits 完整工作流程

结合前面的解析，我们用一个“方法调用”的完整流程，串联起 objc_class、cache、bits 的协同工作，让你彻底理解三者的关联：

调用 [obj method]，OC 编译器将其转化为 Runtime 函数调用 objc_msgSend(obj, @selector(method))；

从这个流程可以看出：cache 负责“加速查找”，bits 负责“存储数据”，objc_class 负责“组织关联”，三者协同，构成了 OC 方法调用的底层逻辑，也是 Runtime 动态机制的核心。

六、实战延伸：源码解析的实际应用

很多开发者会问：“搞懂这些源码，对实际开发有什么用？” 其实，Runtime 源码解析的价值，在于“解决底层问题、实现高级特性”，以下是3个常见的实战场景：

1. 解决“方法未实现”崩溃问题

当调用未实现的方法时，会触发 unrecognized selector sent to instance 崩溃。通过理解 cache 和 bits 的查找流程，我们可以通过 Runtime 钩子（如 resolveInstanceMethod），动态添加方法实现，避免崩溃：

// 动态添加未实现的方法
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(unimplementedMethod)) {
        // 动态添加方法实现
        class_addMethod([self class], sel, (IMP)dynamicMethod, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}

// 动态方法实现
void dynamicMethod(id self, SEL _cmd) {
    NSLog(@"动态添加的方法实现");
};

2. 实现“方法交换”（Method Swizzling）

方法交换是 OC 开发中常用的高级技巧，其底层依赖 bits 中的方法列表。通过修改 class_rw_t->methods 中方法的 IMP，可以实现方法交换：

// 方法交换
+ (void)swizzleMethod {
    Class cls = [self class];
    // 获取两个方法的SEL
    SEL originalSel = @selector(originalMethod);
    SEL swizzledSel = @selector(swizzledMethod);
    
    // 获取方法实例
    Method originalMethod = class_getInstanceMethod(cls, originalSel);
    Method swizzledMethod = class_getInstanceMethod(cls, swizzledSel);
    
    // 交换方法实现
    method_exchangeImplementations(originalMethod, swizzledMethod);
}

3. 动态添加属性（关联对象）

OC 中不能直接给分类添加属性，但可以通过 Runtime 的关联对象机制实现，其底层依赖 objc_object 的 has_assoc 标志位（存储在 isa 中）和 bits 中的相关逻辑：

// 给分类添加关联属性
@interface NSObject (Associated)
@property (nonatomic, copy) NSString *associatedStr;
@end

@implementation NSObject (Associated)
- (NSString *)associatedStr {
    return objc_getAssociatedObject(self, _cmd);
}

- (void)setAssociatedStr:(NSString *)associatedStr {
    objc_setAssociatedObject(self, @selector(associatedStr), associatedStr, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
@end

七、总结：Runtime 核心机制的本质

通过对 objc_class、cache、bits 的源码解析，我们可以发现：OC Runtime 的核心本质，是“用结构体存储类和对象的信息，用哈希表优化查找效率，用动态数组支持扩展”。

总结三个核心要点，帮你快速掌握本文重点：

objc_class 是类的底层载体，继承自 objc_object，包含 superclass、cache、bits 三个核心字段，负责组织类的继承关系和核心数据；

理解这些底层源码，不仅能帮你解决实际开发中的底层问题，更能让你从根源上理解 OC 的动态性，为后续学习更高级的 Runtime 特性（如元类、消息转发、分类加载）打下基础。毕竟，只有看透底层，才能真正掌控 OC 开发。

掘金 iOS
iOS 26 模拟器启动卡死：Method Swizzling 在系统回调时触发 nil 崩溃inxx
2026年4月11日 19:56

iOS 26 模拟器启动卡死：Method Swizzling 在系统回调时触发 nil 崩溃

掘金 iOS

作者 inxx

2026年4月11日 19:56

一、现象

在 Xcode 26.4 + iOS 26.4 模拟器上运行项目，app 卡在 Launching 界面，始终无法进入主界面。控制台有大量 objc 类重复实现的警告（AuthKitUI / AuthKit 框架重复），但这些是系统 bug，与本次崩溃无关。

使用 LLDB 暂停进程，thread list 看到主线程异常：

thread #1: tid = 0xb124db, 0x0000000118fc9c10 CoreFoundation`-[__NSArrayM insertObject:atIndex:] + 251, queue = 'com.apple.main-thread'

二、定位过程

在 LLDB 中执行 thread select 1 + bt，得到完整调用栈：

frame #0: CoreFoundation`-[__NSArrayM insertObject:atIndex:] + 251
frame #1: FNCategory`-[NSMutableArray safe_insertObject:atIndex:] at NSMutableArray+FN.m:68
frame #2: FNCategory`-[NSMutableArray safe_addObject:] at NSMutableArray+FN.m:51
frame #3: CoreFoundation`-[NSEnumerator allObjects] + 189
frame #4: AXCoreUtilities`-[AXBinaryMonitor _frameworkNameForImage:]
frame #5: AXCoreUtilities`-[AXBinaryMonitor _handleLoadedImagePath:]
frame #6: AXCoreUtilities`___axmonitor_dyld_image_callback_block_invoke

关键结论：系统无障碍框架 AXCoreUtilities 在动态加载镜像（dyld image load）时，触发了一个回调，该回调内部调用了 NSEnumerator allObjects，而这个 allObjects 底层最终调用了 NSMutableArray addObject:。

由于项目通过 Method Swizzling 将系统的 addObject: 替换成了自定义的 safe_addObject:，这个系统内部调用被"劫持"进了我们的代码。

而 safe_addObject: 内部调用了 safe_insertObject:atIndex:，这里对 NSMutableArray 插入对象时发生了崩溃。

三、根本原因

这是一个经典的 Method Swizzling 副作用问题，iOS 26 改变了 AXCoreUtilities 的内部实现，触发了长期潜伏的 bug。

完整调用链如下：

AXCoreUtilities（系统无障碍框架）在 dyld 加载镜像时触发内部回调
回调内部操作了一个系统私有数组对象，调用了 insertObject:atIndex:
由于 Method Swizzling，insertObject:atIndex: 已被替换成 safe_insertObject:atIndex:，系统内部调用被"劫持"进了我们的代码
safe_insertObject:atIndex: 内部再调用 [self safe_insertObject:anObject atIndex:index]（即原始方法），但此时 self 是系统内部的私有数组类型，不是普通的 __NSArrayM，导致无限递归或调用到了错误的 IMP，最终崩溃

问题的本质是：Swizzling 作用在父类（NSMutableArray）上，但系统传入的是私有子类对象，Swizzling 后的方法实现与私有类的内存布局不兼容，在 iOS 26 收紧了 AXCoreUtilities 的调用时序之后，这个潜在冲突被激活。

正规的修复思路是在 SwizzlingMethod 里加类型保护，确保只 swizzle __NSArrayM 本身而不影响其私有子类。但由于 FNCategory 是 Pod，还有 AFNetworking、DoraemonKit 等我们无法直接修改源码的三方库存在同样问题，所以统一在 Podfile post_install 里做全局兼容处理。

四、踩过的坑

坑 1：以为是 objc 类重复警告导致的

启动时控制台打印了大量 Class AKAlertImageURLProvider is implemented in both AuthKitUI and AuthKit 的警告，误以为是这些重复类导致崩溃。实际上这是 iOS 26.4 模拟器运行时自身的打包问题，与启动卡死无关。

坑 2：只修复了 FNCategory，没有扩大范围

最初只在 FNCategory 的 NSMutableArray+FN.m 里加了 nil 保护，但 AFNetworking 和 DoraemonKit 也有同样模式的 Swizzling，同样存在风险。

五、修复方案

思路

不针对单个文件做字符串替换，而是在 Podfile 的 post_install 阶段，全局扫描所有 Pod 源文件，找到所有 method_exchangeImplementations( 调用，在其前面统一注入 nil 保护。

实现（Podfile post_install）

post_install do |installer|
  # ... 其他 post_install 逻辑 ...

  # 全局修复：为所有 Pod 的 method_exchangeImplementations 调用注入 nil 保护
  # 防止 iOS 26 系统框架在 dyld 镜像加载回调中触发 Swizzled 方法时崩溃
  fixed_count = 0
  Dir.glob('Pods/**/*.{m,mm}').each do |file|
    content = File.read(file)
    next unless content.include?('method_exchangeImplementations(')

    new_content = content.gsub(
      /^(\s*)(method_exchangeImplementations\((\w+)\s*,\s*(\w+)\s*\)\s*;)/
    ) do
      indent = $1
      full_call = $2
      arg1 = $3
      arg2 = $4
      "#{indent}if (#{arg1} && #{arg2}) #{full_call}"
    end

    if new_content != content
      File.chmod(0644, file)
      File.write(file, new_content)
      puts "✅ 已修复 #{file} 的 method_exchangeImplementations nil 保护"
      fixed_count += 1
    end
  end
  puts "共修复 #{fixed_count} 处 method_exchangeImplementations nil 保护" if fixed_count > 0
end

修复效果

执行 pod install 后的输出：

✅ 已修复 Pods/AFNetworking/AFNetworking/AFNetworking/AFURLSessionManager.m 的 method_exchangeImplementations nil 保护
✅ 已修复 Pods/DoraemonKit/iOS/DoraemonKit/Src/Core/Category/NSObject+Doraemon.m 的 method_exchangeImplementations nil 保护
✅ 已修复 Pods/DoraemonKit/iOS/DoraemonKit/Src/Core/Plugin/Performance/StartTime/DoraemonStartTimeViewController.m 的 method_exchangeImplementations nil 保护
✅ 已修复 Pods/FNCategory/FNCategory/Classes/NSMutableArray+FN.m 的 method_exchangeImplementations nil 保护
✅ 已修复 Pods/FNCategory/FNCategory/Classes/NSObject+FNSwizzle.m 的 method_exchangeImplementations nil 保护
✅ 已修复 Pods/FNCategory/FNCategory/Classes/UIViewController+FNFullScreen.m 的 method_exchangeImplementations nil 保护
Integrating client project
Pod installation complete! There are 32 dependencies from the Podfile and 35 total pods installed.

共修复 6 处，涉及 AFNetworking、DoraemonKit、FNCategory 三个 Pod。

六、总结

项目	说明
问题类型	Method Swizzling 缺少 nil 保护，被系统内部回调触发
触发条件	iOS 26 改变了 dyld 镜像加载回调时序，在类注册完成前触发 Swizzle
崩溃位置	`NSMutableArray insertObject:atIndex:` → `safe_insertObject:atIndex:`
修复方式	Podfile post_install 全局注入 `if (A && B)` nil 保护
优点	一次修复，覆盖所有 Pod，无需逐个修改，pod update 后自动重新修复
注意	这是 Swizzling 的通用最佳实践，不局限于 iOS 26，建议所有项目都加上

AI编程对话式定位解决bug

掘金 iOS

作者 sweet丶

2026年4月11日 10:15

本文是想记录一个使用编译器打开工程后，通过对话式聊天直接定位bug，并提供有效解决方案，效果快速、省事令人满意！

一、传统方式下

先来看一个Crash日志的堆栈信息：

Termination Reason:<RBSTerminateContext| domain:10 code:0x8BADF00D 
explanation:scene-create watchdog transgression: application<com.xxx.aaa>:
34689 exhausted real (wall clock) time allowance of 3.43 seconds

// 
Thread 0 Crashed:
0      libsystem_pthread.dylib       _pthread_mutex_lock$VARIANT$armv81 + 120
1      libc++.1.dylib                std::__1::mutex::lock() + 12
2      libicucore.A.dylib            icu::Locale::getDefault() + 32
3      libicucore.A.dylib            icu::Locale::init(char const*, signed char) + 1400
4      libicucore.A.dylib            _ures_getLocaleByType + 436
5      libicucore.A.dylib            icu::DecimalFormatSymbols::initialize(icu::Locale const&, UErrorCode&, signed char, icu::NumberingSystem const*) + 256
6      libicucore.A.dylib            icu::DecimalFormatSymbols::DecimalFormatSymbols(icu::Locale const&, icu::NumberingSystem const&, UErrorCode&) + 236
7      libicucore.A.dylib            icu::number::LocalizedNumberFormatter::getDecimalFormatSymbols() const + 4608
8      libicucore.A.dylib            icu::number::LocalizedNumberFormatter::getDecimalFormatSymbols() const + 1632
9      libicucore.A.dylib            icu::number::LocalizedNumberFormatter::formatImpl(icu::number::impl::UFormattedNumberData*, UErrorCode&) const + 128
10     libicucore.A.dylib            icu::SimpleDateFormat::zeroPaddingNumber(icu::NumberFormat const*, icu::UnicodeString&, int, int, int) const + 524
11     libicucore.A.dylib            icu::SimpleDateFormat::subFormat(icu::UnicodeString&, char16_t, int, UDisplayContext, int, char16_t, icu::FieldPositionHandler&, icu::Calendar&, UErrorCode&) const + 904
12     libicucore.A.dylib            icu::SimpleDateFormat::_format(icu::Calendar&, icu::UnicodeString&, icu::FieldPositionHandler&, UErrorCode&) const + 688
13     libicucore.A.dylib            icu::SimpleDateFormat::format(icu::Calendar&, icu::UnicodeString&, icu::FieldPosition&) const + 80
14     libicucore.A.dylib            icu::DateFormat::format(double, icu::UnicodeString&, icu::FieldPosition&) const + 124
15     libicucore.A.dylib            _udat_format + 356
16     CoreFoundation                ___cficu_udat_format + 64
17     CoreFoundation                _CFDateFormatterCreateStringWithAbsoluteTime + 180
18     Foundation                    -[NSDateFormatter stringForObjectValue:] + 160
19     MyAPP                        -[HAMLaunchMonitor startUUID] + 136
...    MYApp                               其它调用函数

传统解决步骤：

查看LaunchMonitor中startUUID方法里面内容，看代码上有没明显bug；
查看调用NSDateFormatter的string...方法的方式是否有问题；
后面是系统堆栈，所以得出结论是系统库发生了长时间等锁；
查看崩溃说明是0x8BADF00D,确定是被系统WatchDog检测到杀死了进程导致的崩溃。
解决方式：少量偶现且逻辑不好修改，出临时性修复方案~
问题可能没有根本解决，只是概率降低了。

可以看到我们人工查看这个问题有几个瓶颈：

需要手动找到文件查看分析函数调用链，速度慢。

对于顶部的系统函数，我们一般是缺乏了解的，不知道里面发生了什么导致出了问题。

弄清楚了上面内容后，我们的解决方法也是基于自己认知的，存在偏差。

而这几个瓶颈，交给AI后那都不是事儿。

二、AI时代下Bug修复

复制堆栈信息交给AI工具，AI直接给出了根本原因及有效的方案：

Crash 类型

这是一个 Watchdog 超时 Crash（0x8BADF00D = "ate bad food"），发生在 scene-create（应用启动/场景创建） 阶段。系统允许的时间为 3.43 秒，但应用在该时间内未能完成启动。

根因分析

从调用栈来看，崩溃发生在 [-[HAMLaunchMonitor startUUID]] 方法中：
- (NSString *)startUUID { 
    NSDateFormatter *formatter = [NSDateFormatter new];
    formatter.dateFormat = @"yyMMddHHmmssSSS";
    formatter.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"]; 
    NSString* time = [formatter stringFromDate:[NSDate date]]; 
    // ... 
} 
主线程被阻塞在 pthread_mutex_lock 上，具体路径是：

startUUID 调用 NSDateFormatter stringForObjectValue: 进行日期格式化

底层 ICU 库执行 SimpleDateFormat::format 进行实际格式化

ICU 在格式化数字时需要获取 DecimalFormatSymbols

这触发了 icu::Locale::getDefault() 来获取系统默认 locale

getDefault() 内部需要获取一个 全局互斥锁（std::mutex）

该锁被其他线程持有，导致主线程死等（pthread_mutex_lock 卡住）

核心问题

锁竞争（Lock Contention） —— ICU 库内部有一个全局的 std::mutex 保护 Locale::getDefault()。在应用启动阶段，如果有多个线程同时使用 NSDateFormatter、NSNumberFormatter 或其他依赖 ICU 的 API，就会争抢这把锁。主线程被阻塞等锁，累计时间超过 watchdog 限制，系统杀掉了应用。

加剧因素

启动阶段调用 startUUID：该方法在 [commonParameters] 中被调用，而 commonParameters 在 [appDidFinishLaunch] 流程中执行——正处于 watchdog 监控最严格的时间窗口。

每次调用都创建新的 NSDateFormatter：NSDateFormatter 的初始化本身就是重量级操作，且会触发 ICU locale 的初始化。

ICU 内部的全局锁：这是系统库的已知问题，在 iOS 启动早期阶段锁竞争尤为严重，因为各种系统框架也在并发初始化。

建议修复方案

缓存 NSDateFormatter（最直接有效）：将 NSDateFormatter 创建为静态变量或单例属性，避免每次调用 startUUID 都重新创建：
- (NSString *)startUUID {
 static NSDateFormatter *formatter = nil;
  static dispatch_once_t onceToken; 
  dispatch_once(&onceToken, ^{
   formatter = [NSDateFormatter new]; 
   formatter.dateFormat = @"yyMMddHHmmssSSS"; 
   formatter.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"]; 
  }); 
   NSString *time = [formatter stringFromDate:[NSDate date]]; 
   NSString *startUuid = [NSString stringWithFormat:@"%@2000000%@", time, [self getRandomNumber]]; 
   return startUuid; 
 } 
延迟执行：将 startUUID 和上报逻辑延迟到首帧渲染之后，脱离 watchdog 监控的关键时间窗口。

替代方案：如果仅需要生成唯一标识，可以完全避免 NSDateFormatter，改用时间戳数字拼接：这完全绕开了 ICU/NSDateFormatter，不存在锁竞争问题。
- (NSString *)startUUID { 
NSTimeInterval now = [[NSDate date] timeIntervalSince1970]; 
long long ms = (long long)(now * 1000); 
NSString *startUuid = [NSString stringWithFormat:@"%lld2000000%@", ms, [self getRandomNumber]]; 
return startUuid;
 } 
推荐方案 3，因为它从根本上消除了 ICU 锁竞争的风险，同时性能开销最小。

三、感想

AI时代，整体APP行业的性能将得到大幅提升

优秀大模型解决Bug的能力很强，且修复速度和质量都发生了颠覆性的变化，意味着如果有规划+APP开发人员有心，大部分问题都能解决；AI编程工具下，目前AI写复杂功能可能还有点问题，但如果是指定AI去写一个特定功能bug率可能会比资深工程师还要好；借助AI来深入了解底层知识也很方便，对于提升工程师认知也有帮助，进一步提升了性能。

AI时代，Bug的解决方式会发生变化

现在的热修复功能集成到APP后，往往需要编写修复后的脚本语言文件，下发到APP，APP动态运行时交换方法实现解决。

AI时代的方式可能是：
-》Crash发生后，自动分析原因，出解决方案，发出通知；
-》人工收到通知后，选择一个方案；
-》自动生成对应的脚本文件，自动下发到对应的APP版本。
-》APP再次打开时，Bug已经自动修复。