Combine vs Async/Await 对比

// Combine - 实时搜索与表单校验
import Combine
import Foundation

class SearchViewModel: ObservableObject {
    @Published var searchText = ""
    @Published var results: [String] = []
    @Published var isLoading = false
    @Published var errorMessage: String?

    private var cancellables = Set<AnyCancellable>()
    private let searchService: SearchService

    init(searchService: SearchService) {
        self.searchService = searchService
        setupSearch()
    }

    private func setupSearch() {
        $searchText
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .filter { $0.count >= 2 }
            .handleEvents(receiveOutput: { [weak self] _ in
                self?.isLoading = true
                self?.errorMessage = nil
            })
            .flatMap { [weak self] query -> AnyPublisher<[String], Never> in
                guard let self else { return Just([]).eraseToAnyPublisher() }
                return self.searchService.search(query: query)
                    .catch { [weak self] error -> Just<[String]> in
                        self?.errorMessage = error.localizedDescription
                        return Just([])
                    }
                    .eraseToAnyPublisher()
            }
            .receive(on: DispatchQueue.main)
            .sink { [weak self] results in
                self?.isLoading = false
                self?.results = results
            }
            .store(in: &cancellables)
    }
}

// Async/Await - 并行 API 调用与错误处理
import Foundation

@MainActor
class SearchViewModel: ObservableObject {
    @Published var searchText = ""
    @Published var results: [String] = []
    @Published var isLoading = false
    @Published var errorMessage: String?

    private var searchTask: Task<Void, Never>?
    private let searchService: SearchService

    init(searchService: SearchService) {
        self.searchService = searchService
    }

    func search(_ query: String) {
        searchTask?.cancel()
        searchTask = Task {
            guard query.count >= 2 else { return }

            try? await Task.sleep(for: .milliseconds(300))
            guard !Task.isCancelled else { return }

            isLoading = true
            errorMessage = nil

            do {
                let results = try await searchService.search(query: query)
                guard !Task.isCancelled else { return }
                self.results = results
            } catch {
                errorMessage = error.localizedDescription
            }

            isLoading = false
        }
    }
}