┌─────────────────────────────────────────────┐
│  你的 App                                    │
├─────────────────────────────────────────────┤
│  界面层    SwiftUI · WidgetKit · RealityKit   │
├─────────────────────────────────────────────┤
│  能力层    SwiftData · StoreKit · HealthKit   │
│           FoundationModels · MapKit · ...     │
├─────────────────────────────────────────────┤
│  基础层    Swift 标准库 · Foundation           │
│           Observation · Swift Concurrency     │
└─────────────────────────────────────────────┘

let name = "Jerry"        // 常量，不可改
var count = 0             // 变量，可改
count += 1

let pi: Double = 3.14159  // 显式标注类型
let flag = true           // 类型推断为 Bool

let i: Int = 42
let d: Double = 3.14
let s: String = "你好"
let b: Bool = true
let arr: [Int] = [1, 2, 3]                    // 数组
let dict: [String: Int] = ["a": 1, "b": 2]    // 字典
let set: Set<Int> = [1, 2, 3]                 // 集合，无序不重复
let tuple: (name: String, age: Int) = ("Jerry", 30)  // 元组

let age = 30
print("我叫 \(name)，今年 \(age) 岁")

let text = """
    第一行
    第二行
    """

var nickname: String? = nil    // 现在没有昵称
nickname = "小刘"               // 现在有了

// 1. if let —— 有值就进入分支
if let nickname {
    print("昵称是 \(nickname)")   // 这里 nickname 是 String，不是 String?
} else {
    print("没有昵称")
}

// 2. guard let —— 没值就提前退出（推荐用于函数开头）
func greet(_ nickname: String?) {
    guard let nickname else {
        print("没有昵称，无法问候")
        return
    }
    print("你好，\(nickname)")     // 后续代码里 nickname 都是解包后的
}

// 3. ?? —— 提供默认值
let display = nickname ?? "匿名用户"

let length = nickname?.count      // Int?，nickname 为 nil 时整体为 nil

// if / else
if count > 10 { print("多") } else { print("少") }

// for-in
for i in 1...5 { print(i) }        // 1,2,3,4,5（闭区间）
for i in 1..<5 { print(i) }        // 1,2,3,4（半开区间）
for item in arr { print(item) }
for (key, value) in dict { print("\(key)=\(value)") }

// while
while count < 10 { count += 1 }

// switch —— Swift 的 switch 必须穷尽所有情况
let score = 85
switch score {
case 90...100: print("优秀")
case 60..<90:  print("及格")
default:       print("不及格")
}

let point = (x: 1, y: 0)
switch point {
case (0, 0):            print("原点")
case (_, 0):            print("在 X 轴上")
case (0, _):            print("在 Y 轴上")
case let (x, y) where x == y: print("在对角线上")
default:                print("其他位置")
}

// 基本函数
func add(_ a: Int, _ b: Int) -> Int {
    a + b        // 单表达式函数可省略 return
}

// 参数标签：外部名 + 内部名
func greet(person name: String, from city: String) -> String {
    "你好 \(name)，来自 \(city)"
}
greet(person: "Jerry", from: "北京")

// 默认值
func makeCoffee(size: String = "中杯", sugar: Int = 0) { }
makeCoffee()                  // 用默认值
makeCoffee(size: "大杯")

// 可变参数
func sum(_ numbers: Int...) -> Int { numbers.reduce(0, +) }

// 多返回值用元组
func minMax(_ arr: [Int]) -> (min: Int, max: Int)? {
    guard let first = arr.first else { return nil }
    return arr.reduce((first, first)) { (min($0.0, $1), max($0.1, $1)) }
}

// 完整写法
let double: (Int) -> Int = { (x: Int) -> Int in return x * 2 }
// 简化：类型推断 + 省略 return
let double2: (Int) -> Int = { x in x * 2 }
// 再简化：用 $0 表示第一个参数
let double3: (Int) -> Int = { $0 * 2 }

// 尾随闭包：最后一个参数是闭包时，可以写在括号外面
let sorted = [3, 1, 2].sorted { $0 < $1 }
let doubled = [1, 2, 3].map { $0 * 2 }        // [2, 4, 6]
let evens = [1, 2, 3, 4].filter { $0 % 2 == 0 } // [2, 4]
let total = [1, 2, 3].reduce(0, +)             // 6

Button("点我") {          // 这个 {} 是 action 闭包
    print("被点了")
}

// 结构体 —— 值类型，赋值时复制
struct Person {
    var name: String
    var age: Int

    // 计算属性
    var isAdult: Bool { age >= 18 }

    // 方法
    func greeting() -> String { "我是 \(name)" }

    // 修改自身属性的方法必须标 mutating
    mutating func birthday() { age += 1 }
}

var a = Person(name: "Jerry", age: 30)
var b = a          // 复制了一份，b 和 a 互不影响
b.name = "Tom"
print(a.name)      // 仍是 "Jerry"

// 类 —— 引用类型，赋值时共享同一个对象
class Counter {
    var value = 0
    func increment() { value += 1 }

    init(start: Int = 0) { value = start }   // 类必须写 init（除非所有属性有默认值）
    deinit { print("被释放了") }              // 析构
}

let c1 = Counter()
let c2 = c1        // c1 和 c2 指向同一个对象
c2.increment()
print(c1.value)    // 1

// 枚举 —— Swift 的枚举非常强大
enum LoadState {
    case idle
    case loading
    case loaded(items: [String])    // 关联值
    case failed(Error)
}

let state = LoadState.loaded(items: ["a", "b"])
switch state {
case .idle:              print("空闲")
case .loading:           print("加载中")
case .loaded(let items): print("加载了 \(items.count) 项")
case .failed(let error): print("失败：\(error)")
}

// 原始值枚举
enum Direction: String, CaseIterable {
    case north = "北", south = "南", east = "东", west = "西"
}
Direction.allCases.forEach { print($0.rawValue) }

struct Settings {
    var volume: Double = 0.5 {
        willSet { print("即将从 \(volume) 变为 \(newValue)") }
        didSet  { print("已从 \(oldValue) 变为 \(volume)") }
    }

