SwiftUI自定义@resultBuilder如何拆解ForEach内容获取子视图数组

方案1：扩展ViewArrayBuilder适配ForEach（解决当前报错问题） #

你遇到的报错是因为直接用RandomAccessCollection协议作为ForEach的泛型参数，Swift不允许将协议本身作为符合协议的类型传入泛型约束。可以通过添加泛型重载的方式专门处理ForEach类型，同时补全resultBuilder必要的方法支持更多场景：

@resultBuilder public struct ViewArrayBuilder {
    // 空内容支持
    public static func buildBlock() -> [AnyView] {
        []
    }
    
    // 单个普通视图支持
    public static func buildBlock<Content: View>(_ content: Content) -> [AnyView] {
        [AnyView(content)]
    }
    
    // 多个视图支持
    public static func buildBlock<each Content: View>(_ content: repeat each Content) -> [AnyView] {
        var views = [AnyView]()
        repeat views.append(AnyView(each content))
        return views
    }
    
    // ForEach专门重载，自动展开子视图
    public static func buildBlock<Data: RandomAccessCollection, ID: Hashable, Content: View>(_ content: ForEach<Data, ID, Content>) -> [AnyView] {
        content.data.map { AnyView(content.content($0)) }
    }
    
    // 可选视图支持
    public static func buildIf<Content: View>(_ content: Content?) -> [AnyView] {
        content.map { [AnyView($0)] } ?? []
    }
    
    // 条件分支支持
    public static func buildEither<First: View, Second: View>(first: First) -> [AnyView] {
        [AnyView(first)]
    }
    
    public static func buildEither<First: View, Second: View>(second: Second) -> [AnyView] {
        [AnyView(second)]
    }
}

该方案会自动识别传入的ForEach，直接把它内部的子视图展开后加入数组，其他普通视图保持原有逻辑。如果后续需要支持Group等其他容器视图，按照相同的逻辑添加对应的泛型重载即可。

方案2：使用iOS 16+ Layout协议实现换行HStack（更稳定的推荐方案） #

不需要手动处理resultBuilder和视图拆解，系统原生的Layout协议会自动帮你拿到所有展开的子视图（包括ForEach、Group内部的内容），直接实现流式布局即可，适配性和性能都更好：

struct WrappingHStack: Layout {
    var alignment: Alignment = .topLeading
    var horizontalSpacing: CGFloat = 8
    var verticalSpacing: CGFloat = 8
    var maxRows: Int = .max
    
    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        let rows = arrangeSubviews(proposalWidth: proposal.width ?? .infinity, subviews: subviews)
        guard !rows.isEmpty else { return .zero }
        
        var height: CGFloat = 0
        for (index, row) in rows.enumerated() {
            if index >= maxRows { break }
            height += row.height
            if index > 0 { height += verticalSpacing }
        }
        return CGSize(width: proposal.width ?? 0, height: height)
    }
    
    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let rows = arrangeSubviews(proposalWidth: bounds.width, subviews: subviews)
        var yOffset = bounds.minY
        
        for (rowIndex, row) in rows.enumerated() {
            if rowIndex >= maxRows { break }
            var xOffset = bounds.minX
            
            for element in row.elements {
                let position = CGPoint(
                    x: xOffset + alignment.horizontal * (row.width - element.size.width),
                    y: yOffset + alignment.vertical * (row.height - element.size.height)
                )
                element.subview.place(at: position, proposal: ProposedViewSize(element.size))
                xOffset += element.size.width + horizontalSpacing
            }
            yOffset += row.height + verticalSpacing
        }
    }
    
    private func arrangeSubviews(proposalWidth: CGFloat, subviews: Subviews) -> [Row] {
        var rows: [Row] = []
        var currentRow = Row()
        
        for subview in subviews {
            let size = subview.sizeThatFits(.unspecified)
            if currentRow.width + size.width + horizontalSpacing > proposalWidth, !currentRow.elements.isEmpty {
                rows.append(currentRow)
                currentRow = Row()
            }
            currentRow.elements.append((subview, size))
            currentRow.width += size.width + (currentRow.elements.count > 1 ? horizontalSpacing : 0)
            currentRow.height = max(currentRow.height, size.height)
        }
        
        if !currentRow.elements.isEmpty {
            rows.append(currentRow)
        }
        return rows
    }
    
    private struct Row {
        var elements: [(subview: LayoutSubview, size: CGSize)] = []
        var width: CGFloat = 0
        var height: CGFloat = 0
    }
}

使用方式和原生SwiftUI容器完全一致，自动支持ForEach、条件判断、Group等所有原生语法：

WrappingHStack(maxRows: 2, horizontalSpacing: 8, verticalSpacing: 8) {
    ForEach(0..<10) { index in
        Text("标签\(index)")
            .padding(.horizontal, 12)
            .padding(.vertical, 6)
            .background(Color.blue.opacity(0.1))
            .cornerRadius(8)
    }
    Text("自定义长度的长标签")
    if true {
        Text("条件视图")
    }
}
.padding()

该方案完全满足不等宽子视图的文本流式换行需求，不需要额外处理任何容器视图的拆解逻辑。

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