内容App如何用SwiftUI实现表单校验与提交按钮状态联动?

发布人:A5数据发布时间:2026-11-17 11:07阅读量:3

要让内容App里的提交按钮真正“跟着表单状态走”,关键不是在按钮点击事件中临时判断几个字符串,而是把标题、摘要、正文等输入统一放进可观察状态,再由校验结果计算出按钮是否可用。这样用户输入、删除内容、提交请求和网络失败都会经过同一套状态链路,页面不会出现“看起来可以提交,点击后才发现无效”的情况。

下面采用 SwiftUI 的 ObservableObject、@Published、Form 和 async/await 完成一个内容发布表单。示例按 Swift 5.9、iOS 17+ 编写,核心状态管理方式同样适用于 iOS 16;如果项目部署版本较低,需要根据项目环境调整 onChange 的闭包写法。示例规则为:标题必填且长度为 5~80 个字符,摘要可选但不超过 160 个字符,正文必填且长度为 20~10,000 个字符。实际项目应以服务端接口的限制为准。

先把表单规则变成可计算状态

表单校验通常包含两类规则:

  • 本地即可完成的格式校验,例如是否为空、长度是否超限、首尾是否只有空白字符。
  • 必须请求服务端才能确认的业务校验,例如标题是否重复、当前账号是否有发布权限、内容是否通过审核。

提交按钮只需要依赖第一类规则和当前请求状态。服务端校验则放在点击提交之后处理,不能把网络请求结果提前当成本地表单状态。

示例中的字段规则如下:

字段本地规则是否必填发送到接口前的处理
标题去除首尾空白后,长度为 5~80 个字符是去除首尾空白
摘要去除首尾空白后,不超过 160 个字符否空字符串转换为 nil
正文去除首尾空白后,长度为 20~10,000 个字符是去除首尾空白
分类必须是页面提供的枚举值是发送枚举的接口值

这里使用 String.count 计算字符数量,它按照用户可见字符的语义处理,适合大多数中文内容表单。如果后端限制的是 UTF-8 字节数,就不能直接使用 count,而应额外判断:

let byteCount = value.data(using: .utf8)?.count ?? 0

不要在多个地方分别维护一个 isValid 布尔变量。例如输入标题后更新一次,删除标题后忘记更新,就会导致按钮状态滞后。更稳妥的方式是让 isFormValid 成为基于当前输入的计算属性,任何 @Published 字段变化后,SwiftUI 都会重新计算它。

定义内容数据和提交接口

先把分类、接口请求体和网络提交协议独立出来。视图只负责展示和绑定,具体的请求细节由提交器处理,后续接入已有网络层时不需要修改表单布局。

import Foundation
import SwiftUI

enum ContentCategory: String, CaseIterable, Identifiable {
    case article
    case tutorial
    case news

    var id: String {
        rawValue
    }

    var title: String {
        switch self {
        case .article:
            return "文章"
        case .tutorial:
            return "教程"
        case .news:
            return "资讯"
        }
    }
}

struct ContentPayload: Encodable {
    let title: String
    let summary: String?
    let body: String
    let category: String
}

struct CreateContentResponse: Decodable {
    let id: UUID
}

enum ContentSubmitError: LocalizedError {
    case invalidResponse
    case server(statusCode: Int)

    var errorDescription: String? {
        switch self {
        case .invalidResponse:
            return "服务器响应格式不正确"
        case .server(let statusCode):
            return "服务器返回错误,状态码:\(statusCode)"
        }
    }
}

protocol ContentSubmitting {
    func create(_ payload: ContentPayload) async throws -> UUID
}

struct URLSessionContentSubmitter: ContentSubmitting {
    let endpoint: URL

    func create(_ payload: ContentPayload) async throws -> UUID {
        var request = URLRequest(url: endpoint)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(payload)

        let (data, response) = try await URLSession.shared.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse else {
            throw ContentSubmitError.invalidResponse
        }

        guard (200...299).contains(httpResponse.statusCode) else {
            throw ContentSubmitError.server(
                statusCode: httpResponse.statusCode
            )
        }

        return try JSONDecoder()
            .decode(CreateContentResponse.self, from: data)
            .id
    }
}

接口返回体这里假设为:

{
  "id": "A UUID string"
}

如果现有接口返回的是整数 ID、字符串 ID,或者返回体外层还有 data 字段,只需要调整 CreateContentResponse 的结构,不要把解析逻辑直接写进 SwiftUI 的 Button 闭包中。