    lazy var expensiveThing = computeSomethingSlow()   // 第一次访问时才计算
}

enum NetworkError: Error {
    case notFound
    case unauthorized
    case server(code: Int)
}

func fetch(id: Int) throws -> String {
    guard id > 0 else { throw NetworkError.notFound }
    return "数据 \(id)"
}

// 调用方必须处理
do {
    let data = try fetch(id: 1)
    print(data)
} catch NetworkError.notFound {
    print("没找到")
} catch {
    print("其他错误：\(error)")
}

// try? —— 出错返回 nil
let data = try? fetch(id: -1)      // String?

// try! —— 出错直接崩溃，慎用

extension NetworkError: LocalizedError {
    var errorDescription: String? {
        switch self {
        case .notFound:      "找不到内容"
        case .unauthorized:  "请先登录"
        case .server(let c): "服务器错误（\(c)）"
        }
    }
}

// 1. anyAppleOS —— 替代五个平台名的简写
@available(anyAppleOS 27, *)
func newFeature() { }

// 以前要写：
// @available(iOS 27, macOS 27, watchOS 27, tvOS 27, visionOS 27, *)

// 条件编译也能用
#if os(anyAppleOS)
    func makeWidget() -> some Widget { ... }
#endif

// 需要排除个别平台时照常叠加
@available(anyAppleOS 27, *)
@available(tvOS, unavailable)
func launch() { }

// 2. defer 中支持异步代码
func process() async throws {
    let handle = try await openResource()
    defer { await handle.close() }    // 无论正常返回还是抛错都会执行
    try await doWork(with: handle)
}

// 3. @diagnose —— 更精细地控制警告

protocol Drawable {
    var area: Double { get }        // 要求一个只读属性
    func draw()                     // 要求一个方法
}

struct Circle: Drawable {
    let radius: Double
    var area: Double { .pi * radius * radius }
    func draw() { print("画一个圆") }
}

extension Drawable {
    func describe() { print("面积为 \(area) 的图形") }
    func draw() { print("默认绘制") }    // 遵守者可以不实现 draw
}

struct Todo: Identifiable, Codable, Hashable {
    let id = UUID()
    var title: String
    var done = false
}
// 就这样，JSON 编解码、去重、SwiftUI 列表全部可用

extension String {
    var isValidEmail: Bool {
        contains("@") && contains(".")
    }
}
"[email protected]".isValidEmail    // true

extension Double {
    var asCurrency: String {
        formatted(.currency(code: "CNY"))
    }
}

func firstElement<T>(of array: [T]) -> T? {
    array.first
}

// 带约束的泛型
func maxElement<T: Comparable>(of array: [T]) -> T? {
    array.max()
}

// 泛型类型
struct Stack<Element> {
    private var items: [Element] = []
    mutating func push(_ item: Element) { items.append(item) }
    mutating func pop() -> Element? { items.popLast() }
    var isEmpty: Bool { items.isEmpty }
}

var s = Stack<Int>()
s.push(1); s.push(2)

func makeShape() -> some Drawable { Circle(radius: 1) }
//                  ↑ 「某个确定的、但我不告诉你具体是什么的」类型 —— 编译期确定，高性能

func processAny(_ shape: any Drawable) { shape.draw() }
//                       ↑ 「任意遵守协议的」类型 —— 运行期动态派发，可以放进异构数组

class Parent { var child: Child? }
class Child { weak var parent: Parent? }    // weak 打破循环

class ViewModel {
    var onUpdate: (() -> Void)?
    func setup() {
        onUpdate = { [weak self] in         // 用 [weak self] 避免循环
            guard let self else { return }
            self.doSomething()
        }
    }
    func doSomething() {}
}

func loadUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/user/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// 调用
Task {
    do {
        let user = try await loadUser(id: 1)
        print(user.name)
    } catch {
        print("失败：\(error)")
    }
}

// 串行：总耗时 = A + B
let a = try await loadUser(id: 1)
let b = try await loadUser(id: 2)

// 并行：总耗时 = max(A, B)
async let userA = loadUser(id: 1)
async let userB = loadUser(id: 2)
let (a2, b2) = try await (userA, userB)

// 数量不定时用 TaskGroup
func loadAll(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids {
            group.addTask { try await loadUser(id: id) }
        }
        var results: [User] = []
        for try await user in group { results.append(user) }
        return results
    }
}

let task = Task {
    for i in 0..<1000 {
        try Task.checkCancellation()    // 检查是否被取消
        await process(i)
    }
}
task.cancel()

struct UserView: View {
    @State private var user: User?

    var body: some View {
        Text(user?.name ?? "加载中")
            .task {                       // 视图出现时开始，消失时自动取消
                user = try? await loadUser(id: 1)
            }
    }
}

actor ImageCache {
    private var cache: [URL: Data] = [:]

    func image(for url: URL) -> Data? { cache[url] }
    func store(_ data: Data, for url: URL) { cache[url] = data }
}

let cache = ImageCache()
await cache.store(data, for: url)     // 访问 actor 需要 await

@MainActor
@Observable
final class TodoStore {
    var todos: [Todo] = []

    func refresh() async {
        let fetched = await fetchFromServer()   // 这一步在后台
        todos = fetched                          // 回到主线程更新
    }
}

struct Todo: Sendable { ... }              // 自动推断，通常不用写

final class Config: Sendable {             // 需要所有属性都是 let 且 Sendable
    let apiKey: String
    init(apiKey: String) { self.apiKey = apiKey }
}

// 逐行读文件
for try await line in url.lines {
    print(line)
}

// 自定义流
let stream = AsyncStream<Int> { continuation in
    Task {
        for i in 0..<10 {
            continuation.yield(i)
            try? await Task.sleep(for: .seconds(1))
        }
        continuation.finish()
    }
}
for await value in stream { print(value) }

// Package.swift
// swift-tools-version: 6.2
import PackageDescription

let package = Package(
    name: "MyKit",
    platforms: [.iOS(.v26), .macOS(.v26)],   // 用 Xcode 27 工具链时可写 .v27
    products: [
        .library(name: "MyKit", targets: ["MyKit"])
    ],
    dependencies: [],
    targets: [
        .target(name: "MyKit"),
        .testTarget(name: "MyKitTests", dependencies: ["MyKit"])
    ]
)

