Swift代码片段生成专家

功能概述

使用 SwiftUI 构建一个简洁的登录界面，采用 MVVM 结构与可注入的验证/网络层。支持：

• 邮箱与密码实时校验（邮箱格式、密码至少 8 位）
• 输入合法时启用“登录”按钮
• 点击登录显示加载指示，并模拟 1 秒网络请求
• 失败时弹出带“重试”的错误提示
• 动态字体、深浅色适配与可访问性标签
• iOS 15+，不依赖第三方库

代码实现

import SwiftUI

// MARK: - Validation Layer (可测试/可替换)
protocol AuthValidating {
    func isValidEmail(_ email: String) -> Bool
    func isValidPassword(_ password: String) -> Bool
}

struct DefaultAuthValidator: AuthValidating {
    // 简洁邮箱校验（满足大多数场景，便于单元测试）
    private let emailPredicate = NSPredicate(
        format: "SELF MATCHES[c] %@",
        "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
    )

    func isValidEmail(_ email: String) -> Bool {
        emailPredicate.evaluate(with: email)
    }

    func isValidPassword(_ password: String) -> Bool {
        password.count >= 8
    }
}

// MARK: - Service Layer (模拟网络)
enum AuthError: LocalizedError {
    case network
    case invalidCredentials

    var errorDescription: String? {
        switch self {
        case .network: return "网络异常，请稍后重试。"
        case .invalidCredentials: return "邮箱或密码错误。"
        }
    }
}

protocol AuthServicing {
    func login(email: String, password: String) async throws
}

struct MockAuthService: AuthServicing {
    enum Mode { case random, alwaysFail, alwaysSuccess }
    var mode: Mode = .random

    func login(email: String, password: String) async throws {
        // 模拟 1 秒网络耗时
        try await Task.sleep(nanoseconds: 1_000_000_000)

        // 可配置的结果，默认随机成功/失败
        let success: Bool
        switch mode {
        case .random:
            success = Bool.random()
        case .alwaysFail:
            success = false
        case .alwaysSuccess:
            success = true
        }

        if success {
            return
        } else {
            // 随机返回一种常见错误，便于演示
            throw Bool.random() ? AuthError.network : AuthError.invalidCredentials
        }
    }
}

// MARK: - ViewModel
@MainActor
final class LoginViewModel: ObservableObject {
    // Inputs
    @Published var email: String = ""
    @Published var password: String = ""

    // UI States
    @Published private(set) var isLoading: Bool = false
    @Published private(set) var errorMessage: String?
    @Published var showErrorAlert: Bool = false

    // Dependencies
    private let validator: AuthValidating
    private let authService: AuthServicing

    init(validator: AuthValidating = DefaultAuthValidator(),
         authService: AuthServicing = MockAuthService()) {
        self.validator = validator
        self.authService = authService
    }

    // Realtime validation
    var isEmailValid: Bool { validator.isValidEmail(email) }
    var isPasswordValid: Bool { validator.isValidPassword(password) }
    var isFormValid: Bool { isEmailValid && isPasswordValid }

    // Login action
    func login() async {
        guard isFormValid, !isLoading else { return }
        isLoading = true
        defer { isLoading = false }

        do {
            try await authService.login(email: email, password: password)
            // 登录成功，可在此发布成功事件或跳转
        } catch {
            errorMessage = (error as? LocalizedError)?.errorDescription ?? "未知错误。"
            showErrorAlert = true
        }
    }
}

// MARK: - View
struct LoginView: View {
    @StateObject private var viewModel = LoginViewModel()

