Что такое weak-ссылка в Swift и для чего она используется?

Тип вопроса: Управление памятью Вероятность: 32% Категория: IOS Разработчик

Ответ

weak — это ключевое слово в Swift, которое создает слабую ссылку на объект. Слабая ссылка не увеличивает счетчик сильных ссылок (retain count) объекта, на который указывает. Это основной механизм для предотвращения циклов сильных ссылок (retain cycles), которые приводят к утечкам памяти.

Ключевые свойства:

  1. Optional: Слабая ссылка всегда должна быть объявлена как переменная optional типа (weak var delegate: SomeDelegate?), потому что объект, на который она ссылается, может быть освобожден в любой момент.
  2. Автоматическое обнуление: Когда объект освобождается, все слабые ссылки на него автоматически устанавливаются в nil. Это предотвращает краш при обращении к освобожденной памяти.

Типичные сценарии использования:

  • Делегаты (Delegates): Классический пример, где объект А не должен владеть объектом Б, который является его делегатом.
  • Замыкания (Closures): При захвате self внутри замыкания, которое хранится долго (например, completion handler).
  • Двунаправленные связи в родительско-дочерних отношениях, где дочерний объект не должен продлевать жизнь родительскому.

Пример предотвращения цикла сильных ссылок с делегатом:

protocol ServiceDelegate: AnyObject { // Протокол должен быть class-bound (`AnyObject`)
    func didReceiveData(_ data: Data)
}

class DataService {
    // Делегат объявлен как weak, чтобы не создавать сильную ссылку на ViewController
    weak var delegate: ServiceDelegate?

    func fetchData() {
        // ... получение данных
        delegate?.didReceiveData(someData) // Безопасный вызов, так как delegate - weak
    }
}

class ViewController: UIViewController, ServiceDelegate {
    let service = DataService()

    override func viewDidLoad() {
        super.viewDidLoad()
        service.delegate = self // ViewController не удерживается сервисом через делегата
    }

    func didReceiveData(_ data: Data) { /* Обработка данных */ }
}
// Когда ViewController освобождается, DataService не удерживает его через delegate.

Правило: Используйте weak для ссылок, которые могут создать цикл, где объект А ссылается на Б, а Б ссылается на А, и ни один из них не должен владеть другим.

Ответ 18+ 🔞

Слушай, давай разберемся с этим weak, а то народ путается, как последние идиоты, блядь.

Вот представь: у тебя есть два объекта, они друг на друга ссылаются, как два мудака в баре, которые друг другу долги не отдают. Каждый держит другого за шкирку — это сильные ссылки. В итоге оба них нихуя не могут освободиться, память висит, и приложение твое медленно, но верно накрывается медным тазом. Это и есть retain cycle, ёпта.

Так вот, weak — это как сказать: «Слушай, я на тебя посмотрю, но держать не буду». Ссылка есть, но счетчик владения (retain count) она не увеличивает. Главная фишка в том, что если объект, на который ты слабо смотришь, вдруг помрет (деаллоцируется), то твоя ссылка автоматически станет nil. Красиво, безопасно, без попыток достучаться до трупа, что всегда кончается крешами, блядь.

Важные нюансы, которые все хуйней мажут:

  1. weak ссылка ВСЕГДА должна быть optional и var. Потому что сегодня объект есть, а завтра — в рот меня чих-пых — его уже нет, и ссылке надо стать nil. Константой (let) её не объявишь, это же логично, ёбта.
  2. Работает ТОЛЬКО с классами (reference types). На структуры или енумы слабую ссылку не навесишь — они и так по значению живут. Поэтому протокол для делегата надо помечать AnyObject, чтобы компилятор понял, что тут только классы, а не какая-то хуйня.

Где это самое слабое звено применяется? Да везде, где есть риск схватиться в мертвую хватку:

  • Делегаты (Delegates): Классика жанра. Твой ViewController держит сервис, а сервис через делегата держит ViewController. Без weak они будут держать друг друга до скончания времён, как два пидораса в браке по расчёту.
  • Замыкания (Closures): Вот тут народ реально обжигается. Захватил self в замыкание, которое само живет в self — и всё, пиши пропало, цикл готов. Надо либо [weak self], либо [unowned self] (но это уже на свой страх и риск, как прыжок с парашютом с просроченным куполом).
  • Родитель-ребёнок, когда ребёнок должен знать о родителе. Родитель держит дитя сильно, а дитя смотрит на родителя слабо — и всё в порядке, никто никого в могилу не тянет.

Смотри, как это выглядит в коде, чтобы не быть мудаком:

// Протокол помечаем AnyObject, чтобы делегат был ТОЛЬКО классом
protocol MyServiceDelegate: AnyObject {
    func workDone(_ result: String)
}

class MyService {
    // Вот она, слабая ссылка! Optional, var. Сервис НЕ владеет тем, кто его делегат.
    weak var delegate: MyServiceDelegate?

    func doSomeWork() {
        // Симуляция тяжёлого труда...
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
            // Вызываем осторожненько, через optional chaining.
            // Если делегата уже нет в живых, просто тихо сдохнем.
            self?.delegate?.workDone("Всё, готово, принимай работу, ёпта!")
        }
    }
}

class ViewController: UIViewController, MyServiceDelegate {
    let service = MyService() // Сильная ссылка. ViewController владеет сервисом.

    override func viewDidLoad() {
        super.viewDidLoad()
        service.delegate = self // А вот тут сервис НЕ владеет ViewController'ом. Ссылка weak!
    }

    func workDone(_ result: String) {
        print(result) // Работа принята!
    }
}
// Когда ViewController уничтожается, service.delegate автоматом становится nil.
// Цикла нет, утечки нет, все живы-здоровы, ебать мои старые костыли!

Итог: weak — это твой главный инструмент против утечек памяти из-за циклов. Используй его везде, где есть обратная связь (делегаты, колбэки, замыкания), и где один объект не должен владеть другим. Не забывай про [weak self] в замыканиях. А если забудешь — получишь приложение, которое жрёт память, как свинья, и потом пользователи пошлют тебя нахуй вместе с твоим творением.

© ХакСобесов, 2026
support@hacksobesov.com