swift package init --type library
swift build
swift test
swift run

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

    var body: some View {
        VStack(spacing: 16) {
            Text("计数：\(count)")        // 永远等于 count
                .font(.largeTitle)
            Button("加一") { count += 1 }  // 只改数据，界面自己更新
        }
    }
}

struct MyView: View {
    var body: some View {
        Text("Hello")
    }
}

// 文本
Text("标题")
    .font(.title)
    .fontWeight(.semibold)
    .foregroundStyle(.secondary)

// 图片
Image(systemName: "star.fill")        // SF Symbols，系统内置 7000+ 图标
    .symbolRenderingMode(.multicolor)
Image("myPhoto")                       // Assets 里的图片
    .resizable()
    .scaledToFit()

// 网络图片（iOS 27 起默认支持 HTTP 缓存）
AsyncImage(url: url) { image in
    image.resizable().scaledToFill()
} placeholder: {
    ProgressView()
}

// 按钮
Button("确定") { }
Button("删除", systemImage: "trash", role: .destructive) { }

// 输入
@State var text = ""
TextField("请输入", text: $text)
SecureField("密码", text: $password)
TextEditor(text: $longText)

// 选择
Toggle("开启通知", isOn: $notificationsEnabled)
Slider(value: $volume, in: 0...1)
Stepper("数量：\(count)", value: $count, in: 1...10)
Picker("尺寸", selection: $size) {
    Text("小").tag(Size.small)
    Text("中").tag(Size.medium)
}
DatePicker("日期", selection: $date, displayedComponents: .date)
ColorPicker("颜色", selection: $color)

// 状态指示
ProgressView()                          // 转圈
ProgressView(value: 0.7)                // 进度条
Label("收藏", systemImage: "heart")
Link("访问网站", destination: url)
ShareLink(item: url)                    // 系统分享

Text("Hi")
    .padding()              // 先加内边距
    .background(.blue)      // 再上背景 → 背景包含内边距

Text("Hi")
    .background(.blue)      // 先上背景 → 背景只有文字大小
    .padding()              // 再加内边距 → 内边距在背景外面

// 尺寸与位置
.frame(width: 100, height: 50)
.frame(maxWidth: .infinity)             // 尽量占满
.padding(.horizontal, 16)
.offset(x: 10, y: 0)

// 外观
.background(.regularMaterial)           // 材质背景（毛玻璃）
.foregroundStyle(.blue)
.clipShape(.rect(cornerRadius: 12))
.overlay { RoundedRectangle(cornerRadius: 12).stroke(.gray) }
.shadow(radius: 4)
.opacity(0.8)

// 交互
.onTapGesture { }
.disabled(isLoading)
.contextMenu { Button("删除") { } }
.swipeActions { Button("归档") { } }

// 生命周期
.task { await load() }                  // 出现时执行异步任务
.onAppear { }
.onChange(of: query) { old, new in }

// 弹出
.sheet(isPresented: $showSheet) { DetailView() }
.sheet(item: $selectedItem) { item in DetailView(item: item) }
.fullScreenCover(isPresented: $show) { }
.alert("确认删除？", isPresented: $showAlert) {
    Button("删除", role: .destructive) { }
    Button("取消", role: .cancel) { }
}
.confirmationDialog("选择操作", isPresented: $showDialog) { }
.popover(isPresented: $showPopover) { }

// 栈
VStack(alignment: .leading, spacing: 8) { }    // 垂直
HStack { }                                      // 水平
ZStack(alignment: .topTrailing) { }             // 叠放

// 滚动
ScrollView { LazyVStack { } }
ScrollView(.horizontal) { LazyHStack { } }

// 网格
LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))]) { }

// 列表 —— 最常用
List(todos) { todo in
    Text(todo.title)
}

// 带分区、删除、移动的列表
List {
    Section("今天") {
        ForEach(todos) { todo in
            TodoRow(todo: todo)
        }
        .onDelete { indexSet in delete(at: indexSet) }
        .onMove { from, to in move(from: from, to: to) }
    }
}

// 表格（macOS / iPadOS）
Table(people) {
    TableColumn("姓名", value: \.name)
    TableColumn("年龄") { Text("\($0.age)") }
}

#Preview {
    CounterView()
}

#Preview("深色模式") {
    CounterView()
        .preferredColorScheme(.dark)
}

#Preview("带数据", traits: .sizeThatFitsLayout) {
    TodoRow(todo: .init(title: "买牛奶"))
}

struct ParentView: View {
    @State private var isOn = false          // 真相来源在这里

    var body: some View {
        VStack {
            Text(isOn ? "开" : "关")
            ChildToggle(isOn: $isOn)          // $ 取出 Binding
        }
    }
}

struct ChildToggle: View {
    @Binding var isOn: Bool                   // 引用父视图的状态

    var body: some View {
        Toggle("开关", isOn: $isOn)
    }
}

import Observation

@MainActor
@Observable
final class TodoStore {
    var todos: [Todo] = []
    var isLoading = false

    // 不想被观察的属性
    @ObservationIgnored private var cache: [String: Data] = [:]

    func add(_ title: String) {
        todos.append(Todo(title: title))
    }

    func load() async {
        isLoading = true
        defer { isLoading = false }
        todos = await fetchTodos()
    }
}

struct TodoListView: View {
    @State private var store = TodoStore()      // 用 @State 持有，不是 @StateObject

    var body: some View {
        List(store.todos) { todo in
            Text(todo.title)
        }
        .task { await store.load() }
    }
}

struct EditView: View {
    @Bindable var todo: Todo        // Todo 是 @Observable class

    var body: some View {
        TextField("标题", text: $todo.title)
    }
}

// 1. 定义（iOS 17+ 的宏写法）
extension EnvironmentValues {
    @Entry var todoStore = TodoStore()
}

// 2. 注入
@main
struct MyApp: App {
    @State private var store = TodoStore()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.todoStore, store)
        }
    }
}

