自定义UIScrollView偏移设置及LazyHStack/LazyHGrid懒加载失效求助

问题本质 #

你用的基于UIScrollView封装的自定义组件之所以会让LazyHStack/LazyHGrid懒加载失效，核心原因是这类封装通常会强制计算完整的contentSize，逼着SwiftUI提前渲染所有内容，直接破坏了懒加载的按需加载逻辑。

可行解决方案 #

方案1：原生ScrollView + ScrollViewReader 实现偏移控制（推荐） #

通过ScrollViewReader配合偏移量绑定，既能精确控制滚动位置，又能完整保留懒加载特性：

struct OffsetControlledScrollView<Content: View>: View {
    @Binding var contentOffset: CGPoint
    let axes: Axis.Set
    let showsIndicators: Bool
    let content: () -> Content
    
    init(axes: Axis.Set = .vertical, showsIndicators: Bool = true, contentOffset: Binding<CGPoint>, @ViewBuilder content: @escaping () -> Content) {
        self.axes = axes
        self.showsIndicators = showsIndicators
        self._contentOffset = contentOffset
        self.content = content
    }
    
    var body: some View {
        ScrollView(axes, showsIndicators: showsIndicators) {
            ScrollViewReader { proxy in
                content()
                    .background(
                        GeometryReader { geo in
                            Color.clear
                                .preference(key: ContentSizeKey.self, value: geo.size)
                        }
                    )
                    .onPreferenceChange(ContentSizeKey.self) { size in
                        // 限制偏移量在有效范围内，避免越界
                        let maxX = max(0, size.width - UIScreen.main.bounds.width)
                        let maxY = max(0, size.height - UIScreen.main.bounds.height)
                        contentOffset = CGPoint(
                            x: min(maxX, max(0, contentOffset.x)),
                            y: min(maxY, max(0, contentOffset.y))
                        )
                    }
                    .onChange(of: contentOffset) { newValue in
                        // 通过锚点换算实现精准偏移
                        let anchor = UnitPoint(
                            x: -newValue.x / UIScreen.main.bounds.width,
                            y: -newValue.y / UIScreen.main.bounds.height
                        )
                        proxy.scrollTo(0, anchor: anchor) // 确保第一个元素id为0，可按需调整
                    }
            }
        }
    }
}

private struct ContentSizeKey: PreferenceKey {
    static var defaultValue: CGSize = .zero
    static func reduce(value: inout CGSize, nextValue: () -> CGSize) {
        value = nextValue()
    }
}

使用示例：

struct TestView: View {
    @State private var offset = CGPoint.zero
    
    var body: some View {
        OffsetControlledScrollView(contentOffset: $offset, axes: .horizontal) {
            LazyHStack {
                ForEach(0..<1000) { index in
                    Text("Item \(index)")
                        .frame(width: 100, height: 100)
                        .id(index) // 必须给每个懒加载元素设置唯一id
                }
            }
        }
        .toolbar {
            Button("滚动到X:500") {
                offset.x = 500
            }
        }
    }
}

方案2：修复你用的自定义UIScrollView封装 #

针对你使用的自定义组件，需要调整实现逻辑，避免强制计算contentSize：

1. 删掉手动设置contentSize的代码，交给SwiftUI自动管理
2. 给UIScrollView设置代理，通过scrollViewDidScroll同步偏移量到绑定值
3. 用Auto Layout约束托管SwiftUI内容，不要硬写尺寸
4. 仅当绑定的偏移量和scrollView实际偏移不一致时才更新，避免循环触发

修改后的核心代码片段：

struct CustomScrollView<Content: View>: UIViewRepresentable {
    @Binding var contentOffset: CGPoint
    let content: Content
    
    func makeUIView(context: Context) -> UIScrollView {
        let scrollView = UIScrollView()
        scrollView.delegate = context.coordinator
        
        let hostingController = UIHostingController(rootView: content)
        hostingController.view.translatesAutoresizingMaskIntoConstraints = false
        scrollView.addSubview(hostingController.view)
        
        // 横向滚动时移除widthAnchor约束，让LazyHStack自己控制宽度
        NSLayoutConstraint.activate([
            hostingController.view.topAnchor.constraint(equalTo: scrollView.topAnchor),
            hostingController.view.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor),
            hostingController.view.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor),
            hostingController.view.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor)
        ])
        
        return scrollView
    }
    
    func updateUIView(_ uiView: UIScrollView, context: Context) {
        if uiView.contentOffset != contentOffset {
            uiView.setContentOffset(contentOffset, animated: false)
        }
    }
    
    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
    
    class Coordinator: NSObject, UIScrollViewDelegate {
        var parent: CustomScrollView
        
        init(_ parent: CustomScrollView) {
            self.parent = parent
        }
        
        func scrollViewDidScroll(_ scrollView: UIScrollView) {
            parent.contentOffset = scrollView.contentOffset
        }
    }
}

关键注意事项 #

• 懒加载生效的前提是SwiftUI能按需计算可见区域内容，任何强制渲染全部内容的操作都会废掉懒加载
• 用ScrollViewReader时，必须给每个懒加载元素设置唯一id，否则无法精准定位
• 自定义UIScrollView封装时，绝对不要手动设置contentSize，让Auto Layout自动处理内容尺寸

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