1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import SwiftUI

struct TabDemo: View {
    @State private var selected = "首页"
    @State private var isExpanded = false

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            HStack {
                ForEach(["首页", "发现", "我的"], id: \.self) { tab in
                    Button(tab) { selected = tab }
                        .fontWeight(selected == tab ? .bold : .regular)
                }
            }
            DisclosureGroup("更多设置", isExpanded: $isExpanded) {
                Text("展开后才显示的内容")
            }
        }
        .padding()
    }
}

// 界面效果：三个按钮中当前选中的加粗；点"更多设置"展开一段文字

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import SwiftUI

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

    var body: some View {
        VStack(spacing: 8) {
            Text("count = \(count)")
            Button("加一") { count += 1 }
            // 每次 body 重算都会新建一个 ResetDemo 结构体，
            // 但 count 挂在视图树上，值还是接着往下数
            Text("这一行的结构体编号：\(UUID().uuidString.prefix(4))")
                .font(.caption)
                .foregroundStyle(.secondary)
        }
    }
}

// 界面效果：点"加一"时 count 递增；
// 但那行小字里的随机编号每次重算都会变——它证明了结构体确实被重建了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import SwiftUI

struct Countdown: View {
    @State private var remaining: Int

    init(start: Int) {
        // 注意是 _remaining，不是 remaining
        _remaining = State(initialValue: start)
    }

