如何避免写垃圾代码：iOS开发篇

// 高认知负荷示例：不必要的抽象
protocol DataProcessor {
    func process(data: Data) -> ProcessedData
}

class ImageProcessor: DataProcessor {
    func process(data: Data) -> ProcessedData {
        // 复杂的处理逻辑
        guard let image = UIImage(data: data) else { 
            throw ProcessingError.invalidData 
        }
        // ...更多处理
        return processedImage
    }
}

// 使用时需要理解整个协议体系
let processor: DataProcessor = ImageProcessor()
let result = processor.process(data: imageData)

// 低认知负荷示例：直接明了的代码
func processImageData(_ data: Data) throws -> UIImage {
    guard let image = UIImage(data: data) else {
        throw ImageProcessingError.invalidData
    }
    
    // 清晰的图像处理逻辑
    let scaledImage = image.resize(to: CGSize(width: 300, height: 300))
    let filteredImage = scaledImage.applyFilter(.contrast(1.2))
    
    return filteredImage
}

// 使用时一目了然
let processedImage = try processImageData(imageData)

// ❌ 不良实践：过度抽象
protocol NetworkRequestable {
    associatedtype Response: Decodable
    var endpoint: String { get }
    var method: HTTPMethod { get }
    var parameters: [String: Any]? { get }
}

protocol JSONParsable {
    associatedtype Model: Decodable
    func parse(_ data: Data) throws -> Model
}

protocol Cacheable {
    var cacheKey: String { get }
    var cacheExpiry: TimeInterval { get }
}

struct UserProfileRequest: NetworkRequestable, JSONParsable, Cacheable {
    typealias Response = UserProfile
    typealias Model = UserProfile
    
    let userId: String
    var endpoint: String { "/users/\(userId)" }
    var method: HTTPMethod { .get }
    var parameters: [String: Any]? { nil }
    var cacheKey: String { "user_profile_\(userId)" }
    var cacheExpiry: TimeInterval { 3600 }
    
    func parse(_ data: Data) throws -> UserProfile {
        return try JSONDecoder().decode(UserProfile.self, from: data)
    }
}

// ✅ 改进方案：适度的抽象
struct APIRequest {
    let endpoint: String
    let method: HTTPMethod
    let parameters: [String: Any]?
    let cacheKey: String?
    let cacheExpiry: TimeInterval?
}

func fetchUserProfile(userId: String) async throws -> UserProfile {
    let request = APIRequest(
        endpoint: "/users/\(userId)",
        method: .get,
        parameters: nil,
        cacheKey: "user_profile_\(userId)",
        cacheExpiry: 3600
    )
    
    let data = try await NetworkManager.shared.execute(request)
    return try JSONDecoder().decode(UserProfile.self, from: data)
}

// ❌ 不良实践：无意义的helper函数
class UIHelper {
    static func makeLabel(text: String, 
                         fontSize: CGFloat, 
                         textColor: UIColor) -> UILabel {
        let label = UILabel()
        label.text = text
        label.font = UIFont.systemFont(ofSize: fontSize)
        label.textColor = textColor
        return label
    }
    
    static func makeButton(title: String, 
                          backgroundColor: UIColor) -> UIButton {
        let button = UIButton()
        button.setTitle(title, for: .normal)
        button.backgroundColor = backgroundColor
        return button
    }
}

// 使用这些"helper"反而增加了理解成本
let titleLabel = UIHelper.makeLabel(text: "欢迎", 
                                   fontSize: 16, 
                                   textColor: .black)
let actionButton = UIHelper.makeButton(title: "确定", 
                                      backgroundColor: .blue)

// ✅ 改进方案：直接创建或者使用合理的扩展
extension UILabel {
    convenience init(text: String, 
                    fontSize: CGFloat, 
                    color: UIColor = .black) {
        self.init()
        self.text = text
        self.font = UIFont.systemFont(ofSize: fontSize)
        self.textColor = color
    }
}