// 3. 读取
struct DeepChildView: View {
    @Environment(\.todoStore) private var store
    var body: some View { Text("\(store.todos.count)") }
}

ContentView().environment(store)          // 注入
@Environment(TodoStore.self) private var store   // 读取

@Environment(\.colorScheme) private var colorScheme          // 深浅色
@Environment(\.dismiss) private var dismiss                  // 关闭当前页面
@Environment(\.openURL) private var openURL
@Environment(\.horizontalSizeClass) private var sizeClass    // 紧凑/常规布局
@Environment(\.dynamicTypeSize) private var typeSize         // 用户字号设置
@Environment(\.scenePhase) private var scenePhase            // 前台/后台
@Environment(\.locale) private var locale

struct SettingsView: View {
    @AppStorage("username") private var username = ""
    @AppStorage("isDarkMode") private var isDarkMode = false
    @AppStorage("fontSize") private var fontSize = 16.0

    var body: some View {
        Form {
            TextField("用户名", text: $username)
            Toggle("深色模式", isOn: $isDarkMode)
        }
    }
}

数据只在一个视图里用，且很简单？
  → @State

需要传给子视图并让子视图能改？
  → @Binding

有业务逻辑、需要跨视图共享？
  → @Observable class + @State 持有 + @Environment 分发

只是一个用户偏好设置？
  → @AppStorage

需要持久化的业务数据？
  → SwiftData（见第 11 章）

// NavigationStack —— 单栏推入式导航（iPhone 主力）
NavigationStack {
    List(todos) { todo in
        NavigationLink(todo.title, value: todo)
    }
    .navigationTitle("待办")
    .navigationDestination(for: Todo.self) { todo in
        TodoDetailView(todo: todo)
    }
}

// 可编程导航：用路径数组控制
@State private var path: [Todo] = []

NavigationStack(path: $path) {
    ...
}
// 之后可以 path.append(todo) 或 path.removeAll() 直接跳转/返回

// NavigationSplitView —— 双栏/三栏（iPad、Mac）
NavigationSplitView {
    SidebarView()          // 侧边栏
} content: {
    ListView()             // 中间列（可选）
} detail: {
    DetailView()           // 详情
}

// TabView —— 底部标签
TabView {
    Tab("首页", systemImage: "house") { HomeView() }
    Tab("设置", systemImage: "gear") { SettingsView() }
    Tab(role: .search) { SearchView() }     // 搜索标签有特殊样式
}

.toolbar {
    ToolbarItem(placement: .topBarLeading) {
        Button("取消") { dismiss() }
    }
    ToolbarItemGroup(placement: .primaryAction) {
        Button("保存") { save() }
        Menu("更多") { ... }
    }
}

@State private var query = ""

List(filteredItems) { ... }
    .searchable(text: $query, prompt: "搜索待办")
    .searchSuggestions {
        ForEach(suggestions) { Text($0).searchCompletion($0) }
    }
    .searchScopes($scope) {
        Text("全部").tag(Scope.all)
        Text("未完成").tag(Scope.pending)
    }

// Spacer 推开空间
HStack {
    Text("左")
    Spacer()
    Text("右")
}

// 布局优先级
HStack {
    Text("这段很长很长的文字").layoutPriority(1)
    Text("短的")
}

// 固定尺寸（不被压缩）
Text("不换行").fixedSize()

// 自定义布局：ViewThatFits 自动选第一个装得下的方案
ViewThatFits {
    HStack { A(); B(); C() }      // 宽的时候用这个
    VStack { A(); B(); C() }      // 窄的时候用这个
}

// GeometryReader 读取可用空间（能不用就不用，会破坏布局协商）
GeometryReader { proxy in
    Text("宽度：\(proxy.size.width)")
}

// Grid —— 需要对齐的表格布局
Grid {
    GridRow { Text("姓名"); Text("Jerry") }
    GridRow { Text("城市"); Text("北京") }
}

// 隐式动画：状态变了就自动过渡
@State private var isExpanded = false

Rectangle()
    .frame(height: isExpanded ? 200 : 100)
    .animation(.spring, value: isExpanded)     // 只对 isExpanded 的变化做动画

// 显式动画
Button("展开") {
    withAnimation(.spring(duration: 0.4)) {
        isExpanded.toggle()
    }
}

// 转场：视图出现/消失的方式
if showDetail {
    DetailView()
        .transition(.move(edge: .bottom).combined(with: .opacity))
}

// 匹配几何：两个视图之间的形变动画
@Namespace private var namespace

// 视图 A
Image(...).matchedGeometryEffect(id: "hero", in: namespace)
// 视图 B
Image(...).matchedGeometryEffect(id: "hero", in: namespace)

// 导航转场（iOS 18+）：从卡片放大到详情页
NavigationLink { DetailView() } label: { CardView() }
    .matchedTransitionSource(id: item.id, in: namespace)

// 阶段动画：多步骤动画
Image(systemName: "bell")
    .phaseAnimator([0, -20, 20, 0]) { view, angle in
        view.rotationEffect(.degrees(angle))
    }

// 关键帧动画：多属性独立时间线
.keyframeAnimator(initialValue: AnimationValues()) { view, value in
    view.scaleEffect(value.scale).offset(y: value.offset)
} keyframes: { _ in
    KeyframeTrack(\.scale) {
        SpringKeyframe(1.2, duration: 0.2)
        SpringKeyframe(1.0, duration: 0.3)
    }
}

// SF Symbols 动效
Image(systemName: "heart.fill")
    .symbolEffect(.bounce, value: likeCount)
    .contentTransition(.symbolEffect(.replace))

.onTapGesture(count: 2) { }
.onLongPressGesture { }

@State private var offset = CGSize.zero
.gesture(
    DragGesture()
        .onChanged { offset = $0.translation }
        .onEnded { _ in withAnimation { offset = .zero } }
)

@State private var scale = 1.0
.gesture(MagnifyGesture().onChanged { scale = $0.magnification })

// 组合手势
.gesture(dragGesture.simultaneously(with: magnifyGesture))

// 给自定义视图套玻璃效果
MyCustomBar()
    .glassEffect(in: .rect(cornerRadius: 20))