    var body: some View {
        Text("剩余 \(remaining)")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import SwiftUI
import Observation

final class PlainCounter {
    var value = 0            // 普通类：改它不会通知 SwiftUI
}

@Observable
final class TrackedCounter {
    var value = 0            // @Observable：改它会通知 SwiftUI
}

struct StoreDemo: View {
    @State private var plain = PlainCounter()
    @State private var tracked = TrackedCounter()

    var body: some View {
        VStack {
            Text("普通类：\(plain.value)")     // 点按钮后这里不会更新
            Text("可观察类：\(tracked.value)") // 点按钮后这里会更新
            Button("都加一") {
                plain.value += 1
                tracked.value += 1
            }
        }
    }
}

// 界面效果：点一次按钮，第二行从 0 变 1；
// 第一行看上去没动——直到其他原因导致 body 重算，才突然显示最新值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import SwiftUI

struct StarRating: View {
    // 借用：不创建、不拥有，只负责读写
    @Binding var rating: Int
    var max = 5

    var body: some View {
        HStack {
            ForEach(1...max, id: \.self) { i in
                Image(systemName: i <= rating ? "star.fill" : "star")
                    .foregroundStyle(.yellow)
                    .onTapGesture { rating = i }
            }
        }
    }
}

struct ReviewForm: View {
    @State private var stars = 0          // 这里才是数据真正的家

    var body: some View {
        VStack(spacing: 12) {
            StarRating(rating: $stars)    // 用 $ 把写权限借出去
            Text(stars == 0 ? "还没打分" : "你打了 \(stars) 分")
        }
        .padding()
    }
}

// 界面效果：点第 3 颗星，五颗星的前三颗变黄，下面文字显示"你打了 3 分"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import SwiftUI
import Observation

@Observable
final class Profile {
    var name = ""
    var age = 0
}

struct ProfileEditor: View {
    @State private var profile = Profile()

    var body: some View {
        Form {
            // 手写 Binding：读 profile.name，写回 profile.name
            TextField("名字", text: Binding(
                get: { profile.name },
                set: { profile.name = $0 }
            ))
            // 同理做一个"只能是偶数"的年龄输入
            TextField("年龄", value: Binding(
                get: { profile.age },
                set: { profile.age = $0 - $0 % 2 }
            ), format: .number)
            Text("当前：\(profile.name.isEmpty ? "匿名" : profile.name)，\(profile.age) 岁")
        }
    }
}

// 界面效果：输入 "Mia" 立刻显示在下方；
// 输入年龄 7，下方显示 6（set 里抹掉了奇数部分）

1
2
3
4
5
6
7
8

import SwiftUI

// 预览里不需要真的保存状态
struct PreviewUsage: View {
    var body: some View {
        StarRating(rating: .constant(3))
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import Foundation
import Observation

@Observable
final class CartModel {
    private(set) var items: [String] = []

    var total: Int { items.count }
    var isEmpty: Bool { items.isEmpty }

    func add(_ item: String) { items.append(item) }
    func removeAll() { items.removeAll() }
}

let cart = CartModel()
cart.add("咖啡")
cart.add("可颂")
print(cart.total, cart.isEmpty)
// prints: 2 false

cart.removeAll()
print(cart.total, cart.isEmpty)
// prints: 0 true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import SwiftUI
import Observation

@Observable
final class CartModel {
    private(set) var items: [String] = []
    var total: Int { items.count }
    func add(_ item: String) { items.append(item) }
}

struct CartBadge: View {
    let cart: CartModel          // 普通 let，不需要任何包装器

    var body: some View {
        // 这个 body 只在 items 变化时重算；
        // 假如 CartModel 还有别的属性，改它们不会连累这里
        Text("\(cart.total) 件")
            .padding(6)
            .background(.tint, in: Capsule())
    }
}

struct ShopView: View {
    @State private var cart = CartModel()   // 拥有者用 @State 保管引用

    var body: some View {
        VStack(spacing: 16) {
            CartBadge(cart: cart)
            Button("加一瓶牛奶") { cart.add("牛奶") }
        }
        .padding()
    }
}

// 界面效果：每次点按钮，徽标上的数字加一

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import Observation

final class Session {          // 没有 @Observable
    var token = ""
}

@Observable
final class AppState {
    var session = Session()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import SwiftUI
import Observation

@Observable
final class Profile {
    var name = ""
    var nickname = ""
}

struct ProfileForm: View {
    @Bindable var profile: Profile        // 注意：这里用 @Bindable 而不是 let

    var body: some View {
        Form {
            TextField("真名", text: $profile.name)   // 可以直接 $ 了
            TextField("昵称", text: $profile.nickname)
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import SwiftUI
import Observation

@Observable
final class Profile { var name = "" }

struct LimitedScope: View {
    var profile: Profile

    var body: some View {
        @Bindable var profile = profile
        TextField("名字", text: $profile.name)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import SwiftUI
import Observation

@Observable
final class ShoppingCart {
    var items: [String] = []
}

@main
struct ShopApp: App {
    @State private var cart = ShoppingCart()

    var body: some Scene {
        WindowGroup {
            ShopRoot()
                .environment(cart)          // 注入：往下一整棵树都能拿到
        }
    }
}

struct ShopRoot: View {
    var body: some View {
        NavigationStack {
            DetailView()                    // 中间不需要任何传递
        }
    }
}

struct DetailView: View {
    @Environment(ShoppingCart.self) private var cart   // 取出
    @Environment(\.dismiss) private var dismiss        // 系统提供的动作

    var body: some View {
        VStack {
            Button("加入购物车") { cart.items.append("商品") }
            Button("返回") { dismiss() }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import SwiftUI

extension EnvironmentValues {
    @Entry var brandTint: Color = .blue
}

struct BrandedCard: View {
    @Environment(\.brandTint) private var tint

    var body: some View {
        Text("品牌色卡片")
            .padding()
            .overlay(RoundedRectangle(cornerRadius: 12).stroke(tint))
    }
}

struct BrandedPage: View {
    var body: some View {
        BrandedCard()
            .environment(\.brandTint, .orange)   // 只影响这棵子树
    }
}

// 界面效果：卡片的描边用橙色；把这个 .environment 去掉就变回蓝色

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import SwiftUI

final class OldModel: ObservableObject {
    @Published var count = 0
}

struct OldView: View {
    @StateObject private var model = OldModel()   // 拥有
    @ObservedObject var other: OldModel           // 借用
    @EnvironmentObject var shared: OldModel       // 从环境取

    var body: some View {
        Text("\(model.count) \(other.count) \(shared.count)")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import SwiftUI

struct Row: View {
    let title: String
    let onDelete: () -> Void        // 事件向上走：闭包

    var body: some View {
        HStack {
            Text(title)             // 数据向下流：参数
            Spacer()
            Button("删除", action: onDelete)
        }
    }
}

struct ParentView: View {
    @State private var rows = ["草稿", "已发布"]

    var body: some View {
        List(rows.indices, id: \.self) { i in
            Row(title: rows[i]) { rows.remove(at: i) }
        }
    }
}

// 界面效果：每行一个标题加一个删除按钮，点删除该行消失