    @FocusState private var focusedField: Field?
    private enum Field: Hashable { case email, password }

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("账户信息")) {
                    // 邮箱输入
                    TextField("邮箱", text: $viewModel.email)
                        .keyboardType(.emailAddress)
                        .textContentType(.emailAddress)
                        .textInputAutocapitalization(.never)
                        .disableAutocorrection(true)
                        .focused($focusedField, equals: .email)
                        .submitLabel(.next)
                        .accessibilityLabel("邮箱输入框")
                        .onSubmit {
                            focusedField = .password
                        }

                    if !viewModel.email.isEmpty && !viewModel.isEmailValid {
                        Text("请输入有效的邮箱地址")
                            .font(.footnote)
                            .foregroundColor(.red)
                            .accessibilityLabel("邮箱格式错误")
                    }

                    // 密码输入
                    SecureField("密码（至少 8 位）", text: $viewModel.password)
                        .textContentType(.password)
                        .focused($focusedField, equals: .password)
                        .submitLabel(.go)
                        .accessibilityLabel("密码输入框")
                        .accessibilityHint("密码至少 8 位")
                        .onSubmit {
                            if viewModel.isFormValid {
                                Task { await viewModel.login() }
                            }
                        }

                    if !viewModel.password.isEmpty && !viewModel.isPasswordValid {
                        Text("密码至少需要 8 位")
                            .font(.footnote)
                            .foregroundColor(.red)
                            .accessibilityLabel("密码长度不足")
                    }
                }

                Section {
                    Button(action: {
                        Task { await viewModel.login() }
                    }) {
                        HStack {
                            if viewModel.isLoading {
                                ProgressView()
                                    .progressViewStyle(.circular)
                                    .accessibilityLabel("正在登录")
                            }
                            Text("登录")
                                .font(.headline)
                        }
                        .frame(maxWidth: .infinity)
                    }
                    .buttonStyle(.borderedProminent)
                    .disabled(!viewModel.isFormValid || viewModel.isLoading)
                    .accessibilityLabel("登录按钮")
                    .accessibilityHint("当邮箱与密码合法时可点击")
                }
            }
            .navigationTitle("登录")
            .alert(viewModel.errorMessage ?? "登录失败", isPresented: $viewModel.showErrorAlert) {
                Button("重试") {
                    Task { await viewModel.login() }
                }
                Button("取消", role: .cancel) { }
            } message: {
                Text(viewModel.errorMessage ?? "请稍后重试。")
            }
        }
    }
}

// MARK: - Preview
struct LoginView_Previews: PreviewProvider {
    static var previews: some View {
        Group {
            LoginView()
                .preferredColorScheme(.light)
            LoginView()
                .preferredColorScheme(.dark)
                .environment(\.sizeCategory, .accessibilityExtraExtraExtraLarge) // 动态字体预览
        }
    }
}

代码说明

• 关键点1：MVVM 与可测试验证
  • 通过 AuthValidating 协议与 DefaultAuthValidator，将邮箱/密码校验逻辑独立，便于单元测试与替换。
  • ViewModel 仅持有协议依赖，既可注入真实服务，也可注入 Mock 服务，保持解耦。
• 关键点2：异步登录与加载状态
  • 使用 async/await 与 Task.sleep 模拟 1 秒网络请求，期间设置 isLoading 控制 UI 状态（按钮禁用、显示 ProgressView）。
  • 登录失败后通过 showErrorAlert 与 errorMessage 触发 Alert，提供“重试”按钮再次调用登录逻辑。
• 关键点3：实时校验与无障碍
  • 实时校验：isFormValid、isEmailValid、isPasswordValid 为计算属性，表单输入变化时自动刷新按钮可用性与错误提示。
  • 无障碍：为输入框、按钮、加载指示添加 accessibilityLabel；动态字体使用系统字体样式，适配深浅色主题。
  • 键盘行为：使用 FocusState 与 onSubmit 实现“下一项/提交”键流程，提升可用性。

适用场景

• 基础登录页面的快速搭建（iOS 15+）
• 需要可测试验证逻辑与可替换网络层的表单界面
• 演示 SwiftUI 中表单实时校验、异步任务与加载/错误处理的最佳实践
• 需要支持动态字体、无障碍和深浅色模式的登录/认证场景