实际项目通常还需要在请求中加入认证信息,例如:

request.setValue(
    "Bearer \(accessToken)",
    forHTTPHeaderField: "Authorization"
)

令牌应由账号会话或网络层统一管理,表单视图不应保存固定密钥,也不应把认证信息写死在页面代码中。

在 ViewModel 中集中管理校验和提交状态

下面的 ViewModel 同时管理三类状态:

  1. 用户输入的字段值。
  2. 由字段值计算出的校验结果。
  3. 提交请求的进行中、成功和失败状态。

@MainActor 保证这些界面状态在主线程上读写。网络请求本身仍然可以异步等待,等待期间不会阻塞界面。

@MainActor
final class ContentFormViewModel: ObservableObject {
    @Published var title = ""
    @Published var summary = ""
    @Published var body = ""
    @Published var category: ContentCategory = .article

    @Published private(set) var isSubmitting = false
    @Published private(set) var didSubmitSuccessfully = false
    @Published var showValidation = false
    @Published var submitMessage: String?

    private let submitter: any ContentSubmitting

    init(submitter: any ContentSubmitting) {
        self.submitter = submitter
    }

    private var normalizedTitle: String {
        normalize(title)
    }

    private var normalizedSummary: String? {
        let value = normalize(summary)
        return value.isEmpty ? nil : value
    }

    private var normalizedBody: String {
        normalize(body)
    }

    var titleError: String? {
        let value = normalizedTitle

        if value.isEmpty {
            return "请输入标题"
        }

        if value.count < 5 {
            return "标题至少需要 5 个字符"
        }

        if value.count > 80 {
            return "标题不能超过 80 个字符"
        }

        return nil
    }

    var summaryError: String? {
        let value = normalize(summary)

        if value.count > 160 {
            return "摘要不能超过 160 个字符"
        }

        return nil
    }

    var bodyError: String? {
        let value = normalizedBody

        if value.isEmpty {
            return "请输入正文"
        }

        if value.count < 20 {
            return "正文至少需要 20 个字符"
        }

        if value.count > 10_000 {
            return "正文不能超过 10,000 个字符"
        }

        return nil
    }

    var isFormValid: Bool {
        titleError == nil &&
        summaryError == nil &&
        bodyError == nil
    }

    var canSubmit: Bool {
        isFormValid &&
        !isSubmitting &&
        !didSubmitSuccessfully
    }

    func submit() async {
        showValidation = true

        guard isFormValid,
              !isSubmitting,
              !didSubmitSuccessfully else {
            return
        }

        isSubmitting = true
        submitMessage = nil

        defer {
            isSubmitting = false
        }

        let payload = ContentPayload(
            title: normalizedTitle,
            summary: normalizedSummary,
            body: normalizedBody,
            category: category.rawValue
        )

        do {
            let contentID = try await submitter.create(payload)
            didSubmitSuccessfully = true
            submitMessage = "提交成功,内容编号:\(contentID.uuidString)"
        } catch is CancellationError {
            // 页面离开或任务被取消时,不把取消显示成普通错误
        } catch let error as URLError where error.code == .cancelled {
            // URLSession 取消请求时的另一种常见表现
        } catch {
            submitMessage = "提交失败:\(error.localizedDescription)"
        }
    }

    func clearSubmitMessage() {
        submitMessage = nil
        didSubmitSuccessfully = false
    }

