如何使用元类型在 SwiftUI 中显示视图？

为了显示视图，您只需使用符合的枚举即可:View。

在主视图中，创建该枚举的一个实例，并使用按钮将其值设置为枚举中可用的任何情况。

这是一个有效的例子：

import SwiftUI

enum ViewPresenter: View {
    case view1, view2, view3, view4
    
    var body: some View {
        switch self {
            case .view1:
                View1()
            case .view2:
                View2()
            case .view3:
                View3()
            case .view4:
                View4()
        }
    }
}

struct ShowViewsDemo: View {
    @State var presentView: ViewPresenter?

    var body: some View {
        VStack {
            if presentView != nil {
                //Show selected view
                presentView
                    .foregroundStyle(.white)
                
                    //Close button as overlay
                    .overlay(alignment: .topTrailing) {
                        Button {
                            presentView = nil
                        } label: {
                            Image(systemName: "xmark.circle.fill")
                                .font(.title2)
                        }
                        .padding(.horizontal)
                        .tint(.white)
                    }
            }
            else {
                //Show placeholder
                ContentUnavailableView {
                    Label("No view selected", systemImage: "eye")
                } description: {
                    Text("Tap any of the buttons to select and show a view.")
                }
            }
            
            Spacer() // push buttons to the bottom
            
            //Buttons
            HStack {
                Button ("View1") {
                    presentView = .view1
                }
                Button ("View2") {
                    presentView = .view2
                }
                Button ("View3") {
                    presentView = .view3
                }
                Button ("View4") {
                    presentView = .view4
                }
            }
            .padding()
            .buttonStyle(.bordered)
        }
        .animation(.smooth, value: presentView)
    }
}

struct View1: View {
    
    var body: some View {
        
        VStack {
            Text("View 1")
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.green)
    }
}

struct View2: View {
    
    var body: some View {
        
        VStack {
            Text("View 2")

        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.orange)
    }
}

struct View3: View {
    
    var body: some View {
        
        VStack {
            Text("View 3")
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.blue)
    }
}

struct View4: View {
    
    var body: some View {
        
        VStack {
            Text("View 4")
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.pink)
    }
}

#Preview {
    ShowViewsDemo()
}

这在 SwiftUI 中并不常见。如果您只是想减少混乱，我建议使用switch和一个enum值来表示每个视图。

enum ShowableView {
    case one, two, three, four
}

@State private var shownView: ShowableView?

var body: some View {
    switch shownView {
    case .one: View1()
    case .two: View2()
    case .three: View3()
    case .four: View4()
    case nil:
        VStack {
            Button("Show View1") {
                shownView = .one
            }
            Button("Show View2") {
                shownView = .two
            }
            Button("Show View3") {
                shownView = .three
            }
            Button("Show View4") {
                shownView = .four
            }
        }
    }
}

如果您甚至想删除case标签，您可以编写一个基于Int索引显示特定视图的视图，但我认为这比使用枚举的编写方式更糟糕switch。

struct ViewSelector<Content: View>: View {
    @Binding var selection: Int?
    let content: Content
    
    init(selection: Binding<Int?>, @ViewBuilder content: () -> Content) {
        self._selection = selection
        self.content = content()
    }
    
    var body: some View {
        Group(subviews: content) { subviews in
            if let selection {
                subviews[selection]
            }
        }
    }
}

struct ContentView: View {
    @State private var shownView: Int?
    
    var body: some View {
        if shownView == nil {
            ViewSelector(selection: $shownView) {
                View1()
                View2()
                View3()
                View4()
            }
        } else {
            VStack {
                Button("Show View1") {
                    shownView = 0
                }
                Button("Show View2") {
                    shownView = 1
                }
                Button("Show View3") {
                    shownView = 2
                }
                Button("Show View4") {
                    shownView = 3
                }
            }
        }
    }
}

如果您确实想要存储元类型，则需要使用AnyView，这可能会有问题。此方法仅适用于具有无参数初始化程序的视图类型，与使用switch甚至ViewSelector上述方法相比，这极大​​地限制了它的实用性。

首先将无参数初始化要求编码到协议中，

protocol DirectlyInitializableView: View {
    init()
}

extension DirectlyInitializableView {
    static func make() -> AnyView { AnyView(Self()) }
}

然后您可以存储一个(any DirectlyInitializableView.Type)?。

@State private var shownView: (any DirectlyInitializableView.Type)?

var body: some View {
    if let shownView {
        shownView.make()
    } else {
        VStack {
            // assuming these views all conform to DirectlyInitializableView
            Button ("Show View1") {
                shownView = View1.self
            }
            Button ("Show View2") {
                shownView = View2.self
            }
            Button ("Show View3") {
                shownView = View3.self
            }
            Button ("Show View4") {
                shownView = View4.self
            }
        }
    }
}

除了接受答案中的枚举之外，您还可以使用类似以下内容：

struct ContentView: View {
    @State private var shownView: (any View)?

    var body: some View {
        if let shownView {
            AnyView(shownView)
        } else {
            VStack {
                Button("Show View1") {
                    shownView = View1()
                }
                Button("Show View2") {
                    shownView = View2()
                }
                Button("Show View3") {
                    shownView = View3()
                }
                Button("Show View4") {
                    shownView = View4()
                }
            }
        }
    }
}

但枚举仍然是首选。