// 材质背景
.background(.regularMaterial)      // 还有 .thin / .thick / .ultraThin / .ultraThick

// 按钮样式
Button("确定") { }.buttonStyle(.glass)
Button("确定") { }.buttonStyle(.borderedProminent)

Image(systemName: "heart.fill")
    .font(.title)
    .symbolRenderingMode(.hierarchical)      // 层次渲染
    .foregroundStyle(.red, .pink)            // 多色
    .symbolVariant(.circle)                  // 变体
    .symbolEffect(.pulse)                    // 动效

import Charts

struct SalesChart: View {
    let data: [Sale]

    var body: some View {
        Chart(data) { sale in
            BarMark(
                x: .value("月份", sale.month),
                y: .value("销售额", sale.amount)
            )
            .foregroundStyle(by: .value("产品", sale.product))
        }
        .chartXAxis { AxisMarks(values: .automatic) }
        .chartLegend(position: .bottom)
        .frame(height: 200)
    }
}

import TipKit

struct FavoriteTip: Tip {
    var title: Text { Text("收藏这篇文章") }
    var message: Text? { Text("点击星标，稍后在收藏夹里查看") }
    var image: Image? { Image(systemName: "star") }
}

// 在 App 启动时配置
try? Tips.configure()

// 在界面上展示
Button("收藏", systemImage: "star") { }
    .popoverTip(FavoriteTip())

struct WebView: UIViewRepresentable {
    let url: URL

    func makeUIView(context: Context) -> WKWebView { WKWebView() }
    func updateUIView(_ view: WKWebView, context: Context) {
        view.load(URLRequest(url: url))
    }
}

Image(systemName: "star.fill")
    .accessibilityLabel("已收藏")
    .accessibilityHint("双击取消收藏")
    .accessibilityAddTraits(.isButton)

// 把一组元素合并成一个可访问元素
HStack { Image(...); Text("标题"); Text("副标题") }
    .accessibilityElement(children: .combine)

Text("你好")                              // 自动本地化
Text("共 \(count) 项")                     // 支持复数变体，在 Catalog 里配置
String(localized: "确认删除", comment: "删除确认弹窗的标题")

// 格式化（自动跟随用户地区）
Text(date, format: .dateTime.year().month().day())
Text(price, format: .currency(code: "CNY"))
Text(bytes, format: .byteCount(style: .file))

import SwiftData

@Model
final class Todo {
    var title: String
    var isDone: Bool
    var createdAt: Date
    var priority: Priority

    // 关系
    @Relationship(deleteRule: .cascade)
    var subtasks: [Subtask] = []

    // 不参与持久化
    @Transient var isEditing = false

    // 唯一约束
    #Unique<Todo>([\.title])

    // 建索引，加速查询
    #Index<Todo>([\.createdAt])

    init(title: String, priority: Priority = .normal) {
        self.title = title
        self.isDone = false
        self.createdAt = .now
        self.priority = priority
    }
}

enum Priority: Int, Codable, CaseIterable {
    case low, normal, high
}

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: Todo.self)      // 一行搞定
    }
}

let container = try ModelContainer(
    for: Todo.self, Subtask.self,
    configurations: ModelConfiguration(
        isStoredInMemoryOnly: false,
        cloudKitDatabase: .automatic      // 开启 iCloud 同步
    )
)

struct TodoListView: View {
    // 最简单：查全部
    @Query private var todos: [Todo]

    // 排序
    @Query(sort: \Todo.createdAt, order: .reverse)
    private var recentTodos: [Todo]

    // 过滤 + 排序 + 限量
    @Query(
        filter: #Predicate<Todo> { !$0.isDone },
        sort: [SortDescriptor(\.priority, order: .reverse),
               SortDescriptor(\.createdAt)]
    )
    private var pendingTodos: [Todo]

    var body: some View {
        List(pendingTodos) { todo in
            Text(todo.title)
        }
    }
}

struct SearchableTodoList: View {
    @Query private var todos: [Todo]

    init(searchText: String) {
        _todos = Query(filter: #Predicate<Todo> {
            searchText.isEmpty || $0.title.localizedStandardContains(searchText)
        })
    }

    var body: some View { List(todos) { Text($0.title) } }
}

struct AddTodoView: View {
    @Environment(\.modelContext) private var context
    @State private var title = ""

    var body: some View {
        Form {
            TextField("标题", text: $title)
            Button("添加") {
                context.insert(Todo(title: title))   // 插入
                // 不需要手动 save()，SwiftUI 环境下会自动保存
            }
        }
    }
}

// 删除
context.delete(todo)

// 修改：直接改属性即可
todo.isDone = true

// 手动保存（在非 SwiftUI 上下文中需要）
try context.save()

// 批量删除
try context.delete(model: Todo.self, where: #Predicate { $0.isDone })

@ModelActor
actor TodoImporter {
    func importTodos(from data: Data) throws {
        let items = try JSONDecoder().decode([TodoDTO].self, from: data)
        for item in items {
            modelContext.insert(Todo(title: item.title))
        }
        try modelContext.save()
    }
}

// 使用
let importer = TodoImporter(modelContainer: container)
try await importer.importTodos(from: data)

enum TodoSchemaV1: VersionedSchema {
    static var versionIdentifier = Schema.Version(1, 0, 0)
    static var models: [any PersistentModel.Type] { [Todo.self] }
}

enum TodoSchemaV2: VersionedSchema { ... }

enum TodoMigrationPlan: SchemaMigrationPlan {
    static var schemas: [any VersionedSchema.Type] {
        [TodoSchemaV1.self, TodoSchemaV2.self]
    }
    static var stages: [MigrationStage] {
        [.lightweight(fromVersion: TodoSchemaV1.self, toVersion: TodoSchemaV2.self)]
    }
}

UserDefaults.standard.set(true, forKey: "hasSeenOnboarding")
let seen = UserDefaults.standard.bool(forKey: "hasSeenOnboarding")

// App 与小组件、扩展共享数据需要 App Group
let shared = UserDefaults(suiteName: "group.com.yourname.app")

let docs = URL.documentsDirectory              // 用户数据，会被备份
let caches = URL.cachesDirectory                // 缓存，系统可能清理
let temp = URL.temporaryDirectory               // 临时文件

let fileURL = docs.appending(path: "notes.json")
try data.write(to: fileURL)
let loaded = try Data(contentsOf: fileURL)

// JSON 编解码
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
encoder.dateEncodingStrategy = .iso8601
let json = try encoder.encode(todos)

import CloudKit

let container = CKContainer.default()
let db = container.publicCloudDatabase

let record = CKRecord(recordType: "Article")
record["title"] = "标题"
try await db.save(record)

let query = CKQuery(recordType: "Article",
                    predicate: NSPredicate(format: "title CONTAINS %@", "Swift"))
let (results, _) = try await db.records(matching: query)

import Security

func saveToken(_ token: String) throws {
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: "apiToken",
        kSecValueData as String: Data(token.utf8)
    ]
    SecItemDelete(query as CFDictionary)
    let status = SecItemAdd(query as CFDictionary, nil)
    guard status == errSecSuccess else { throw KeychainError.saveFailed }
}