    private func normalize(_ value: String) -> String {
        value.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

这里没有把错误字符串单独保存为 @Published。例如标题从 4 个字符变成 5 个字符时,titleError 会根据新值重新计算,isFormValid 也会随之变化,按钮状态会自动更新。

为什么需要区分 isFormValid 和 canSubmit

isFormValid 只表示本地输入是否符合规则,而 canSubmit 还要考虑请求是否正在进行,以及当前内容是否已经提交成功。

可以把几个典型状态理解为:

为什么需要区分 isFormValid 和 canSubmit配图

表单状态isFormValidisSubmittingdidSubmitSuccessfully按钮表现
初始为空falsefalsefalse禁用
输入不完整falsefalsefalse禁用
输入完整truefalsefalse可点击
请求发送中truetruefalse禁用并显示进度
服务端失败true 或 falsefalsefalse根据当前输入重新决定
提交成功truefalsetrue显示已提交,避免重复发送

如果发布成功后页面会立即返回列表页,也可以不保留 didSubmitSuccessfully,而是在成功回调中执行导航。当前示例保留这个状态,是为了避免用户连续点击或在成功后重复创建相同内容。

将字段绑定到 SwiftUI 页面

接下来把 ViewModel 绑定到 Form。字段直接使用 $viewModel.title、$viewModel.summary 和 $viewModel.body,不要在视图中再维护一份同名的 @State,否则容易出现输入框显示值和校验值不是同一份数据的问题。

将字段绑定到 SwiftUI 页面配图

struct ContentEditorView: View {
    @StateObject private var viewModel: ContentFormViewModel

    @State private var titleTouched = false
    @State private var summaryTouched = false
    @State private var bodyTouched = false

    @FocusState private var focusedField: Field?

    private enum Field: Hashable {
        case title
        case summary
        case body
    }

    init(submitter: any ContentSubmitting) {
        _viewModel = StateObject(
            wrappedValue: ContentFormViewModel(submitter: submitter)
        )
    }

    var body: some View {
        NavigationStack {
            Form {
                Section {
                    TextField("标题(必填)", text: $viewModel.title)
                        .focused($focusedField, equals: .title)
                        .submitLabel(.next)
                        .onSubmit {
                            focusedField = .summary
                        }
                        .onChange(of: viewModel.title) { _, _ in
                            titleTouched = true
                            viewModel.clearSubmitMessage()
                        }

                    if (titleTouched || viewModel.showValidation),
                       let error = viewModel.titleError {
                        Text(error)
                            .font(.footnote)
                            .foregroundStyle(.red)
                    }

                    HStack {
                        Text("标题长度")
                            .foregroundStyle(.secondary)

                        Spacer()

                        Text("\(viewModel.title.count)/80")
                            .foregroundStyle(.secondary)
                    }
                    .font(.footnote)

                    Picker("分类", selection: $viewModel.category) {
                        ForEach(ContentCategory.allCases) { category in
                            Text(category.title)
                                .tag(category)
                        }
                    }

                    TextField("摘要(可选)", text: $viewModel.summary)
                        .focused($focusedField, equals: .summary)
                        .submitLabel(.next)
                        .onSubmit {
                            focusedField = .body
                        }
                        .onChange(of: viewModel.summary) { _, _ in
                            summaryTouched = true
                            viewModel.clearSubmitMessage()
                        }

                    if (summaryTouched || viewModel.showValidation),
                       let error = viewModel.summaryError {
                        Text(error)
                            .font(.footnote)
                            .foregroundStyle(.red)
                    }

                    TextEditor(text: $viewModel.body)
                        .frame(minHeight: 220)
                        .focused($focusedField, equals: .body)
                        .onChange(of: viewModel.body) { _, _ in
                            bodyTouched = true
                            viewModel.clearSubmitMessage()
                        }

                    if (bodyTouched || viewModel.showValidation),
                       let error = viewModel.bodyError {
                        Text(error)
                            .font(.footnote)
                            .foregroundStyle(.red)
                    }
                } header: {
                    Text("内容信息")
                } footer: {
                    Text("标题和正文会在提交前自动去除首尾空白字符。")
                }

                Section {
                    Button {
                        Task {
                            await viewModel.submit()
                        }
                    } label: {
                        HStack {
                            Spacer()

                            if viewModel.isSubmitting {
                                ProgressView()
                                    .controlSize(.small)
                            }

                            Text(buttonTitle)

                            Spacer()
                        }
                    }
                    .buttonStyle(.borderedProminent)
                    .disabled(!viewModel.canSubmit)

                    if let message = viewModel.submitMessage {
                        Text(message)
                            .font(.footnote)
                            .foregroundStyle(.secondary)
                    }
                }
            }
            .navigationTitle("发布内容")
            .scrollDismissesKeyboard(.interactively)
        }
    }

    private var buttonTitle: String {
        if viewModel.isSubmitting {
            return "提交中…"
        }

        if viewModel.didSubmitSuccessfully {
            return "已提交"
        }

        if viewModel.isFormValid {
            return "提交内容"
        }

        return "完成必填项后提交"
    }
}

这段代码使用了 iOS 17 的双参数 onChange 闭包。如果项目仍以 iOS 16 为最低部署版本,可以将:

.onChange(of: viewModel.title) { _, _ in
    // ...
}

改为:

.onChange(of: viewModel.title) { _ in
    // ...
}

其余状态逻辑不需要改变。

titleTouched、summaryTouched 和 bodyTouched 的作用是避免页面刚打开时就把所有错误显示出来。用户编辑过某个字段后,该字段才显示错误;如果通过其他入口调用 submit(),showValidation 会变成 true,所有错误也会显示出来。

按钮为什么会自动变化

SwiftUI 的状态链路可以简化成:

按钮为什么会自动变化配图

输入框
  ↓
@Published 字段
  ↓
titleError / summaryError / bodyError
  ↓
isFormValid
  ↓
canSubmit
  ↓
.disabled(!canSubmit)

例如用户输入一个只有 3 个字符的标题:

  1. viewModel.title 发生变化。
  2. titleError 返回“标题至少需要 5 个字符”。
  3. isFormValid 变成 false。
  4. canSubmit 变成 false。
  5. 提交按钮被禁用。

当用户继续输入到 5 个字符,titleError 返回 nil。如果摘要和正文也符合规则,isFormValid 变成 true,按钮就会恢复为可点击状态。

这种方式比在每个输入框的 onChange 中直接写:

isButtonEnabled = true

更可靠,因为每次重新计算都会基于所有字段的当前值,不会遗漏某个字段的删除、清空或超长情况。

异步提交时需要处理的异常分支

本地校验通过,只说明数据满足页面规则,不代表接口一定会接受。实际提交至少要考虑以下情况。

用户重复点击

提交按钮使用:

.disabled(!viewModel.canSubmit)

请求开始时,isSubmitting 立即变成 true,按钮随即禁用。网络请求结束后,defer 中的代码把 isSubmitting 恢复为 false。

defer 很重要。无论请求成功、接口返回错误、JSON 解析失败还是网络异常,都会执行恢复逻辑。如果只在成功分支中恢复按钮,失败后页面可能一直停留在“提交中”。

如果项目中存在多个提交入口,例如快捷操作、键盘操作或父视图按钮,还应让所有入口最终都调用同一个 submit(),不要分别复制提交代码。

服务端返回 400、401 或 403

这些状态通常表示请求参数不符合服务端规则、登录状态失效或当前账号无权发布。示例代码会把非 2xx 响应转换为 ContentSubmitError.server,并让按钮在请求结束后恢复。

实际项目可以根据状态码给出更适合用户理解的提示:

  • 400:显示接口返回的字段错误,必要时定位到对应输入框。
  • 401:引导用户重新登录,不要只显示“提交失败”。
  • 403:提示账号没有发布权限。
  • 409:提示内容可能已经存在,或当前版本号发生冲突。
  • 429:提示请求过于频繁,并根据接口约定决定是否允许重试。
  • 500 及其他服务端错误:保留表单内容,提示稍后重试。

不要在所有错误上都自动重试。网络超时可以在用户主动操作后重试,但权限错误、参数错误和内容冲突重复请求通常没有意义。

请求成功但响应无法解析

示例接口要求 2xx 响应中包含有效的 id。如果服务器返回 201 但响应体为空,JSONDecoder 会抛出错误,页面不会误显示为成功。

如果接口约定成功时返回 204,没有响应体,就应把提交器改成只判断状态码:

guard let httpResponse = response as? HTTPURLResponse else {
    throw ContentSubmitError.invalidResponse
}

guard (200...299).contains(httpResponse.statusCode) else {
    throw ContentSubmitError.server(
        statusCode: httpResponse.statusCode
    )
}

// 204 接口没有 id 时,可以返回一个由业务层生成的标识,
// 或者将协议改为 async throws 不返回 UUID。

接口返回格式必须和客户端解码模型一致。不能因为 HTTP 状态码是 200,就跳过响应体校验并直接显示成功。

用户离开页面或任务被取消

Task 会在视图生命周期结束时存在被取消的可能。示例对 CancellationError 和 URLError.cancelled 单独处理,不把用户主动离开页面显示成普通网络故障。

如果业务要求离开页面前必须完成提交,可以在外层保存任务并决定是否阻止导航;如果允许取消,则应保留本地输入,避免用户返回后内容全部丢失。

接入已有内容App时的调整方式

在页面外部注入提交器

页面不应该自己决定接口地址、会话令牌和网络环境。父视图或依赖注入容器可以创建提交器,再传给编辑页面:

let endpoint = URL(
    string: "https://api.example.com/v1/contents"
)!

let submitter = URLSessionContentSubmitter(
    endpoint: endpoint
)

ContentEditorView(submitter: submitter)

上面的域名只是接口形态示例,接入项目时应替换为实际配置。生产环境通常还会根据开发、测试和正式环境提供不同的 API 基地址,避免把环境切换写在表单页面中。

如果项目已经有 ContentRepository、APIClient 或网络服务层,可以让它实现 ContentSubmitting:

struct ContentRepository: ContentSubmitting {
    let apiClient: APIClient

    func create(_ payload: ContentPayload) async throws -> UUID {
        try await apiClient.postContent(payload)
    }
}

这样表单只依赖协议,后续可以很容易替换为测试提交器、离线队列或草稿保存服务。

A5idc数据可围绕内容App的接口提交链路提供域名、SSL证书与CDN等配套业务:域名用于应用站点和接口入口的解析,SSL证书用于建立HTTPS加密连接,CDN适合分发静态资源并分担源站访问;如需承载接口服务或业务数据,也可结合香港、美国、日本等地区的物理服务器资源,按访问地区、计算和存储需求组织运行环境。

编辑已有草稿时的处理

新建内容和编辑草稿的区别主要在于初始值和接口方法:

  • 新建页面初始字段为空,调用创建接口。
  • 编辑页面初始化时填入草稿,调用更新接口。
  • 更新请求通常还需要携带内容 ID或版本号。
  • 草稿恢复后,应重新计算本地校验状态,而不是直接把按钮固定为可用。

如果需要在页面初始化后填入草稿,可以让 ViewModel 增加初始化参数:

init(
    submitter: any ContentSubmitting,
    title: String = "",
    summary: String = "",
    body: String = "",
    category: ContentCategory = .article
) {
    self.submitter = submitter
    self.title = title
    self.summary = summary
    self.body = body
    self.category = category
}

不要在 body 每次刷新时重新创建 ContentFormViewModel,否则用户输入可能因为视图重建而丢失。由页面拥有状态时使用 @StateObject,由父级传入并共享状态时则应根据现有架构使用 @ObservedObject 或环境注入。

使用 Observation 框架的项目

如果项目已经全面采用 iOS 17 的 Observation 框架,也可以把 ObservableObject 和 @Published 换成 @Observable。但校验属性、isSubmitting、错误分支和提交器协议的设计仍然相同。

不要为了追求新写法,在同一个 ViewModel 中混用两套观察机制。选择哪一种主要取决于项目最低系统版本和现有状态管理方式,按钮联动的核心仍然是:

isValid && !isSubmitting

如何验证按钮状态和提交结果

不需要一开始就连接正式接口,可以先用一个模拟提交器验证本地状态变化:

struct MockContentSubmitter: ContentSubmitting {
    let shouldFail: Bool

    func create(_ payload: ContentPayload) async throws -> UUID {
        try await Task.sleep(for: .milliseconds(500))

        if shouldFail {
            throw URLError(.notConnectedToInternet)
        }

        return UUID()
    }
}

在预览或测试页面中传入 MockContentSubmitter(shouldFail: false),可以检查正常流程;传入 true,可以检查失败后按钮是否恢复。

建议依次验证以下输入:

  1. 页面初始打开时,标题和正文为空,按钮显示“完成必填项后提交”并处于禁用状态。
  2. 只输入合规标题,不输入正文,按钮仍然禁用。
  3. 输入只包含空格的标题,去除首尾空白后仍然为空,按钮不能启用。
  4. 标题达到 5 个字符、正文达到 20 个字符且摘要不超长后,按钮变为“提交内容”。
  5. 提交请求开始后,按钮显示“提交中…”并且不能再次点击。
  6. 模拟网络失败,页面保留原始输入,按钮恢复为可提交状态。
  7. 模拟成功响应,页面显示内容编号,按钮变成“已提交”。
  8. 成功后修改任意字段,成功状态被清除,按钮根据新表单状态重新计算。

还要用真实接口验证服务端校验,因为客户端规则只能改善交互,不能代替服务端的权限检查、内容审核、长度限制和重复提交防护。尤其是内容发布场景,最终是否允许创建内容必须由服务端决定,客户端禁用按钮只是减少无效操作和重复请求。

本文由A5数据原创发布,转载请注明出处:https://www.a5idc.com/helpcontent/9949.html

相关推荐