Замыкание (программирование)
Замыкание (англ. closure ) в программировании — процедура или функция, в теле которой присутствуют ссылки на переменные, объявленные вне тела этой функции и не в качестве её параметров (а в окружающем коде). Говоря другим языком, замыкание — это процедура или функция, которая ссылается на свободные переменные в своём лексическом контексте.
Замыкание, так же как и экземпляр объекта, есть способ представления функциональности и данных, связанных и упакованных вместе.
Замыкание — это особый вид функции. Она определена в теле другой функции и создаётся каждый раз во время её выполнения. В записи это выглядит как функция, находящаяся целиком в теле другой функции. При этом вложенная внутренняя функция содержит ссылки на локальные переменные внешней функции. Каждый раз при выполнении внешней функции происходит создание нового экземпляра внутренней функции, с новыми ссылками на переменные внешней функции.
В случае замыкания ссылки на переменные внешней функции действительны внутри вложенной функции до тех пор, пока работает вложенная функция, даже если внешняя функция закончила работу, и переменные вышли из области видимости. [1]
Замыкание связывает код функции с её лексическим окружением (местом, в котором она определена в коде). Лексические переменные замыкания отличаются от глобальных переменных тем, что они не занимают глобальное пространство имён. От переменных в объектах они отличаются тем, что привязаны к функциям, а не объектам.
Содержание
Реализации замыкания в языках программирования
Pascal
Пример работы замыканий на Pascal (Delphi c 2009 версии):
В версиях начиная с 2009, этот код выведет в Memo строки First и Second. Когда переменной типа reference to *** присваивается совместимая по спецификации анонимная подпрограмма или метод, неявно создаётся и инициализируется экземпляр анонимного класса, с полями для хранения значений, используемых подпрограммой из контекста её объявления, методом выполнения (присвоенной подпрограммой) и счётчиком ссылок.
Scheme
Пример работы замыканий на Scheme:
Анонимные методы в C# 2.0 могут замыкаться на локальный контекст:
Функция Array.ConvertAll преобразует один список/массив в другой, применяя для каждого элемента передаваемую ей в качестве параметра функцию.
В C# 3.0 введены лямбда-выражения, которые делают синтаксис анонимных методов более кратким и выразительным. Соответственно, они также поддерживают замыкания. То есть, замыкания в C# 3.0 практически аналогичны анонимным функциям из C# 2.0, но синтаксически более кратки. Вот тот же пример с применением лямбда-выражений в C# 3.0:
Метод Select аналогичен методу Array.ConvertAll за тем исключением, что он принимает и возвращает IEnumerable<T>.
В языке C++ замыкание долгое время не поддерживалось. Однако новый стандарт языка C++11 вводит лямбда-функции и выражения, ограниченно поддерживающие замыкание:
VB.NET
В VB.NET 9.0 лямбда-функции могут быть только однострочными. Начиная с версии 10.0, можно использовать синтаксис для описания многострочных лямбда-функций.
Некоторые языки, такие как Ruby, позволяют выбирать различные способы замыканий по отношению к оператору возврата return . Вот пример на Ruby:
И Proc.new , так же как и lambda , в этом примере — это способы создания замыкания, но семантика замыканий различна по отношению к оператору return .
PHP имеет встроенную поддержку замыканий начиная с версии 5.3. Пример замыкания. Локальная переменная $id будет увеличиваться при вызове возвращаемой функцией getAdder вложенной функции:
Для более ранних версий возможно использовать одноименный шаблон проектирования, который реализуется в библиотеке Николаса Нассара. P.S. Однако, до сих пор существует проблема с замыканиями в классах, в частности — для статических методов класса.
Java реализует концепцию замыкания с помощью анонимных классов. Анонимный класс имеет доступ к полям класса, в лексическом контексте которого он определён, а также к переменными с модификатором final в лексическом контексте метода.
Предполагалось, что версия Java-7 будет включать полную поддержку концепции замыканий, которые официально должны были называться «лямбда-выражения» (Lambda expressions), но этого не произошло. Теперь поддержка «лямбда-выражений» заявлена в версии Java-8 [2] .
Python
Пример с использованием замыканий и карринга:
Пример простого замыкания:
JavaScript
В JavaScript областью видимости локальных переменных (объявляемых словом var) является тело функции, внутри которой они определены. [3]
Если вы объявляете функцию внутри другой функции, первая получает доступ к переменным и аргументам последней:
При этом, такие переменные продолжают существовать и остаются доступными внутренней функции даже после того, как внешняя функция, в которой они определены, была исполнена.
Рассмотрим пример — функцию, возвращающую количество собственных вызовов:
Пример с использованием замыканий на Perl:
Пример с использованием замыканий на Lua:
Haskell
В Haskell замыкания используются повсеместно в виде частичного применения аргументов к функциям (также известного как каррирование).
Определение функции «sum3» напоминает следующий код на C:
На самом деле «sum3» эквивалентна функции «sum3_desugared», по определению которой видно, что «sum3_desugared» принимает один аргумент «x» и возвращает новую функцию со связанной переменной «x». Новая функция также принимает только один аргумент «y» и возвращает функцию от одного аргумента «z».
Псевдоопределение таких функций выглядит следующим образом («bounded» — это некоторые фиксированные значения, которые неявно хранятся вместе с функциями):
Такой подход очень часто применяется для создания «специализированных» функций из более общих:
Для удобства использования общих функций рекомендуют располагать в них параметры в порядке от общих к частным. Например, сначала принимать функцию-обработчик перед самими данными.
Smalltalk
Пример с использованием замыкания на Smalltalk:
Выполнение метода создает замыкание, при использовании которого будет происходить сравнение произвольного аргумента each и связанного значения aComparator.
MATLAB
Пример реализации замыкания в MATLAB с использованием nested функций:
Пример реализации замыкания в MATLAB с использованием анонимных функций:
Objective-C
Пример реализации замыкания в Objective-c с использованием блоков(blocks):
Common LISP
См. также
Примечания
- ↑Blocks Can Be Closures — Containers, Blocks, and Iterators — Programming Ruby. The Pragmatic Programmer’s Guide.
- ↑OpenJDK: Project Lambda
- ↑ Владимир Агафонкин Замыкания в JavaScript
 |