@main
struct MyDocApp: App {
    var body: some Scene {
        DocumentGroup(newDocument: TextDocument()) { file in
            EditorView(document: file.$document)
        }
    }
}

struct APIClient {
    let baseURL = URL(string: "https://api.example.com")!

    func fetch<T: Decodable>(_ path: String, as type: T.Type) async throws -> T {
        let url = baseURL.appending(path: path)
        let (data, response) = try await URLSession.shared.data(from: url)

        guard let http = response as? HTTPURLResponse else {
            throw APIError.invalidResponse
        }
        guard (200..<300).contains(http.statusCode) else {
            throw APIError.server(code: http.statusCode)
        }

        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .iso8601
        return try decoder.decode(T.self, from: data)
    }

    func post<Body: Encodable, T: Decodable>(
        _ path: String, body: Body, as type: T.Type
    ) async throws -> T {
        var request = URLRequest(url: baseURL.appending(path: path))
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(body)

        let (data, _) = try await URLSession.shared.data(for: request)
        return try JSONDecoder().decode(T.self, from: data)
    }
}

// 下载文件到磁盘（不占内存）
let (fileURL, _) = try await URLSession.shared.download(from: url)

// 上传
let (data, _) = try await URLSession.shared.upload(for: request, from: fileData)

// 流式读取（逐行）
for try await line in url.lines { print(line) }

// 后台下载（App 退到后台也继续）
let config = URLSessionConfiguration.background(withIdentifier: "com.app.download")

import Network

let monitor = NWPathMonitor()
monitor.pathUpdateHandler = { path in
    print(path.status == .satisfied ? "有网" : "没网")
    print(path.isExpensive ? "蜂窝网络" : "WiFi")
}
monitor.start(queue: .global())

import UserNotifications

// 请求权限
let granted = try await UNUserNotificationCenter.current()
    .requestAuthorization(options: [.alert, .badge, .sound])

// 本地通知
let content = UNMutableNotificationContent()
content.title = "该喝水了"
content.body = "已经两小时没喝水了"
content.sound = .default

let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 7200, repeats: true)
let request = UNNotificationRequest(identifier: UUID().uuidString,
                                    content: content, trigger: trigger)
try await UNUserNotificationCenter.current().add(request)

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(to: "用一句话总结这段文字：\(text)")
print(response.content)

let session = LanguageModelSession(
    instructions: """
    你是一个记账助手。用户会描述一笔消费，
    你需要提取金额、类别和商家。回答保持简洁。
    """
)

for try await partial in session.streamResponse(to: prompt) {
    displayText = partial.content     // 逐字更新界面
}

@Generable
struct Expense {
    @Guide(description: "消费金额，单位为元")
    let amount: Double

    @Guide(description: "消费类别", .anyOf(["餐饮", "交通", "购物", "娱乐", "其他"]))
    let category: String

    @Guide(description: "商家名称，如果无法确定则留空")
    let merchant: String

    @Guide(description: "3-5 个描述这笔消费的标签", .count(3...5))
    let tags: [String]
}

let session = LanguageModelSession()
let expense = try await session.respond(
    to: "今天在星巴克花了 38 块买咖啡",
    generating: Expense.self
).content

print(expense.amount)     // 38.0
print(expense.category)   // "餐饮"

struct SearchNotesTool: Tool {
    let name = "searchNotes"
    let description = "在用户的笔记中搜索包含关键词的内容"

    @Generable
    struct Arguments {
        @Guide(description: "搜索关键词")
        let query: String
    }

    func call(arguments: Arguments) async throws -> String {
        let results = await NoteStore.shared.search(arguments.query)
        return results.map(\.title).joined(separator: "\n")
    }
}

let session = LanguageModelSession(
    tools: [SearchNotesTool()],
    instructions: "你可以搜索用户的笔记来回答问题。"
)
let answer = try await session.respond(to: "我上周关于设计的笔记里写了什么？")

import AppIntents

struct AddTodoIntent: AppIntent {
    static let title: LocalizedStringResource = "添加待办"
    static let description = IntentDescription("在待办列表中新增一项")

    @Parameter(title: "内容")
    var text: String

    func perform() async throws -> some IntentResult & ProvidesDialog {
        await TodoStore.shared.add(text)
        return .result(dialog: "已添加：\(text)")
    }
}

struct MyAppShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: AddTodoIntent(),
            phrases: [
                "在 \(.applicationName) 里添加待办",
                "用 \(.applicationName) 记一件事"
            ],
            shortTitle: "添加待办",
            systemImageName: "plus.circle"
        )
    }
}

struct TodoEntity: AppEntity {
    let id: UUID
    let title: String

    static let typeDisplayRepresentation: TypeDisplayRepresentation = "待办"
    var displayRepresentation: DisplayRepresentation { .init(title: "\(title)") }

    static let defaultQuery = TodoQuery()
}