// 使用更清晰明了
let titleLabel = UILabel(text: "欢迎", fontSize: 16)
let actionButton = UIButton(type: .system).then {
    $0.setTitle("确定", for: .normal)
    $0.backgroundColor = .blue
}

// ❌ 不良实践：过度复杂的函数式链式调用
let processedItems = items
    .filter { $0.isActive }
    .map { item in
        return item.transformed { value in
            return value * coefficientCalculator(
                base: baseValue,
                modifier: environmentalModifier
            )
        }
    }
    .compactMap { $0.finalize() }
    .sorted { $0.priority > $1.priority }
    .flatMap { $0.components }

// ✅ 改进方案：分解为清晰的步骤
var activeItems = items.filter { $0.isActive }

var transformedItems: [ProcessedItem] = []
for item in activeItems {
    let coefficient = calculateCoefficient(
        base: baseValue,
        modifier: environmentalModifier
    )
    let transformed = transformItem(item, coefficient: coefficient)
    if let finalized = transformed.finalize() {
        transformedItems.append(finalized)
    }
}

let sortedItems = transformedItems.sorted { $0.priority > $1.priority }
let result = sortedItems.flatMap { $0.components }

// UIKit示例：传统的MVC模式
class UserProfileViewController: UIViewController {
    var user: User?
    private let nameLabel = UILabel()
    private let emailLabel = UILabel()
    private let avatarImageView = UIImageView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        configureWithUser()
    }
    
    private func setupUI() {
        // 大量的布局代码...
        nameLabel.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(nameLabel)
        NSLayoutConstraint.activate([
            nameLabel.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 20),
            nameLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
            nameLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16)
        ])
        
        // 更多UI设置代码...
    }
    
    private func configureWithUser() {
        nameLabel.text = user?.name
        emailLabel.text = user?.email
        // 图片加载等...
    }
}

// SwiftUI示例：声明式UI降低认知负荷
struct UserProfileView: View {
    let user: User?
    
    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            HStack {
                AsyncImage(url: user?.avatarURL) { image in
                    image.resizable()
                } placeholder: {
                    Color.gray
                }
                .frame(width: 60, height: 60)
                .clipShape(Circle())
                
                VStack(alignment: .leading) {
                    Text(user?.name ?? "")
                        .font(.headline)
                    Text(user?.email ?? "")
                        .font(.subheadline)
                        .foregroundColor(.secondary)
                }
            }
            .padding()
        }
    }
}

// ❌ 不良实践：复杂的内存管理
class DataManager {
    static let shared = DataManager()
    private var cache: [String: Any] = [:]
    private var observers: [NSObjectProtocol] = []
    
