Как сделать так, чтобы свойство инициализировалось при первом обращении к нему?

Lazy Initialization (Ленивая инициализация) в Swift

Ленивая инициализация — это паттерн, при котором инициализация ресурсоемкого или опционального свойства откладывается до момента первого обращения к нему. Это ключевой механизм для оптимизации производительности и управления памятью в iOS-приложениях.

Основные подходы в Swift

1. Использование lazy-переменных (наиболее распространенный способ)

Для хранения свойства используется lazy модификатор, который гарантирует однократную инициализацию при первом чтении.

class DataManager {
    // Ленивое свойство с явным указанием типа
    lazy var expensiveResource: Resource = {
        let resource = Resource()
        resource.configure(with: "data")
        return resource
    }()
    
    // Ленивое свойство с зависимостью от self
    lazy var formatter: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        return formatter
    }()
}

Важные особенности:

• lazy можно использовать только с var (не с let)
• Инициализация происходит потокобезопасно (в Swift 5+)
• Свойство должно иметь явно указанный тип
• Нельзя использовать с вычисляемыми свойствами (computed properties)

2. Классический подход с backing property

class ConfigurationManager {
    private var _configuration: AppConfiguration?
    
    var configuration: AppConfiguration {
        if let existingConfig = _configuration {
            return existingConfig
        }
        
        let newConfig = AppConfiguration.loadFromDisk()
        _configuration = newConfig
        return newConfig
    }
}

3. Использование property wrapper (Swift 5.1+)

Можно создать кастомный property wrapper для повторного использования логики:

@propertyWrapper
struct LazilyInitialized<T> {
    private var storage: T?
    private let initializer: () -> T
    
    init(wrappedValue initializer: @escaping @autoclosure () -> T) {
        self.initializer = initializer
    }
    
    var wrappedValue: T {
        mutating get {
            if storage == nil {
                storage = initializer()
            }
            return storage!
        }
        set {
            storage = newValue
        }
    }
}

// Использование
class ImageCache {
    @LazilyInitialized var cache: NSCache<NSString, UIImage> = {
        let cache = NSCache<NSString, UIImage>()
        cache.countLimit = 100
        return cache
    }()
}

Сравнение подходов

Практические примеры использования

Ленивая загрузка тяжелых ресурсов:

class DocumentViewController: UIViewController {
    lazy var thumbnailGenerator: ImageProcessor = {
        let processor = ImageProcessor()
        processor.quality = .high
        processor.cacheEnabled = true
        return processor
    }()
    
    lazy var documentContent: String = {
        guard let path = Bundle.main.path(forResource: "document", ofType: "txt") else {
            return ""
        }
        return try? String(contentsOfFile: path) ?? ""
    }()
}

Ленивая инициализация UI-компонентов:

class ProfileView: UIView {
    lazy var avatarImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.layer.cornerRadius = 40
        imageView.clipsToBounds = true
        imageView.translatesAutoresizingMaskIntoConstraints = false
        addSubview(imageView)
        return imageView
    }()
}

Потокобезопасность и нюансы

Начиная с Swift 5, ленивые свойства инициализируются атомарно:

// Swift обеспечивает потокобезопасность автоматически
lazy var sharedInstance: NetworkManager = {
    return NetworkManager.shared
}()

// Для ручной реализации в многопоточной среде:
class ThreadSafeLazy<T> {
    private var value: T?
    private let lock = NSLock()
    
    func get(initializer: () -> T) -> T {
        lock.lock()
        defer { lock.unlock() }
        
        if let existingValue = value {
            return existingValue
        }
        
        let newValue = initializer()
        value = newValue
        return newValue
    }
}

Когда использовать ленивую инициализацию

• Ресурсоемкие объекты (парсеры, процессоры изображений)
• Зависимые от контекста свойства (требующие self для настройки)
• UI-компоненты, которые могут никогда не понадобиться
• Кэшированные вычисления для тяжелых операций

Ограничения и предостережения

1. Не использовать с let — только с var
2. Не использовать в структурах с mutating методами
3. Тестирование усложняется — состояние зависит от порядка обращения
4. Не подходит для optional типов, которые могут быть nil

Ленивая инициализация — мощный инструмент, который при грамотном применении значительно улучшает производительность приложений, экономя ресурсы на инициализации объектов, которые могут никогда не понадобиться в течение жизненного цикла объекта.