Что такое замыкание

Замыкание (или closure) — это одна из фундаментальных концепций в современных языках программирования, которая играет важную роль в функциональном подходе и при создании гибких архитектур. Говоря простыми словами, замыкание — это функция, которая не только может быть передана как значение, но и сохраняет доступ к переменным из своего внешнего контекста, даже после того, как этот контекст завершил выполнение. Это позволяет создавать функции с «памятью», которые продолжают использовать значения из той среды, в которой они были определены.

В языке Swift замыкания являются полноценными объектами первого класса. Они могут быть присвоены переменным, переданы как аргументы и возвращены из других функций. Например, представим функцию, которая возвращает другую функцию, инкрементирующую счётчик:

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

let counter = makeCounter()
print(counter()) // 1
print(counter()) // 2
print(counter()) // 3

func makeCounter() -> () -> Int {

    var count = 0

    return {

        count += 1

        return count

    }

}

​

let counter = makeCounter()

print(counter()) // 1

print(counter()) // 2

print(counter()) // 3

Здесь переменная count находится во внешнем по отношению к возвращаемому замыканию контексте. Однако, несмотря на то, что функция makeCounter уже завершила выполнение, замыкание, возвращённое из неё, продолжает «помнить» значение count и каждый раз увеличивает его. Именно это и делает его замыканием: оно сохраняет ссылку на лексическое окружение, в котором было создано.

Аналогичная картина наблюдается и в языке Kotlin, где лямбда-выражения обладают теми же свойствами. Рассмотрим пример:

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

val counter = makeCounter()
println(counter()) // 1
println(counter()) // 2
println(counter()) // 3

xxxxxxxxxx

fun makeCounter(): () -> Int {

    var count = 0

    return {

        count += 1

        count

    }

}

​

val counter = makeCounter()

println(counter()) // 1

println(counter()) // 2

println(counter()) // 3

В этом примере поведение абсолютно аналогично Swift: переменная count, объявленная внутри функции makeCounter, остаётся доступной для замыкания, возвращённого этой функцией. Несмотря на то, что выполнение функции завершилось, лямбда продолжает использовать переменную, которая уже вроде как должна была исчезнуть. Это становится возможным благодаря механизму замыканий, при котором компилятор и рантайм сохраняют ссылку на переменные из внешнего контекста.

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

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

Недостатки замыканий

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

1. Удержание в памяти переменных — риск утечки памяти

Замыкание захватывает переменные из внешнего контекста. Если оно где-то сохраняется и продолжает жить, эти переменные тоже остаются в памяти. Это может привести к утечке памяти, особенно если захвачены тяжёлые объекты (например, UI-элементы).

class MyController {
    var onEvent: (() -> Void)?

    func setup() {
        onEvent = {
            print(self) // замыкание захватывает self
        }
    }
}

xxxxxxxxxx

class MyController {

    var onEvent: (() -> Void)?

​

    func setup() {

        onEvent = {

            print(self) // замыкание захватывает self

        }

    }

}

Если self захвачен сильно (strong), объект MyController никогда не освободится из памяти.

Решение: использовать [weak self] или [unowned self] в Swift, или WeakReference в других языках.

2. Скрытая логика и неявное состояние

Замыкание может содержать состояние, которое не видно снаружи, и это усложняет отладку и понимание кода.

val counter = run {
    var count = 0
    { ++count }
}

xxxxxxxxxx

val counter = run {

    var count = 0

    { ++count }

}

Здесь кажется, что counter — просто функция, но она имеет внутреннее состояние. Это может путать других разработчиков.

3. Сложности с отладкой

При отладке сложно посмотреть на переменные, захваченные в замыкании, особенно в некоторых IDE или при компиляции в production-режиме. Поведение может быть неожиданным, особенно если замыкание долго живёт или выполняется асинхронно.

4. Непотокобезопасность

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

5. Сложнее тестировать

Замыкания со скрытым состоянием или зависимостями из внешнего контекста сложно изолировать и тестировать. Это нарушает принцип явности (explicit is better than implicit).

6. Переиспользование и масштабируемость

Для сложной логики замыкание может оказаться неудобным — его нельзя расширить, у него нет интерфейсов или наследования (в отличие от классов). Добавить туда логику сброса, логирования или отладки — сложно.

Чем можно заменить замыкание

Замыкания — удобный инструмент, но в некоторых языках (или архитектурах) можно добиться того же эффекта другими способами. Вот основные альтернативы:

1. Классы или структуры с внутренним состоянием

Альтернатива для: хранения состояния между вызовами

Пример на Swift:

class Counter {
    private var count = 0

    func increment() -> Int {
        count += 1
        return count
    }
}

let counter = Counter()
print(counter.increment()) // 1
print(counter.increment()) // 2

xxxxxxxxxx

class Counter {

    private var count = 0

​

    func increment() -> Int {

        count += 1

        return count

    }

}

​

let counter = Counter()

print(counter.increment()) // 1

print(counter.increment()) // 2

Плюс: лучше читается в ООП, легко масштабируется
Минус: громоздко для простых задач, больше кода

2. Функция с явным параметром состояния

Альтернатива — чистая функция без скрытого состояния:

fun increment(count: Int): Int {
    return count + 1
}

var current = 0
current = increment(current) // 1
current = increment(current) // 2

xxxxxxxxxx

fun increment(count: Int): Int {

    return count + 1

}

​

var current = 0

current = increment(current) // 1

current = increment(current) // 2

Плюс: идеально в функциональном стиле, никаких скрытых зависимостей
Минус: всё состояние надо явно передавать

3. Статическая переменная или глобальное состояние

Если хочется «запомнить» что-то между вызовами, но не хочется писать классы:

def counter():
    counter.count += 1
    return counter.count
counter.count = 0

print(counter())  # 1
print(counter())  # 2

xxxxxxxxxx

def counter():

    counter.count += 1

    return counter.count

counter.count = 0

​

print(counter())  # 1

print(counter())  # 2

Плюс: просто
Минус: не потокобезопасно, сложнее тестировать

4. Функциональные объекты (callable objects)

Вместо замыкания можно сделать объект с методом __call__ (в Python) или перегрузить оператор invoke (в Kotlin):

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

c = Counter()
print(c())  # 1
print(c())  # 2

xxxxxxxxxx

class Counter:

    def __init__(self):

        self.count = 0

​

    def __call__(self):

        self.count += 1

        return self.count

​

c = Counter()

print(c())  # 1

print(c())  # 2

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