    func fetchData(for key: String, 
                  completion: @escaping (Result<Data, Error>) -> Void) {
        if let cached = cache[key] as? Data {
            completion(.success(cached))
            return
        }
        
        // 复杂的网络请求和缓存逻辑
        let request = URLRequest(url: URL(string: key)
        let task = URLSession.shared.dataTask(with: request) { [weak self] data, _, error in
            guard let self = self else { return }
            
            if let error = error {
                completion(.failure(error))
                return
            }
            
            guard let data = data else {
                completion(.failure(NSError(domain: "NoData", code: -1)))
                return
            }
            
            self.cache[key] = data
            completion(.success(data))
            
            // 通知观察者
            self.notifyObservers(for: key, data: data)
        }
        task.resume()
    }
    
    private func notifyObservers(for key: String, data: Data) {
        // 复杂的观察者通知逻辑
    }
}

// ✅ 改进方案：使用现代并发框架简化内存管理
actor DataCache {
    private var storage: [String: Data] = [:]
    
    func data(for key: String) async throws -> Data {
        if let cached = storage[key] {
            return cached
        }
        
        let data = try await downloadData(from: key)
        storage[key] = data
        return data
    }
    
    private func downloadData(from key: String) async throws -> Data {
        let url = URL(string: key)!
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    }
}

// 使用示例清晰简单
let data = try await DataCache().data(for: "https://example.com/data")

// 🤖 AI友好的代码结构
struct UserProfileConfig {
    let userId: String
    let shouldLoadAvatar: Bool
    let cachePolicy: CachePolicy
    let timeout: TimeInterval
}

// 清晰的函数签名和职责分离
func loadUserProfile(config: UserProfileConfig) async throws -> UserProfile {
    // 1. 检查缓存
    if let cached = try await checkCache(for: config.userId, policy: config.cachePolicy) {
        return cached
    }
    
    // 2. 网络请求
    let userData = try await fetchUserData(
        userId: config.userId,
        timeout: config.timeout
    )
    
    // 3. 数据处理
    let profile = try processUserData(
        userData,
        loadAvatar: config.shouldLoadAvatar
    )
    
    // 4. 缓存结果
    try await cacheProfile(profile, for: config.userId)
    
    return profile
}

// 每个辅助函数都有明确的单一职责
private func checkCache(for userId: String, policy: CachePolicy) async throws -> UserProfile? {
    // 清晰的缓存检查逻辑
}

private func fetchUserData(userId: String, timeout: TimeInterval) async throws -> Data {
    // 清晰的网络请求逻辑
}

private func processUserData(_ data: Data, loadAvatar: Bool) throws -> UserProfile {
    // 清晰的数据处理逻辑
}

// ❌ 测试代码中的高认知负荷
func testUserProfileLoading() {
    let mockNetwork = MockNetworkService()
    let mockCache = MockCacheService()
    let mockParser = MockDataParser()
    let config = AppConfig.shared
    
    let manager = UserProfileManager(
        network: mockNetwork,
        cache: mockCache,
        parser: mockParser,
        config: config
    )
    
    mockNetwork.stubResponse = .success(testData)
    mockCache.stubResult = .empty
    mockParser.stubResult = testUser
    
    let expectation = self.expectation(description: "Profile loaded")
    
    manager.loadProfile(userId: "123") { result in
        switch result {
        case .success(let user):
            XCTAssertEqual(user.name, "Test User")
        case .failure:
            XCTFail("Should not fail")
        }
        expectation.fulfill()
    }
    
    waitForExpectations(timeout: 1)
}

// ✅ 低认知负荷的测试代码
func testUserProfileLoading() async throws {
    // 设置清晰的测试数据
    let testUser = User.testInstance()
    let testData = try JSONEncoder().encode(testUser)
    
    // 使用简单的测试依赖
    let service = UserProfileService(
        network: .mock(returning: testData),
        cache: .empty,
        parser: .standard
    )
    
    // 清晰的测试逻辑
    let result = try await service.loadProfile(userId: "123")
    
    // 明确的断言
    XCTAssertEqual(result, testUser)
}

// 测试辅助扩展
extension User {
    static func testInstance() -> User {
        User(
            id: "123",
            name: "Test User",
            email: "test@example.com"
        )
    }
}

extension NetworkService {
    static func mock(returning data: Data) -> Self {
        // 简单的mock实现
    }
}

// 使用// MARK: 注释组织代码
class UserProfileViewController: UIViewController {
    
    // MARK: - Properties
    private var user: User?
    private var isLoading = false
    
    // MARK: - UI Components
    private let nameLabel = UILabel()
    private let avatarImageView = UIImageView()
    
    // MARK: - Lifecycle
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        loadData()
    }
    
    // MARK: - Setup
    private func setupUI() {
        configureLabel()
        configureImageView()
        setupConstraints()
    }
    
    // MARK: - Data Loading
    private func loadData() {
        guard !isLoading else { return }
        isLoading = true
        Task {
            await fetchUserProfile()
        }
    }
    
    // MARK: - Helper Methods
    private func configureLabel() {
        nameLabel.font = .preferredFont(forTextStyle: .headline)
        nameLabel.textColor = .label
    }
}