带@Binding与无@Binding的初始化：如何控制SwiftUI的@State？

问题描述 #

我需要实现一个类似SwiftUI原生TabView的自定义组件，要求支持两种使用场景：

1. 传入@Binding类型的selection参数，由外部控制选中项：

@State var selection = 0
...
var body: some View {
  CustomTabView(selection: $selection) { .... }
}

2. 不传入绑定参数，由组件内部自行维护选中状态：

var body: some View {
  CustomTabView { ... }
}

参考SwiftUI原生TabView的实现，它通过两个不同的初始化方法来实现该功能：

public init<C>(selection: Binding<SelectionValue>, @TabContentBuilder<SelectionValue> content: () -> C) where Content == TabContentBuilder<SelectionValue>.Content<C>, C : TabContent

....

public init<C>(@TabContentBuilder<Never> content: () -> C) where SelectionValue == Never, Content == TabContentBuilder<Never>.Content<C>, C : TabContent

我想照搬这个思路，但不清楚在不带@Binding的初始化方法中，如何正确初始化和控制@State类型的_selectedTab变量。目前我的组件代码框架如下：

struct CustomTabView: View {
    init(@CustomTabBuilder tabs: () -> [CustomTab]) {
        self._selectedTab = // ??????
        self.tabs = tabs()
    }
    
    init(selection: Binding<Int>, @CustomTabBuilder tabs: () -> [CustomTab]) {
        self._selectedTab = selection
        self.tabs = tabs()
    }
}

解决方案 #

要对齐SwiftUI的实现逻辑，你需要通过泛型关联类型区分外部绑定与内部状态的场景，同时正确处理@State和Binding的初始化逻辑：

1. 定义泛型组件结构 #

给CustomTabView添加SelectionValue泛型关联类型，用来适配外部绑定类型或内部状态的Never类型（对应无外部控制的场景）：

struct CustomTabView<SelectionValue: Hashable>: View {
    // 统一用Binding类型处理选中状态，不管是内部还是外部管理
    private let selectedTab: Binding<SelectionValue>
    private let tabs: [CustomTab]
    
    // 仅在内部管理状态时使用的私有State变量
    @State private var internalSelection: Int = 0

2. 实现两种初始化方法 #

（1）内部管理状态的初始化（无Binding参数）

当用户不传入selection时，将SelectionValue约束为Never（表示外部无法访问或控制选中状态），同时把内部@State变量包装成Binding赋值给selectedTab：

init(@CustomTabBuilder tabs: () -> [CustomTab]) where SelectionValue == Never {
    self.tabs = tabs()
    // 将内部State包装为Binding，仅组件内部可访问
    self.selectedTab = Binding(
        get: { fatalError("内部状态无法外部访问") },
        set: { self.internalSelection = $0 as! Int }
    )
}

（2）外部管理状态的初始化（带Binding参数）

当用户传入selection时，直接将外部Binding赋值给selectedTab：

init(selection: Binding<SelectionValue>, @CustomTabBuilder tabs: () -> [CustomTab]) {
    self.tabs = tabs()
    self.selectedTab = selection
}

3. 视图渲染逻辑 #

在body中统一处理选中状态，内部管理场景下直接操作internalSelection即可：

var body: some View {
    VStack {
        // Tab切换栏
        HStack {
            ForEach(tabs.indices, id: \.self) { index in
                Button(action: {
                    if SelectionValue.self == Never.self {
                        internalSelection = index
                    } else {
                        selectedTab.wrappedValue = index as! SelectionValue
                    }
                }) {
                    tabs[index].label
                        .foregroundColor(
                            (SelectionValue.self == Never.self ? internalSelection == index : selectedTab.wrappedValue == index as! SelectionValue)
                            ? .blue : .gray
                        )
                }
            }
        }
        // 内容展示区域
        if SelectionValue.self == Never.self {
            tabs[internalSelection].content
        } else {
            tabs[selectedTab.wrappedValue as! Int].content
        }
    }
}

4. 配套的CustomTab与CustomTabBuilder #

为了让组件完整可用，实现对应的Tab模型和视图构建器：

// 自定义Tab的数据模型
struct CustomTab {
    let label: AnyView
    let content: AnyView
    
    init<Label: View, Content: View>(label: Label, content: Content) {
        self.label = AnyView(label)
        self.content = AnyView(content)
    }
}

// 自定义Tab的结果构建器
@resultBuilder
enum CustomTabBuilder {
    static func buildBlock(_ tabs: CustomTab...) -> [CustomTab] {
        tabs
    }
}

关键说明 #

• 用SelectionValue泛型区分两种模式：无外部selection时，SelectionValue自动推断为Never，此时选中状态完全由组件内部的@State变量管理，外部无法访问；传入selection时，泛型匹配外部绑定的类型（如Int），选中状态由外部控制。
• 统一用Binding类型封装选中状态，让视图渲染逻辑无需区分内部/外部管理场景，简化代码。
• 在Never模式下，selectedTab的get方法抛出错误，防止外部非法访问内部状态，对齐SwiftUI的设计逻辑。

内容的提问来源于stack exchange，提问作者Lupurus