struct TodoQuery: EntityQuery {
    func entities(for ids: [UUID]) async throws -> [TodoEntity] {
        await TodoStore.shared.todos(ids: ids).map(TodoEntity.init)
    }
    func suggestedEntities() async throws -> [TodoEntity] {
        await TodoStore.shared.recent().map(TodoEntity.init)
    }
}

let model = try MyImageClassifier(configuration: MLModelConfiguration())
let output = try await model.prediction(image: pixelBuffer)
print(output.classLabel, output.classLabelProbs)

import Vision

// 文字识别（OCR）
let request = RecognizeTextRequest()
let results = try await request.perform(on: image)
for observation in results {
    print(observation.topCandidates(1).first?.string ?? "")
}

import MapKit
import CoreLocation

// 地图（SwiftUI 原生）
Map {
    Marker("公司", coordinate: officeCoordinate)
    Annotation("家", coordinate: homeCoordinate) {
        Image(systemName: "house.fill")
    }
    MapPolyline(coordinates: route)
        .stroke(.blue, lineWidth: 4)
}
.mapStyle(.standard(elevation: .realistic))
.mapControls { MapUserLocationButton(); MapCompass() }

// 定位
let manager = CLLocationManager()
manager.requestWhenInUseAuthorization()

// 搜索地点
let request = MKLocalSearch.Request()
request.naturalLanguageQuery = "咖啡店"
let response = try await MKLocalSearch(request: request).start()

import HealthKit

let store = HKHealthStore()
try await store.requestAuthorization(toShare: [], read: [
    HKQuantityType(.stepCount), HKQuantityType(.heartRate)
])

let descriptor = HKSampleQueryDescriptor(
    predicates: [.quantitySample(type: HKQuantityType(.stepCount))],
    sortDescriptors: [SortDescriptor(\.startDate, order: .reverse)],
    limit: 100
)
let samples = try await descriptor.result(for: store)

import WeatherKit

let weather = try await WeatherService.shared.weather(for: location)
print(weather.currentWeather.temperature)
print(weather.dailyForecast.forecast.first?.highTemperature ?? "")

// 选照片
@State private var item: PhotosPickerItem?
PhotosPicker("选择照片", selection: $item, matching: .images)
    .onChange(of: item) { _, new in
        Task {
            if let data = try? await new?.loadTransferable(type: Data.self) {
                image = UIImage(data: data)
            }
        }
    }

// 播放视频
VideoPlayer(player: AVPlayer(url: videoURL))

// Sign in with Apple
SignInWithAppleButton(.signIn) { request in
    request.requestedScopes = [.fullName, .email]
} onCompletion: { result in
    // 处理结果
}
.signInWithAppleButtonStyle(.black)

// 生物识别
import LocalAuthentication
let context = LAContext()
let ok = try await context.evaluatePolicy(
    .deviceOwnerAuthenticationWithBiometrics,
    localizedReason: "解锁你的笔记"
)

import WidgetKit
import SwiftUI

struct TodoEntry: TimelineEntry {
    let date: Date
    let pendingCount: Int
}

struct TodoProvider: TimelineProvider {
    func placeholder(in context: Context) -> TodoEntry {
        TodoEntry(date: .now, pendingCount: 3)
    }
    func getSnapshot(in context: Context, completion: @escaping (TodoEntry) -> Void) {
        completion(TodoEntry(date: .now, pendingCount: currentCount()))
    }
    func getTimeline(in context: Context, completion: @escaping (Timeline<TodoEntry>) -> Void) {
        let entry = TodoEntry(date: .now, pendingCount: currentCount())
        completion(Timeline(entries: [entry], policy: .after(.now.addingTimeInterval(3600))))
    }
}

struct TodoWidgetView: View {
    let entry: TodoEntry
    var body: some View {
        VStack {
            Text("\(entry.pendingCount)").font(.largeTitle.bold())
            Text("待办").font(.caption)
        }
        .containerBackground(.fill.tertiary, for: .widget)
    }
}

@main
struct TodoWidget: Widget {
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: "TodoWidget", provider: TodoProvider()) { entry in
            TodoWidgetView(entry: entry)
        }
        .configurationDisplayName("待办统计")
        .supportedFamilies([.systemSmall, .systemMedium, .accessoryCircular])
    }
}

struct ToggleTodoIntent: AppIntent {
    static let title: LocalizedStringResource = "切换完成状态"
    @Parameter var todoID: String

    func perform() async throws -> some IntentResult {
        await TodoStore.shared.toggle(id: todoID)
        return .result()
    }
}

// 在小组件视图里
Button(intent: ToggleTodoIntent(todoID: todo.id)) {
    Image(systemName: todo.isDone ? "checkmark.circle.fill" : "circle")
}

import ActivityKit

struct DeliveryAttributes: ActivityAttributes {
    struct ContentState: Codable, Hashable {
        var status: String
        var estimatedMinutes: Int
    }
    let orderNumber: String
}

// 启动
let activity = try Activity.request(
    attributes: DeliveryAttributes(orderNumber: "12345"),
    content: .init(state: .init(status: "配送中", estimatedMinutes: 20), staleDate: nil)
)

// 更新
await activity.update(.init(state: .init(status: "即将送达", estimatedMinutes: 3), staleDate: nil))

// 结束
await activity.end(nil, dismissalPolicy: .immediate)

struct QuickAddControl: ControlWidget {
    var body: some ControlWidgetConfiguration {
        StaticControlConfiguration(kind: "QuickAdd") {
            ControlWidgetButton(action: AddTodoIntent()) {
                Label("快速添加", systemImage: "plus")
            }
        }
    }
}

// 形状
Circle()
RoundedRectangle(cornerRadius: 12)
Capsule()

// 自定义形状
struct Triangle: Shape {
    func path(in rect: CGRect) -> Path {
        var p = Path()
        p.move(to: CGPoint(x: rect.midX, y: rect.minY))
        p.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY))
        p.addLine(to: CGPoint(x: rect.minX, y: rect.maxY))
        p.closeSubpath()
        return p
    }
}

// Canvas —— 命令式高性能绘制（大量图元时用它）
Canvas { context, size in
    for i in 0..<1000 {
        context.fill(Path(ellipseIn: randomRect(in: size)), with: .color(.blue))
    }
}