- Концепции языков программирования
Wikimedia Foundation . 2010 .
Полезное
Смотреть что такое «Замыкание (программирование)» в других словарях:
Замыкание (математика) — Замыкание: Термины В математике Замыкание (геометрия) Алгебраическое замыкание поля Оператор замыкания Замыкание отношения Замыкание относительно операции Замыкание (программирование) подпрограмма, сохраняющая контекст (привязку к переменным)… … Википедия
Замыкание множества — Замыкание: Термины В математике Замыкание (геометрия) Алгебраическое замыкание поля Оператор замыкания Замыкание отношения Замыкание относительно операции Замыкание (программирование) подпрограмма, сохраняющая контекст (привязку к переменным)… … Википедия
Замыкание — В Викисловаре есть статья «замыкание» Замыкание процесс или результат действия, сводящегося к ограничению или спрямлению чего либо … Википедия
Функциональное программирование на Питоне — Функциональное программирование является одной из парадигм, поддерживаемых языком программирования Python. Основными предпосылками для полноценного функционального программирования в Python являются: функции высших порядков, развитые средства… … Википедия
Функциональное программирование на Python — Функциональное программирование является одной из парадигм, поддерживаемых языком программирования Python. Основными предпосылками для полноценного функционального программирования в Python являются: функции высших порядков, развитые средства… … Википедия
Функциональная зависимость (программирование) — Функциональная зависимость концепция, лежащая в основе многих вопросов, связанных с реляционными базами данных, включая, в частности, их проектирование. Математически представляет бинарное отношение между множествами атрибутов данного… … Википедия
Продолжение (программирование) — Продолжение (англ. continuation) представляет состояние программы в определённый момент, которое может быть сохранено и использовано для перехода в это состояние. Продолжения содержат всю информацию, чтобы продолжить выполнения программы с… … Википедия
ECMAScript — Класс языка: мультипарадигменный: объектно ориентированное, обобщённое, функциональное, императивное, аспектно ориентированное, событийно ориентированное, прототипное программирование Появился в: 1995 Автор(ы) … Википедия
Лямбда-выражения — Лямбда выражение (в программировании) это специальный синтаксис для объявления анонимных функторов по месту их использования. Используя лямбда выражения, можно объявлять функции в любом месте кода. Обычно лямбда выражение допускает… … Википедия
Лямбда-выражение — В программировании лямбда или лямбда выражения это безымянная функция, объявляемая по месту ее непосредственного использования. Обычно лямбда допускает замыкание на лексический контекст, в котором она объявлена. Смотри также Лямбда исчисление… … Википедия
Изучаем замыкания в JavaScript
Замыкания — это базовая концепция JavaScript, которая сбивает с толку многих новичков, тем не менее её должен знать и понимать каждый разработчик.
Правильное представление о замыканиях поможет вам писать более эффективный и «чистый» код, чтобы стать отличным JavaScript разработчиком.
В этой статье я попробую объяснить, как устроены замыкания и как они работают в JavaScript.
Начнём без промедлений ��
Что такое замыкание?
Замыкание — это функция, которая имеет доступ к своему внешнему окружению, даже после того, как внешняя функция возвращена. Другими словами — замыкание помнит и имеет доступ к переменным и аргументам внешней функции, даже после её завершения.
Перед тем как продолжить, давайте разберёмся с лексической областью видимости.
Что такое лексическая область видимости?
Лексическая или статическая область видимости в JavaScript относится к понятиям доступности переменных, функций и объектов в зависимости от их физического расположения в исходном коде. Пример:
Здесь, функция inner имеет доступ к переменным, определённым в её собственной области видимости, а также в функции outer и глобально. И функция outer имеет доступ к переменным, определённым в собственном пространстве видимости и глобально.
Иерархия областей видимости в этом коде выглядит так:
Обратите внимание, что функция inner окружена лексической областью видимости функции outer , которая в свою очередь окружена глобальной областью видимости. Вот почему функция inner может получить доступ к переменным, определённым в функции outer , а также в глобальном пространстве.
Практические примеры замыкания
Давайте рассмотрим практические примеры замыканий, перед тем как начнем разбираться в их устройстве.
Пример №1
В этом коде мы вызываем функцию person , которая возвращает внутреннюю функцию displayName и сохраняет её в переменной peter . Когда мы вызываем функцию peter (она ссылается на функцию displayName ), в консоли выводится имя ‘Peter’.
Обратите внимание, что в функции displayName нет переменной name , т.е. эта функция как-то получает доступ к своей внешней функции person , даже после того, как та функция возвращена. Поэтому функция displayName и является замыканием.
Пример №2
И снова мы сохраняем анонимную внутреннюю функцию, возвращённую функцией getCounter в переменную count . Так как теперь функция count является замыканием, у неё есть доступ к переменной counter функции getCounter , даже после завершения getCounter() .
Обратите внимание, что значение counter не сбрасывается на 0 при каждом вызове функции count , как это обычно бывает.
Так происходит потому, что при каждом вызове count() для неё создаётся новая область видимости. Но для функции getCounter существует только одна область видимости, потому что переменная counter определена в пространстве getCounter() . Её значение будет увеличиваться при каждом вызове функции count , а не обнуляться.
Как работают замыкания?
Мы говорили о том, что такое замыкания и как они применяются на практике. Теперь давайте разберёмся, как они работают в JavaScript.
Чтобы в полной мере понять, как работают замыкания в JavaScript, необходимо знать два наиболее важных понятия: 1) контекст исполнения и 2) лексическое окружение.
Контекст исполнения
Это абстрактное окружение, где код JavaScript оценивается и исполняется. Когда глобальный код выполняется, это происходит в глобальном контексте, а код функции выполняется в контексте функции.
В текущий момент может быть только один контекст исполнения (потому что JavaScript — однопоточный язык). Этот процесс управляется структурой данных стека, известным как Execution Stack или Call Stack.
Execution Stack — это стек со структурой LIFO (Last in, first out), в котором элементы могут быть добавлены или удалены только с верху стека.
Текущий контекст исполнения всегда находиться в верхней части стека. После выполнения текущей функции, её контекст исполнения «вылетит» из стека, а контроль перейдёт к следующему, под ним в стеке.
Давайте разберём фрагмент кода, чтобы лучше понимать контекст исполнения и стек:
После выполнения этого кода, движок JavaScript создаёт глобальный контекст исполнения, чтобы выполнить глобальный код. Когда JS встречает вызов функции first() , он создаёт новый контекст исполнения для этой функции, и «проталкивает» его на верх стека.
Стек исполнения для этого кода выглядит вот так:
Когда функция first() завершена, она удаляется из стека. Управление переходит к следующему контексту, в этом случае, к глобальному контексту исполнения. Оставшийся код будет выполнен в глобальном пространстве.
Лексическое окружение
Каждый раз, когда движок JavaScript создаёт контекст исполнения, чтобы выполнить функцию или глобальный код, он также создаёт новое лексическое окружение для хранения переменных, определённых в этой функции в процессе её исполнения.
Лексическое окружение — это структура данных, которая содержит карту соответствий идентификатор-переменная. В ней идентификатор ссылается на имя переменной/функции, а переменная на сам объект (включая функциональный объект) или на примитивное значение.
В лексическом окружении есть два компонента: 1) запись о внешних условиях и 2) ссылка на внешнюю среду.
1. Запись о внешних условиях — это фактическое место, где хранятся объявления переменных и функций.
2. Ссылка на внешнюю среду — означает наличие доступа к внешнему (родительскому) лексическому окружению. Этот компонент очень важен для понимания работы замыканий.
Концептуально лексическое окружение выглядит так:
Давайте ещё раз посмотрим на предыдущий фрагмент кода:
Когда движок JavaScript создаёт глобальный контекст исполнения, для выполнения глобального кода, он также создаёт новое лексическое окружение в глобальном пространстве. Лексическое окружение для глобального пространства выглядит так:
Здесь для лексического окружения установлен null , потому что нет внешнего лексического окружения для глобального пространства.
Когда движок создаёт контекст исполнения для функции first() , он также создаёт лексическое окружение для хранения переменных, определённых в процессе выполнения функции. Лексическое окружение функции выглядит так:
Для внешнего лексического окружения функции установлено глобальное лексическое окружение, потому что функция окружена глобальным пространством в исходном коде.
Примечание
После выполнения функции, её контекст исполнения удаляется из стека. Но удалится ли её лексическое окружение из памяти, зависит от того, ссылается ли на него другое лексическое окружение, в свойствах их внешнего окружения.
Примеры замыканий. В деталях
Теперь, когда мы разобрались с контекстом исполнения и лексическим окружением, вернёмся к замыканиям.
Пример №1
Разберём этот код:
После выполнения функции person , движок JavaScript создаёт новый контекст исполнения и лексическое окружение для функции. После её завершения, мы возвращаем функцию displayName и присваиваем её к переменной peter .
Её лексическое окружение выглядит так:
Когда функция person завершена, её контекст исполнения удаляется из стека. Но её лексическое окружение остаётся в памяти, потому что на него ссылается лексическое окружение внутренней функции displayName . Поэтому её переменные всё ещё доступны в памяти.
Когда функция peter выполнена (она является отсылкой к функции displayName ), движок создаёт новый контекст исполнения и лексическое окружение для этой функции.
Её лексическое окружение выглядит так:
Так как в функции displayName нет переменных, её запись о внешних условиях будет пустой. В процессе выполнения этой функции, движок JavaScript попытается найти переменную name , в её лексическом окружении.
Так как в лексическом окружении функции displayName нет переменных, JS будет смотреть во внешнем окружении, а именно, в лексическом окружении функции person , которая всё ещё в памяти. Движок JavaScript найдёт переменную и выведет name в консоли.
Пример №2
И снова лексическое окружение. Для функции getCounter оно выглядит так:
Она возвращает анонимную функцию и присваивает её переменной count .
После выполнения функции count , её лексическое окружение выглядит так:
Когда вызвана функция count , движок JavaScript будет искать переменную counter в лексическом окружении этой функции. И снова, запись окружения пуста, поэтому движок будет смотреть во внешнем лексическом окружении функции.
Движок найдёт переменную, выведет её в консоли и инкрементирует переменную счётчик в лексическом окружении функции getCounter .
После первого вызова функции count , лексическое окружение для функции getCounter будет выглядеть так:
При каждом вызове функции count , движок JavaScript создаёт для неё новое лексическое окружение, инкрементирует переменную counter и обновляет лексическое окружение функции getCounter , чтобы отразить изменения.
Заключение
Теперь вы знаете, что такое замыкания и как они работают. Замыкания — это базовая концепция JavaScript, которую должен понимать каждый JS разработчик. Эти знания помогут вам быть более эффективным в разработке.
Замыкание в C#
5064
Введение
Замыкание, как правило, используется функциональными языками программирования, где они связывают функцию с определенным типом параметров, это позволяет дать доступ к переменным, находящимся за пределами границы функции. С использованием делегатов замыкание доступно в С#.
Что такое Замыкание?
Чаще всего, лексика замыкания используется в функциональных языках программирования. Замыкание – это специальный тип функции, с помощью которого она ссылается на свободные переменные. Это позволяет замкнутым функциям использовать переменные из внешнего окружения, несмотря на то что они не входят в границы. Когда функция создана, внешние переменные, которыми мы пользуемся, «захватываются», иными словами, они связаны с замкнутой функцией, так что они становятся доступными. Часто это обозначает то, что делаются копии значений переменных, когда инициализируется замыкание.
Использование замыкания в С#
В С# замыкание может быть создано с помощью анонимного метода или лямбда-выражения, все зависит от версии .NET framework, на которой вы разрабатываете. Когда вы создаете функцию, переменные, что используются в ней и находятся за областью видимости, скопированы и хранятся в коде с замыканием. Они могут использоваться везде, где вы вызовете оператор delegate. Это дает огромную гибкость при использовании делегатов, но также создает возможность неожиданных багов. К этому мы вернемся позже. А пока, давайте рассмотрим простой пример замыкания.
В коде, который ниже, мы создаем переменную «nonLocal» типа integer. Во второй строчке создаем экземпляр делегата «Action», что выводит в сообщение значение переменной типа integer. В конце мы запускаем функцию-делегат, чтобы увидеть сообщения.
int nonLocal = 1;
Action closure = delegate
Console.WriteLine( " <0>+ 1 = <1>" , nonLocal, nonLocal + 1);
closure(); // 1 + 1 = 2
Мы можем сделать то же самое с лямбда-выражением. В следующем коде мы используем «lambda» для вывода информации, при этом лямбда-выражение имеет одинаковую силу.
int nonLocal = 1;
Console.WriteLine( " <0>+ 1 = <1>" , nonLocal, nonLocal + 1);
closure(); // 1 + 1 = 2
Тема связана со специальностями:
Замыкания и переменные за пределами
С помощью анонимных методов или лямбда-выражения примеры выше,при этом получаем те результаты, что вы могли ожидать, так как захват переменных замыканием не очевиден сразу же. Мы можем сделать его более явным, изменяя пределы делегатов.
Рассмотрим следующий код. Здесь замыкание находится в классе «program» с переменной «action». В главном методе вызываем метод «SetUpClosure» для инициализации замыкания перед его использованием. Метод «SetUpClosure» очень важен. Вы можете увидеть, что переменная типа integer создана и инициализирована, и только тогда используется замыкание. В конце метода «SetUpClosure» эта переменная типа integer выходит за пределы. Однако, мы все еще вызываем делегат после этого. Скомпилируется и запустится ли этот код правильно? Произошло ли исключение при получении доступа к переменной за пределами? Попробуйте выполнить код.
static Action _closure;
static void Main( string [] args)
_closure(); // 1 + 1 = 2
private static void SetUpClosure()
int nonLocal = 1;
Console .WriteLine( " <0>+ 1 = <1>" , nonLocal, nonLocal + 1);
Вы могли заметить, что мы получили одинаковый результат как и в оригинальном примере. Это и есть замыкание в действии. Переменная «nonLocal» была охвачена или «замкнута» кодом delegate, в результате чего она остается в нормальных пределах. По сути, переменная будет доступна, пока никаких дальнейших ссылок на делегат не останется.
Несмотря на то, что мы увидели замыкание в действии, они не поддерживаются С# и .NET framework. То, что действительно происходит — это работа на заднем фоне компилятора. Когда вы создаете собственные проекты, компилятор генерирует новые, скрытые классы, инкапсулируют нелокальную переменную и описанный код в анонимный метод или лямбда-выражение. Код, описанный в методе, и нелокальная переменная представлены в виде полей. Этот новый метод класса вызовется, когда делегат выполняется.
Автоматически сгенерированный класс для нашего простого замыкания — аналогичный приведенному ниже:
private sealed class <>c__DisplayClass1
public int nonLocal;
public void b__0()
Console.WriteLine( " <0>+ 1 = <1>" , this .nonLocal, this .nonLocal + 1);
Видео курсы по схожей тематике:
Выполнение домашнего задания по курсу C# Стартовый
Unit тестирование в C#
Асинхронное программирование в C# 5
Замыкание захватывает переменную, а не его значение
В некоторых языках программирования определяют значение переменной, которая используется в замыкании. В С# захватываются сами переменные. Это важное отличие, так как мы можем изменять значение переменной за пределами функции. Для иллюстрации рассмотрим следующий код. Здесь мы создаем замыкание, которое выводит наше начальное математическое значение переменной. При создании делегатов значение переменной типа integer равно 1. Но после того замыкания, как мы объявили замыкание, и перед тем, как его вызвали, значение переменной поменялось на 10.
int nonLocal = 1;
Action closure = delegate
Console.WriteLine( " <0>+ 1 = <1>" , nonLocal, nonLocal + 1);
Так как нелокальная переменная имела значение 1 перед созданием замыкания, вы могли бы ожидать, что результатом вывода будет «1+1=2». На самом деле, на других языках программирования так бы и было. Однако, так как мы изменили значение переменной до вызова функции замыкания, это значение влияет на выполнение функции замыкание. В действительности, вы увидите на дисплее:
Изменения в нелокальную переменную внутри функции замыкания также передаются в другом направлении. В следующем коде внутри делегата изменяем значение переменной перед тем, как объявленный код выведет ее. Изменения видны во внешней части кода несмотря на то, что происходят они внутри замыкания.
int nonLocal = 1;
Action closure = delegate
Переменная, которую мы изменяем, может привести нас к неожиданным багам в нашем коде. Мы можем продемонстрировать эту проблему в другом примере. На этот раз мы используем замыкание в простом алгоритме: многопоточное или параллельное программирование. Код ниже показывает цикл for, который имеет 5 новых потоков. Каждая пауза короткая, перед выводом значения переменной внутри цикла. Если значение переменной в цикле были захвачены, мы увидим цифры от 1 до 5 показаны в консоли, хотя, возможно, не в правильном порядке. Однако, так как эта переменная находится внутри замыкания и цикл закончится до того, как переменные будут выведены в сообщение, в конечном итоге мы увидим значение 6 для каждого потока.
for ( int i = 1; i <= 5; i++)
new Thread( delegate ()
К счастью, такая проблема легко устраняется, когда вы понимаете, что переменные, а не их значения захватываются. Все, что нам нужно сделать, это создать новую переменную для каждого прохождения(итерации) цикла. Это объявление можно записать в теле цикла и давать значение в управляющую переменную. При нормальных обстоятельствах временная переменная будет находится за переделами, когда цикл закончится, но замыкание будет связывать и поддерживать ее.
Бесплатные вебинары по схожей тематике:
Начало работы с ASP.NET Web API 2.0
Создание 2D игры «Гонки» на C# + WPF.
CIL&C# Перегрузка методов по возвращаемому значению
В коде ниже вы можете увидеть 5 примеров «значений», переменные, созданные и им назначенные 5 различных значений, каждая из них привязана к разному потоку.
for ( int i = 1; i <= 5; i++)
new Thread( delegate ()
Обратите внимание: вывод может меняться в зависимости от порядка, в котором потоки выполняются.