视图传递

使用初始化器传递数据

struct ContentView: View {
    var body: some View {
        NavigationView {
            NavigationLink(destination: DetailView(text: "来自 ContentView 的您好")) {
                Text("转到详细视图")
            }
        }
    }
}

struct DetailView: View {
    let text: String
    var body: some View {
        Text(text)
    }
}

直接传递一个视图

struct ContainerView<Content: View>: View {
    @ViewBuilder let content: Content
    var body: some View {
        content
    }
}

struct IfElseView: View {
    var flag = true
    var body: some View {
        ContainerView {
            if flag {
                Text("True text")
            } else {
                Text("False text")
            }
        }
    }
}

struct TemplateView: View {
    // 我们声明一个常量，用于存储
    // 主视图传递的视图
    // 该常量的类型是 AnyView
    let subView: AnyView
    var body: some View {
        VStack {
            // 显示已通过的视图
            subView()
            /* 一些内容在这里 */
        }
    }
}

struct ContentView: View {
    var body: some View {
        VStack {
            // 调用 TemplateView 并传递子视图 SomeSubview
            TemplateView(subView: SomeSubview())
        }
    }
}

多个视图传递

struct ContentView: View {
    var body: some View {
        CustomTupleView {
            Text("First").foregroundColor(.red)
            Text("Second").foregroundColor(.green)
            Text("Third").foregroundColor(.blue)
        }
    }
}

fileprivate extension ContentView {
    // 自定义元组视图，接受三个视图作为参数
    struct CustomTupleView<First: View, Second: View, Third: View>: View {
        let first: First    // 第一个视图
        let second: Second  // 第二个视图
        let third: Third    // 第三个视图
        init(@ViewBuilder content: () -> TupleView<(First, Second, Third)>) {
            // 使用 ViewBuilder 构建元组视图
            let views = content().value
            // 分别取出元组中的三个视图
            first = views.0
            second = views.1
            third = views.2
        }
        
        var body: some View {
            VStack {
                first
                Divider().frame(width: 44).padding()
                second
                Divider().frame(width: 44).padding()
                third
            }
        }
    }
}

使用环境变量

// 定义一个环境键，用于传递数据
struct MyEnvironmentKey: EnvironmentKey {
    static let defaultValue: String = "Default Value"
}

// 定义环境变量的扩展方便访问
extension EnvironmentValues {
    var myEnvironmentValue: String {
        get { self[MyEnvironmentKey.self] }
        set { self[MyEnvironmentKey.self] = newValue }
    }
}

struct ContentView: View {
    @Environment(\.myEnvironmentValue) var myValue
    var body: some View {
        VStack {
            Text(myValue) // 使用环境变量
            DetailView()
        }
        .environment(\.myEnvironmentValue, "Hello from Environment!") // 设置环境变量
    }
}

struct DetailView: View {
    @Environment(\.myEnvironmentValue) var myValue
    var body: some View {
        Text(myValue) // 使用环境变量
    }
}

在这个示例中，myEnvironmentValue 作为环境变量传递给所有
DetailView 中有权访问这个环境变量。 ContentView 的子视图。

使用 ObservableObject 传递对象

class SharedData: ObservableObject {
    @Published var text: String = "Hello from Shared Data"
}

struct ContentView: View {
    @StateObject var sharedData = SharedData()
    var body: some View {
        DetailView(sharedData: sharedData)
    }
}

struct DetailView: View {
    @ObservedObject var sharedData: SharedData
    var body: some View {
        Text(sharedData.text)
    }
}

在这里， SharedData 是一个可以被观察的对象类，含有一个 @Published 属性 text。它被创建为 ContentView 的 @StateObject，然后作为一个引用传递给 DetailView，DetailView
使用 @ObservedObject 来观察它。