// 渐变与效果
.background(LinearGradient(colors: [.blue, .purple], startPoint: .top, endPoint: .bottom))
MeshGradient(width: 3, height: 3, points: [...], colors: [...])
.blur(radius: 8)
.visualEffect { content, proxy in
    content.scaleEffect(proxy.frame(in: .global).minY / 1000)
}

// Shaders.metal
[[ stitchable ]] half4 wave(float2 position, half4 color, float time) {
    // ...
}

// SwiftUI
Image("photo")
    .colorEffect(ShaderLibrary.wave(.float(time)))

import RealityKit

struct ImmersiveView: View {
    var body: some View {
        RealityView { content in
            // 加载模型
            if let robot = try? await Entity(named: "Robot") {
                robot.position = [0, 1, -2]
                robot.components.set(InputTargetComponent())
                robot.generateCollisionShapes(recursive: true)
                content.add(robot)
            }

            // 程序化创建
            let sphere = ModelEntity(
                mesh: .generateSphere(radius: 0.1),
                materials: [SimpleMaterial(color: .blue, isMetallic: true)]
            )
            content.add(sphere)
        } update: { content in
            // 状态变化时更新
        }
        .gesture(
            TapGesture().targetedToAnyEntity().onEnded { value in
                value.entity.position.y += 0.1
            }
        )
    }
}

@main
struct SpatialApp: App {
    var body: some Scene {
        // 1. 窗口 —— 平面界面，跟 iPad App 类似
        WindowGroup { ContentView() }

        // 2. 体积 —— 有深度的 3D 盒子，可以在共享空间里跟别的 App 共存
        WindowGroup(id: "volume") {
            ModelView()
        }
        .windowStyle(.volumetric)
        .defaultSize(width: 0.5, height: 0.5, depth: 0.5, in: .meters)

        // 3. 沉浸空间 —— 独占整个环境
        ImmersiveSpace(id: "immersive") {
            ImmersiveView()
        }
        .immersionStyle(selection: $style, in: .mixed, .progressive, .full)
    }
}

#if os(iOS)
    .navigationBarTitleDisplayMode(.inline)
#elseif os(macOS)
    .frame(minWidth: 600, minHeight: 400)
#endif

// 更好的方式：用尺寸类而不是平台判断
@Environment(\.horizontalSizeClass) private var sizeClass
if sizeClass == .compact { VStack { ... } } else { HStack { ... } }

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup { ContentView() }
            .commands {                       // 菜单栏
                CommandGroup(after: .newItem) {
                    Button("导入…") { }.keyboardShortcut("i", modifiers: .command)
                }
            }

        Settings { SettingsView() }           // 偏好设置窗口

        MenuBarExtra("状态", systemImage: "star") {   // 菜单栏常驻
            StatusView()
        }
    }
}

import StoreKit

@MainActor
@Observable
final class Store {
    private(set) var products: [Product] = []
    private(set) var purchasedIDs: Set<String> = []

    private let productIDs = ["com.app.pro.monthly", "com.app.pro.yearly", "com.app.lifetime"]
    private var updateTask: Task<Void, Never>?

    init() {
        updateTask = Task { await observeTransactions() }
    }

    func loadProducts() async {
        products = (try? await Product.products(for: productIDs)) ?? []
    }

    func purchase(_ product: Product) async throws {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await updateEntitlements()
            await transaction.finish()
        case .userCancelled, .pending:
            break
        @unknown default:
            break
        }
    }

    func restore() async throws {
        try await AppStore.sync()
        await updateEntitlements()
    }

    private func updateEntitlements() async {
        var ids: Set<String> = []
        for await result in Transaction.currentEntitlements {
            if let t = try? checkVerified(result) {
                ids.insert(t.productID)
            }
        }
        purchasedIDs = ids
    }

    // 监听在别处发生的交易（家庭共享、退款、续订）
    private func observeTransactions() async {
        for await result in Transaction.updates {
            if let t = try? checkVerified(result) {
                await updateEntitlements()
                await t.finish()
            }
        }
    }

    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .verified(let safe): return safe
        case .unverified: throw StoreError.failedVerification
        }
    }
}

enum StoreError: Error { case failedVerification }

// 订阅页（Apple 提供的标准布局，自动本地化、自动处理购买流程）
SubscriptionStoreView(groupID: "YOUR_GROUP_ID") {
    VStack {
        Image(systemName: "star.circle.fill").font(.system(size: 60))
        Text("升级到 Pro").font(.largeTitle.bold())
    }
}
.storeButton(.visible, for: .restorePurchases)
.subscriptionStorePolicyDestination(url: privacyURL, for: .privacyPolicy)

// 单个商品
ProductView(id: "com.app.lifetime")

// 商品列表
StoreView(ids: productIDs)

import Testing
@testable import MyApp

@Test func 添加待办后数量增加() {
    let store = TodoStore()
    store.add("买牛奶")
    #expect(store.todos.count == 1)
    #expect(store.todos.first?.title == "买牛奶")
}

@Test("空标题应该被拒绝")
func 拒绝空标题() throws {
    let store = TodoStore()
    #expect(throws: ValidationError.self) {
        try store.addValidated("")
    }
}

// 参数化测试：一次跑多组数据
@Test(arguments: [("", false), ("a", true), (String(repeating: "x", count: 200), false)])
func 标题校验(input: String, expected: Bool) {
    #expect(Todo.isValidTitle(input) == expected)
}

// 分组与标签
@Suite("待办存储")
struct TodoStoreTests {
    @Test(.tags(.critical)) func 持久化() async throws { ... }
}

1. App Store Connect 创建 App 记录（Bundle ID 要和 Xcode 里一致）
2. 准备素材：图标、截图（各尺寸）、描述、关键词、隐私标签、年龄分级
3. Xcode: Product → Archive → Distribute App → App Store Connect
4. 在 App Store Connect 里把构建版本分配给 TestFlight
5. TestFlight 内测（内部最多 100 人，外部最多 10000 人，外部需简单审核）
6. 收集反馈、修复、迭代
7. 提交审核（通常 24-48 小时）
8. 通过后手动或自动发布