Какие знаешь виды замыканий?

Виды замыканий в Swift

В Swift замыкания (closures) — это самодостаточные блоки функциональности, которые могут быть переданы и использованы в коде. Они захватывают и хранят ссылки на константы и переменные из окружающего контекста, отсюда и название. Вот основные виды замыканий, которые я использую в разработке под iOS.

1. Глобальные функции (Global Functions)

Это замыкания, которые имеют имя и не захватывают никакие значения из окружающего контекста. Они объявляются на верхнем уровне кода.

func greet(name: String) -> String {
    return "Привет, \(name)!"
}

// Вызов
print(greet(name: "Анна")) // Привет, Анна!

2. Вложенные функции (Nested Functions)

Функции, определенные внутри других функций. Они могут захватывать значения из внешней функции.

func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    func incrementer() -> Int {
        total += incrementAmount
        return total
    }
    return incrementer
}

let incrementByTwo = makeIncrementer(incrementAmount: 2)
print(incrementByTwo()) // 2
print(incrementByTwo()) // 4

3. Замыкающие выражения (Closure Expressions)

Безымянные замыкания, записанные в облегченном синтаксисе. Они могут захватывать значения из окружающего контекста. Есть несколько форм:

a. Базовое замыкающее выражение

let numbers = [1, 4, 2, 5]
let sortedNumbers = numbers.sorted(by: { (a: Int, b: Int) -> Bool in
    return a < b
})

b. Замыкания с выводом типов (Type Inference)

Swift может вывести типы параметров и возвращаемого значения из контекста.

let sortedNumbers = numbers.sorted(by: { a, b in
    return a < b
})

c. Неявные возвращаемые значения (Implicit Returns)

Для замыканий из одного выражения ключевое слово return можно опустить.

let sortedNumbers = numbers.sorted(by: { a, b in a < b })

d. Сокращенные имена аргументов (Shorthand Argument Names)

Можно обращаться к аргументам по позициям $0, $1 и т.д.

let sortedNumbers = numbers.sorted(by: { $0 < $1 })

e. Последующее замыкание (Trailing Closure)

Если замыкание является последним аргументом функции, его можно вынести за круглые скобки.

let sortedNumbers = numbers.sorted { $0 < $1 }

f. Автозамыкания (Autoclosures)

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

func debugLog(_ condition: @autoclosure () -> Bool, _ message: String) {
    if condition() {
        print(message)
    }
}

let isEnabled = true
debugLog(isEnabled && 2 > 1, "Условие выполнено")

4. Захватывающие замыкания (Capturing Closures)

Замыкания, которые захватывают переменные или константы из окружающего контекста, удерживая их в памяти.

func makeCounter() -> () -> Int {
    var count = 0
    let counter: () -> Int = {
        count += 1
        return count
    }
    return counter
}

let myCounter = makeCounter()
print(myCounter()) // 1
print(myCounter()) // 2

5. Escaping и non-escaping замыкания

• Non-escaping замыкания — выполняются в пределах тела функции и не могут быть вызваны после ее завершения (используются по умолчанию).
• Escaping замыкания — могут быть сохранены и вызваны после завершения функции, например, в асинхронных задачах.

class DataManager {
    var completionHandlers: [() -> Void] = []
    
    func loadData(completion: @escaping () -> Void) {
        completionHandlers.append(completion)
        // Асинхронная операция
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            completion()
        }
    }
}

Ключевые особенности замыканий в Swift:

• Захват значений — замыкания могут захватывать и хранить ссылки на переменные из окружающего контекста.
• Сокращенный синтаксис — позволяет писать более чистый и выразительный код.
• Гибкость — могут использоваться как аргументы функций, возвращаемые значения, или храниться в свойствах.
• Управление памятью — важно следить за циклами сильных ссылок (strong reference cycles) при захвате self в escaping-замыканиях, используя [weak self] или [unowned self].

Понимание этих видов замыканий критически важно для эффективной работы с асинхронным кодом, обработкой событий и функциональными паттернами в iOS-разработке.