Какие знаешь антипаттерны?

Антипаттерны в iOS-разработке

Антипаттерны — это распространённые, но неэффективные или вредные подходы к решению типичных задач в разработке. Их знание помогает избежать ошибок, улучшить архитектуру и повысить качество кода. Вот ключевые антипаттерны, которые часто встречаются в iOS-проектах.

1. Massive View Controller (MVC в плохом смысле)

Классическая проблема, когда UIViewController становится "богом-объектом", берущим на себя слишком много ответственности: логику представления, бизнес-логику, работу с сетью, управление данными.

Пример проблемного кода:

class UserProfileViewController: UIViewController {
    var user: User?
    var posts: [Post] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        fetchUserData()
        fetchUserPosts()
        setupUI()
        configureGestures()
        // ... ещё 200 строк кода
    }
    
    func fetchUserData() {
        // Сетевой запрос
        URLSession.shared.dataTask(with: userURL) { data, _, _ in
            // Обработка JSON
            // Сохранение в Core Data
            // Обновление UI
        }.resume()
    }
    
    // Десятки других методов
}

Решение: разделение ответственности через MVP, MVVM, VIPER, использование сервисов, менеджеров, фабрик.

2. Сильная связность между компонентами

Когда модули тесно зависят друг от друга, изменения в одном приводят к поломке другого.

Пример:

class OrderService {
    func processOrder() {
        let paymentProcessor = PayPalProcessor() // Жёсткая привязка
        paymentProcessor.process()
        // Прямое создание зависимостей внутри класса
    }
}

Решение: применение Dependency Injection, протоколов, фабрик.

3. Нарушение принципа единой ответственности (SRP)

Класс или метод выполняет несколько несвязанных задач.

Пример:

func saveUserAndSendNotification(_ user: User) {
    // Сохранение в базу
    database.save(user)
    
    // Отправка уведомления
    notificationService.send(for: user)
    
    // Кэширование изображения
    imageCache.cache(user.avatar)
    
    // Логирование
    Logger.log("User saved")
}

Решение: разделение на специализированные методы или классы.

4. Избыточное использование force unwrap и force cast

Применение ! без необходимости ведёт к крешам приложения.

let label = view.subviews.first as! UILabel // Опасный force cast
let text = user.name! // Опасный force unwrap

Решение: безопасное извлечение через guard let, if let, optional chaining, ?? с default значением.

5. "Магические числа" и строки

Жёстко закодированные значения без пояснения их смысла.

func configureTimer() {
    timer = Timer.scheduledTimer(timeInterval: 30.0, // Что это за 30.0?)
                                 target: self,
                                 selector: #selector(update),
                                 userInfo: nil,
                                 repeats: true)
}

Решение: использование констант, enum, конфигурационных файлов.

6. Неправильное управление памятью и retain cycles

Сильные ссылочные циклы между объектами, особенно с замыканиями.

class DataLoader {
    var onComplete: (() -> Void)?
    
    func loadData() {
        API.requestData { [weak self] data in
            self?.process(data) // Без [weak self] будет retain cycle
            self?.onComplete?() // Дополнительный потенциальный цикл
        }
    }
}

Решение: тщательное использование [weak self], [unowned self], анализ отношений владения.

7. Глобальное состояние

Использование синглтонов и глобальных переменных для хранения состояния, что усложняет тестирование и приводит к неожиданным побочным эффектам.

class AppState {
    static let shared = AppState()
    var currentUser: User?
    var settings: Settings?
    // ... много mutable глобального состояния
}

// Использование в любом месте кода
AppState.shared.currentUser = fetchedUser

Решение: передача зависимостей явно, использование локаторов зависимостей в умеренных количествах.

8. Копипаст вместо абстракции

Дублирование кода с минимальными изменениями вместо создания переиспользуемых компонентов.

Пример: несколько UITableViewDataSource с почти идентичной логикой в разных контроллерах.

Решение: создание базовых классов, дженериков, протоколов с реализациями по умолчанию.

9. Игнорирование обработки ошибок

Отсутствие proper error handling, особенно в асинхронных операциях.

func loadImage(from url: URL) {
    URLSession.shared.dataTask(with: url) { data, _, _ in // Игнорируем error
        if let data = data {
            let image = UIImage(data: data)
            // Показать image
        }
        // Никакой обработки ошибок сети, отсутствия данных и т.д.
    }.resume()
}

Решение: использование Result типа, do-try-catch, completion handlers с параметром ошибки.

10. Преждевременная оптимизация

Сложные оптимизации (например, ручное управление памятью, кастомные структуры данных) до выявления реальных проблем производительности.

Решение: профилирование с помощью Instruments, оптимизация только bottleneck'ов.

11. Нарушение принципа открытости/закрытости

Модификация существующего кода вместо расширения через новые классы/protocols.

func handlePayment(type: String) {
    if type == "creditCard" {
        // Логика для карт
    } else if type == "paypal" {
        // Логика для PayPal
    } else if type == "applePay" {
        // Логика для Apple Pay
    } // Добавление нового типа требует изменения этого метода
}

Решение: применение стратегии, фабрик, протоколов.

12. Избыточные зависимости в проекте

Добавление тяжелых библиотек для решения простых задач (например, подключать целую библиотеку сетевых запросов для 2-3 экранов).

Решение: оценка необходимости зависимости, создание легковесных обёрток, использование нативных решений.

Как бороться с антипаттернами

• Code Reviews — регулярные проверки кода коллегами
• Статический анализ — использование SwiftLint, Danger
• Автоматизированное тестирование — unit, integration, UI тесты
• Обсуждение архитектуры — планирование решений до реализации
• Рефакторинг — регулярное улучшение кодовой базы
• Обучение команды — sharing знаний о лучших практиках

Избегание этих антипаттернов приводит к созданию поддерживаемого, тестируемого и масштабируемого кода, что критически важно для долгосрочных проектов.