defer — какво е, синтаксис и ред на изпълнение

Какво е defer?

defer — е управляваща конструкция на езика Swift, въведена в Swift 2.0 (2015), която отлага изпълнението на своя блок до момента на завършване на текущия scope. Ключова особеност: defer гарантира изпълнението на тялото си независимо от това как точно завършва scope — успешно (return), с грешка (throw), преждевременно (break, continue) или фатално (fatalError, precondition).

Синтактично defer изглежда като defer { /* код */ } и може да бъде поставен навсякъде в рамките на scope. Компилаторът на Swift гарантира, че кодът вътре в defer ще бъде изпълнен, дори ако между декларирането на defer и края на scope възникне изключение или return. Това принципно различава defer от обикновения код, поставен в края на функция, който може да бъде пропуснат при преждевременно излизане.

Според статията на Крис Латнър (Създател на Swift, 2015), defer е вдъхновен от аналогични конструкции в други езици — defer в Go, finally в Java/Python, scope guard в C++ — но с важна разлика: в Swift defer се изпълнява в края на scope, а не веднага след try-catch блок. Това дава по-предвидимо поведение за cleanup във функции с множество точки на излизане.

Използвайте defer за симетрично управление на ресурси: отваряне на файл → defer { close }, поставяне на заключване → defer { unlock }. Такъв модел гарантира, че освобождаването на ресурса няма да бъде пропуснато при никакви обстоятелства.

Ред на изпълнение на няколко defer

Когато в един scope са декларирани няколко defer, те се изпълняват в обратен ред на деклариране (LIFO — Last In, First Out). Това означава, че последният деклариран defer ще се изпълни пръв, а първият — последен:

func exampleDeferOrder() {
    defer { print("Първи defer") }
    defer { print("Втори defer") }
    defer { print("Трети defer") }

    print("Тяло на функция")
}
// Изход:
// Тяло на функция
// Трети defer
// Втори defer
// Първи defer

Редът LIFO е важен за коректното управление на вложени ресурси. Ако първо се отваря файл А, след това файл Б, те трябва да бъдат освободени в обратен ред: първо Б, после А. С defer това става автоматично — декларирайте defer веднага след отварянето на всеки ресурс и редът на почистване ще бъде правилен независимо от броя на точките на излизане от функцията.

Според Swift by Sundell (2024), тази характеристика прави defer идеален за вложени заключвания и транзакции: захващане на заключване → defer { unlock } → захващане на следващото → defer { unlock }. LIFO гарантира, че заключванията се освобождават в обратен ред на захващане, предотвратявайки блокирания.

Defer за почистване на ресурси

Основното приложение на defer — гарантирано почистване на ресурси. Нека разгледаме работа с файловата система. Отварянето на файл чрез FileHandle изисква изрично затваряне — defer гарантира, че close ще бъде извикан при всеки сценарий:

func readFile(path: String) throws -> String {
    let handle = try FileHandle(forReadingFrom: URL(fileURLWithPath: path))
    defer { try? handle.close() }

    let data = try handle.readToEnd()
    guard let data else { throw FileError.empty() }

    return String(data: data, encoding: .utf8) ?? ""
    // handle.close() ще бъде извикан дори при throw или return
}

Друг типичен сценарий — UI-анимации с флаг за зареждане. Преди започване на зареждането се задава флаг isLoading = true, а defer го променя на false при излизане от функцията, независимо от успеха или грешката на заявката. Това предотвратява ситуацията, при която флагът остава true поради необработена грешка и блокира интерфейса завинаги.

Според Bitbucket Engineering Blog (2024), defer се използва и за профилиране: в началото на функцията може да се запише времето, а в defer — да се изчисли и изведе разликата. Това дава точни измервания на производителността на всички пътища на изпълнение, включително грешните.

Defer и обработка на грешки

defer ефективно се комбинира с throws-функции. Когато функция може да хвърли грешка на всеки етап, defer гарантира cleanup без дублиране на код във всеки catch блок или преждевременно излизане guard:

func processTransaction() throws {
    let db = try openDatabase()
    defer { closeDatabase(db) }

    let user = try fetchUser(from: db)
    defer { logAudit(user) }

    let result = try performPayment(user)
    sendNotification(result)
    // closeDatabase(db) и logAudit(user) ще бъдат извикани
    // при всеки throw или return
}

Важно: defer се изпълнява преди прехвърлянето на контрола от catch блока, но след възникването на грешката. Ако в defer бъде хвърлена грешка, Swift не позволява използването на try вътре в defer директно — изисква се try? или try!. Според Apple Documentation, Swift не позволява грешката да „излезе" от defer, тъй като това би нарушило гаранцията за изпълнение на блока.

Поставяйте defer веднага след захващането на ресурса. Това следва принципа на близост: читателят вижда захващането и освобождаването едно до друго, което повишава надеждността на кода и опростява прегледа на кода.

Правила за обхват на видимост

defer се изпълнява при излизане от scope, в който е деклариран. Ако defer е деклариран вътре в do-блок, той се изпълнява при излизане от този блок, а не от външната функция. Ако е вътре в for-цикъл — при всяка итерация:

func scopeExample() {
    print("start")
    do {
        defer { print("defer в do-блок") }
        print("inside do")
    }
    // "defer в do-блок" отпечатва тук
    print("after do")
}
    // Изход: start, inside do, defer в do-блок, after do

for i in 1...3 {
    defer { print("end iteration \(i)") }
    print("iteration \(i)")
}
    // Изход: итерация 1, край на итерация 1, итерация 2, край на итерация 2, ...

Променливите, захванати от defer, се четат в момента на излизане от scope, а не в момента на деклариране на defer. Ако променлива се промени между декларирането на defer и края на scope, defer ще види последната стойност. Това е важна разлика от затварянията (closures), където захващането става в момента на създаване. Бъдете внимателни: промените на променлива след декларирането на defer ще повлияят на неговото изпълнение.

Типични грешки с defer

Първа грешка — предположение за ред на изпълнение, различен от LIFO. Ако редът на cleanup е важен, а defer са декларирани в грешен ред, ресурсите могат да бъдат освободени с нарушаване на зависимостите. Решение: декларирайте defer веднага след захващането на всеки ресурс. Втори ресурс отворен → defer { close second } преди първият да бъде затворен.

Втора грешка — използване на defer за логика, несвързана с почистване. defer е предназначен за гарантиран cleanup, а не за основния поток на управление. Ако кодът в defer влияе на връщаната стойност, това почти винаги е грешка. defer не може да промени return стойността на функцията (за разлика от Java finally, където return в finally презаписва оригиналния return).

Трета грешка — хвърляне на грешка от defer. Swift забранява try вътре в defer, ако грешката може да се разпространи навън. Използвайте try? или try! за операции, които могат да хвърлят грешка, или ги обвийте в отделна функция без throws. Според O'Reilly „Swift in Depth" (2025), добра практика е да направите cleanup функциите нехвърлящи (non-throwing) или да обработвате грешките вътре в defer.