Замыкание что такое: Замыкания в JavaScript для начинающих | by Nikita | WebbDEV

Если вы не хотите использовать больше замыканий, вы можете использовать ключевое слово let , представленное в ES2015:

  function showHelp (help) {
  document.getElementById ('справка'). textContent = help;
}

function setupHelp () {
  var helpText = [
      {'id': 'email', 'help': 'Ваш адрес электронной почты'},
      {'id': 'name', 'help': 'Ваше полное имя'},
      {'id': 'age', 'help': 'Ваш возраст (вы должны быть старше 16 лет)'}
    ];

  for (пусть i = 0; i  длина; i ++) {
    let item = helpText [i];
    document.getElementById (item.id) .onfocus = function () {
      showHelp (item.help);
    }
  }
}

setupHelp ();  

В этом примере используется let вместо var , поэтому каждое замыкание связывает переменную с блочной областью видимости, что означает, что никаких дополнительных замыканий не требуется.

Другой альтернативой может быть использование forEach () для перебора массива helpText и присоединения слушателя к каждому , как показано:

  function showHelp (help) {
  документ.getElementById ('помощь'). textContent = help;
}

function setupHelp () {
  var helpText = [
      {'id': 'email', 'help': 'Ваш адрес электронной почты'},
      {'id': 'name', 'help': 'Ваше полное имя'},
      {'id': 'age', 'help': 'Ваш возраст (вы должны быть старше 16 лет)'}
    ];

  helpText.forEach (function (text) {
    document.getElementById (text. id) .onfocus = function () {
      showHelp (text.help);
    }
  });
}

setupHelp ();  

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

Например, при создании нового объекта / класса методы обычно должны быть связаны с прототипом объекта, а не определены в конструкторе объекта. Причина в том, что всякий раз, когда вызывается конструктор, методы будут переназначены (то есть для каждого создания объекта).

Рассмотрим следующий случай:

  function MyObject (имя, сообщение) {
  this.name = name.toString ();
  this.message = message.toString ();
  this.getName = function () {
    верни это.имя;
  };

  this.getMessage = function () {
    вернуть this.message;
  };
}
  

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

  function MyObject (имя, сообщение) {
  this. name = name.toString ();
  this.message = message.toString ();
}
MyObject.prototype = {
  getName: function () {
    вернуть this.name;
  },
  getMessage: function () {
    верни это.сообщение;
  }
};
  

Однако переопределять прототип не рекомендуется. Следующий пример вместо этого добавляется к существующему прототипу:

  function MyObject (имя, сообщение) {
  this.name = name.toString ();
  this.message = message.toString ();
}
MyObject.prototype.getName = function () {
  вернуть this.name;
};
MyObject.prototype.getMessage = function () {
  вернуть this.message;
};
  

В двух предыдущих примерах унаследованный прототип может использоваться всеми объектами, и определения методов не обязательно должны появляться при создании каждого объекта.См. Подробности об объектной модели для получения дополнительной информации.

c ++ - Каждая функция закрывается?

- это эффективный способ реализации функций .

Я утверждаю, что каждая функция концептуально закрытие, даже на нескольких языках, в которых их нет.

^{Закрытые переменные являются константами или статическими данными внутри кода. Но в полноценных замыканиях (например, в Ocaml, Scheme, Common Lisp или C ++ 11) закрытые переменные и код находятся в самом закрытии.}

Например, в C (и в C ++ 98) функции являются замыканиями, но их закрытые (или свободные ) переменные ограничены статическими или глобальными переменными.

Closures также дает возможность для анонимных функций, например лямбда-выражения, которые создают замыкания с новыми закрытыми переменными (а это невозможно в стандартном C). Это абстракция , операция λ-исчисления (которой нет в C, поэтому каждая функция обратного вызова -e.грамм. в GTK- принимает некоторые "данные клиента" как дополнительный параметр).

С точки зрения реализации, функция всегда представляет собой некоторый код с некоторыми данными, необходимыми для этого кода. Данные - это закрытые переменные. Для скомпилированного кода C данные связаны в коде как фиксированные глобальные или статические переменные (и изменение этих переменных требует перекомпиляции) или как буквальные константы. Таким образом, единственный способ сделать абстракцию - это регенерировать некоторый новый код с некоторыми новыми переменными в нем.

Абстракция не существует в стандарте C, потому что нет способа генерировать переносимые новые функции. Но вы можете использовать странные уловки, зависящие от конкретной реализации. Представьте, что вы хотите реализовать функцию генератора переводов. В ocaml функция для генерации переведенной на дельта функции -

  позвольте перевести дельту = веселье x -> x + delta
  

, и это создает новое закрытие для каждого вызова. Так в

  пусть t3 = transl 3 в t3 5
  

создается новое закрытие t3 (но, возможно, оптимизатор удаляет его), и результат равен 8 (что составляет 3 + 5).

Вы можете проделывать безумные трюки в C: в Linux, например, сгенерирует во время выполнения новый текстовый файл t3mod.c , содержащий

  int t3 (int y) {вернуть y + 3; };
  

, и вы скомпилируете этот файл t3mod.c в общий объект t3mod.so и dlopen , а затем dlsym , используя "t3" . Этот надуманный способ (использование генерации кода C во время выполнения с последующей его динамической загрузкой) представляет собой способ реализации абстракций в C и способ динамически генерировать новых указателей на функции.Точно так же вы можете использовать библиотеки компиляции JIT, например, libjit, LLVM (или libgccjit в будущем GCC 5). Прочтите также о частичной оценке, eval и многоэтапном программировании (например, Meta OCaml ...). См. Также записи в блоге Дж. Питрата о мета-комбинаторном поиске и мета-ошибках.

- Являются ли методы класса типом закрытия?

Являются ли методы класса типом закрытия?

Нет. Закрытие - это очень специфический тип функции.Как говорит Википедия, они реализуют лексическую область видимости.

Укупорочные средства

В Python такое закрытие выглядело бы так:

  по умолчанию startAt (x):
    def incrementBy (y):
        вернуть x + y
    return incrementBy
  

Переменная x связана (в случае Python - неизменяемо) в incrementBy , который создается при вызове startAt . ( x вполне может быть изменяемой структурой данных , либо реализация вашего языка может позволить вам изменить ее.)

Для сравнения, вот пример функции без закрытия, в которой используется глобальный:

  х = 0
def incrementBy (y):
    вернуть x + y
  

Здесь есть одна функция, incrementBy , и всякий раз, когда x изменяется в глобальной области видимости, это отражается в функции:

  >>> incrementBy (5)
5
>>> х = 1
>>> incrementBy (5)
6
  

Методы

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

Вы, , можете сделать закрытие метода, добавленного к классу, в зависимости от реализации вашего языка:

  класс Foo (объект):
    ib5 = статический метод (startAt (5))

>>> Фу.ib5 (3)
8
>>> Foo.ib5
<приращение функции по адресу 0x7f29e978b758>
  

Но я не думаю, что вы на самом деле хотите это сделать.

Что такое закрытие?

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

Сравнение и противопоставление методов закрытия

Их объединяет функциональность и данные.

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

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

Что такое закрытие? - Calhoun.io

В предыдущей статье о тестировании с Go есть пример, в котором замыкание используется для создания тестов, управляемых таблицами.Это довольно распространенная практика в Go, но после написания статьи разработчик связался со мной и сделал следующий комментарий.

«Я кое-что узнал. В основном то, что я понятия не имею, как работают замыкания в Go »

Ой! Это означает, что, несмотря на то, что остальная часть статьи наполнена отличным контентом о тестировании, если читатель не понимает закрытия, он не сможет получить от статьи все преимущества.

Этот пост предназначен для решения этой проблемы.В нем мы собираемся обсудить, что такое замыкания и почему вы должны заботиться о них. Затем в следующей статье «5 полезных способов использования замыканий в Go» (избыточных, я знаю) мы рассмотрим некоторые из наиболее распространенных вариантов использования замыканий, чтобы помочь вам понять, где и когда использовать замыкания в вашем собственном коде. У каждого варианта использования есть конкретный пример, с которым я столкнулся, так что это не просто воображаемое использование.

Анонимные функции

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

Как и большинство вещей, это проще объяснить с помощью кода. Ниже показано, как будет выглядеть обычная функция.

  func DoStuff () {
  // Делаем что-нибудь
}
  

Если бы мы хотели превратить эту же функцию в анонимную, мы бы не объявляли ее таким же образом; вместо того, чтобы начинать с ключевого слова func , мы могли бы вместо этого создать переменную с типом func () . После этого мы могли создать и назначить анонимную функцию переменной.

  var DoStuff func () = func () {
  // Делаем что-нибудь
}
  

Между этими двумя есть много тонких различий, но для большинства практических целей большая разница заключается в том, что мы могли назначить новую функцию переменной DoStuff во время выполнения, что позволяет нам динамически изменять то, что делает DoStuff () . .

  пакет основной

импорт "FMT"

var DoStuff func () = func () {
  // Делаем что-нибудь
}

func main () {
  DoStuff ()

  DoStuff = func () {
    fmt.Println ("Делаю что-нибудь!")
  }
  DoStuff ()

  DoStuff = func () {
    fmt.Println ("Занимаюсь другими делами.")
  }
  DoStuff ()
}
  

Если вы запустите эту программу, вы увидите следующий результат.

 Делаем всякие!
Занимаюсь другими делами.
 

Мы видим две разные строки вывода, потому что мы объявили три разные анонимные функции, и каждая из последних двух выводит что-то свое.

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

  пакет основной

импорт "FMT"

var DoStuff func () = func () {
// Делаем что-нибудь
}

func RegFunc () {fmt.Println ("reg func")}

func main () {
DoStuff ()
DoStuff = RegFunc
DoStuff ()
}
  

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

затворы

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

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

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

  пакет основной

импорт "FMT"

func main () {
  п: = 0
  counter: = func () int {
    п + = 1
    вернуть n
  }
  fmt.Println (counter ())
  fmt.Println (counter ())
}
  

Если вы запустите этот код, вы получите результат:

Обратите внимание, что наша анонимная функция имеет доступ к переменной n , но она никогда не передавалась в качестве параметра при вызове counter () .Это то, что делает его закрытием!

Замыкания обеспечивают изоляцию данных

Одна проблема с предыдущим примером - проблема, которая также может всплывать при использовании глобальных переменных. Любой код внутри функции main () имеет доступ к n , поэтому можно увеличивать счетчик без фактического вызова counter () . Мы не этого хотим; Вместо этого мы предпочли бы изолировать n , чтобы никакой другой код не имел к нему доступа.

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

  пакет основной

импорт "FMT"

func main () {
  counter: = newCounter ()
  fmt.Println (counter ())
  fmt.Println (counter ())
}

func newCounter () func () int {
  п: = 0
  return func () int {
    п + = 1
    вернуть n
  }
}
  

В этом примере наше замыкание ссылается на переменную n даже после того, как функция newCounter () завершила работу. Это означает, что у нашего замыкания есть доступ к переменной, которая отслеживает, сколько раз оно было вызвано, но никакой другой код, кроме функции newCounter () , не имеет доступа к этой переменной. Это одно из многих преимуществ замыкания - мы можем сохранять данные между вызовами функций, а также изолировать данные от другого кода.

Хотите улучшить свои навыки игры в го?

Вы хотите попрактиковаться в го, но не можете придумать хороший проект для работы? Или, может быть, вы просто не знаете, какие техники и навыки вам нужно изучить дальше, поэтому не знаете, с чего начать. Если так, не волнуйтесь - я вас прикрыл!

Gophercises - это БЕСПЛАТНЫЙ курс, в котором мы работаем над задачами упражнений, каждая из которых предназначена для того, чтобы научить вас различным аспектам го.Сюда входят темы, начиная от базовых операций со строками и заканчивая более сложными темами, такими как функциональные параметры и параллелизм. В каждом упражнении есть образец решения, а также скринкаст (видео), где я кодирую решение, пока вы по коду показываете. К тому же суслики действительно милые 😉

Вперед…

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

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

Изучите веб-разработку с Go!

Подпишитесь на мою рассылку, и я пришлю вам БЕСПЛАТНЫЙ образец из моего курса - Веб-разработка с Go.Пример включает в себя несколько первых глав из книги и более 2,5 часов скринкастов.

Вы также будете получать от меня электронные письма о предстоящих курсах (включая БЕСПЛАТНЫЕ), новых сообщениях в блогах и скидках на курсы.

© 2018 Джонатан Калхун. Все права защищены.

Определение закрытия по Merriam-Webster

1 : акт закрытия : условие закрытия закрытие век закрытие бизнеса закрытие фабрики

3 : то, что закрывает карман на молнии с защитой от детей

5 : свойство, которое имеет система счисления или множество, когда они математически закрываются при выполнении операции.

6 : набор, который состоит из данного набора вместе со всеми предельными точками этого набора.

Простое объяснение закрытий в JavaScript

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

Затворы, которые используются повсеместно, трудно понять. Если вы еще не пробовали «Ага!» момент в понимании закрытия, тогда этот пост для вас.

Я начну с основных терминов: объем и лексический объем. Затем, усвоив основы, вам понадобится всего один шаг, чтобы окончательно понять замыкания.

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

1. Область применения

Когда вы определяете переменную, вы хотите, чтобы она была доступна в определенных границах. Например. Переменная result имеет смысл существовать в функции calculate () в качестве внутренней детали. Вне calculate () переменная result бесполезна.

Доступность переменных управляется областью .Вы можете получить доступ к переменной, определенной в ее области видимости. Но вне этой области переменная недоступна.

В JavaScript область создается функцией или блоком кода.

Давайте посмотрим, как область действия влияет на доступность переменной count . Эта переменная принадлежит области, созданной функцией foo () :

  function foo () {
  
  пусть count = 0;
  console.log (количество); }

foo ();
console.log (количество);  

count свободно доступно в рамках foo () .

Однако за пределами области foo () счетчик недоступен. Если вы все равно попытаетесь получить доступ к count извне, JavaScript выдает ReferenceError: count is not defined .

В JavaScript область видимости говорит: если вы определили переменную внутри функции или блока кода, то вы можете использовать эту переменную только в этой функции или блоке кода. Приведенный выше пример демонстрирует такое поведение.

Теперь давайте посмотрим на общую формулировку:

Область действия - это политика пространства, которая управляет доступностью переменных.

Непосредственно возникает свойство: область видимости изолирует переменных. Это замечательно, потому что различных областей видимости могут иметь переменные с одинаковыми именами .

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

foo () и bar () области функций имеют свои собственные, но с тем же именем переменные count :

  function foo () {
  
  пусть count = 0;
  консоль.журнал (количество); }

function bar () {
  
  пусть count = 1;
  console.log (количество); }

foo ();
бар();  

count переменных из областей видимости функций foo () и bar () не конфликтуют.

2. Вложенность областей применения

Давайте еще немного поиграем с прицелами и вставим один прицел в другой.

Функция innerFunc () вложена во внешнюю функцию outerFunc () .

Как 2 области действия функций будут взаимодействовать друг с другом? Могу ли я получить доступ к переменной outerVar из outerFunc () из области innerFunc () ?

Давайте попробуем это на примере:

  function outerFunc () {
  
  let outerVar = 'Я снаружи!';

  function innerFunc () {
    
    консоль.журнал (externalVar); }

  innerFunc ();
}

externalFunc ();  

Действительно, переменная outerVar доступна внутри области innerFunc () . Переменные внешней области видимости доступны внутри внутренней области.

Теперь вы знаете 2 интересные вещи:

• Области могут быть вложены
• Переменные внешней области видимости доступны внутри внутренней области

3.

Как JavaScript понимает, что externalVar внутри innerFunc () соответствует переменной outerVar из outerFunc () ?

Это потому, что JavaScript реализует механизм области видимости под названием лексическая область видимости (или статическая область видимости).Лексическая область видимости означает, что доступность переменных определяется положением переменных в исходном коде внутри областей вложенности.

Проще говоря, лексическая область видимости означает, что внутри внутренней области видимости вы можете получить доступ к переменным ее внешней области видимости.

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

Вот как движок понимает предыдущий фрагмент кода:

1. Я вижу, вы определяете функцию outerFunc () с переменной outerVar . Хороший.
2. Внутри externalFunc () я вижу, что вы определяете функцию innerFunc () .
3. Внутри innerFunc () я вижу переменную outerVar без объявления. Поскольку я использую лексическую область видимости, я считаю, что переменная outerVar внутри innerFunc () является той же переменной, что и outerVar из outerFunc () .

Дистиллированное представление о лексической области:

Лексическая область состоит из внешних областей, определяемых статически.

Например:

  const myGlobal = 0;

function func () {
  const myVar = 1;
  console.log (myGlobal);
  function innerOfFunc () {
    const myInnerVar = 2;
    console.log (myVar, myGlobal);
    function innerOfInnerOfFunc () {
      console.log (myInnerVar, myVar, myGlobal); }

    innerOfInnerOfFunc ();
  }

  innerOfFunc ();
}

func ();  

Лексическая область видимости innerOfInnerOfFunc () состоит из областей видимости innerOfFunc () , func () и глобальной области (самой внешней области). Внутри innerOfInnerOfFunc () вы можете получить доступ к переменным лексической области видимости myInnerVar , myVar и myGlobal .

Лексическая область видимости innerFunc () состоит из func () и глобальной области видимости. Внутри innerOfFunc () вы можете получить доступ к переменным лексической области видимости myVar и myGlobal .

Наконец, лексическая область видимости func () состоит только из глобальной области видимости.В func () вы можете получить доступ к переменной лексической области видимости myGlobal .

4. Укупорка

Хорошо, лексическая область видимости позволяет получить статический доступ к переменным внешней области видимости. До закрытия остался всего один шаг!

Давайте еще раз посмотрим на примеры outerFunc () и innerFunc () :

  function outerFunc () {
  let outerVar = 'Я снаружи!';

  function innerFunc () {
    console. log (externalVar);
  }

  innerFunc ();}

externalFunc ();  

Внутри области innerFunc () переменная outerVar доступна из лексической области.Это уже известно.

Обратите внимание, что вызов innerFunc () происходит внутри его лексической области видимости (области видимости outerFunc () ).

Давайте внесем изменения: innerFunc () , который будет вызываться вне его лексической области видимости (за пределами outerFunc () ). Будет ли innerFunc () по-прежнему иметь доступ к externalVar ?

Давайте внесем изменения в фрагмент кода:

  function outerFunc () {
  let outerVar = 'Я снаружи!';

  function innerFunc () {
    консоль.журнал (externalVar);
  }

  return innerFunc;}

const myInnerFunc = externalFunc ();
myInnerFunc ();  

Теперь innerFunc () выполняется вне своей лексической области видимости. И что важно:

innerFunc () по-прежнему имеет доступ к outerVar из своей лексической области видимости, даже если она выполняется вне ее лексической области.

Другими словами, innerFunc () закрывает более (или захватывает, запоминает) переменную outerVar из своей лексической области видимости.

Другими словами, innerFunc () является закрытием , потому что он закрывает переменную outerVar из своей лексической области видимости.

Вы сделали последний шаг к пониманию того, что такое закрытие:

Замыкание - это функция, которая обращается к своей лексической области видимости, даже если она выполняется вне ее лексической области видимости.

Проще говоря, замыкание - это функция, которая запоминает переменные с того места, где они определены, независимо от того, где они выполняются позже.

Эмпирическое правило для определения замыкания: если вы видите в функции чужеродную переменную (не определенную внутри функции), скорее всего, эта функция является замыканием, потому что чужая переменная захвачена.

В предыдущем фрагменте кода outerVar - это чужая переменная внутри замыкания innerFunc () , захваченная из области outerFunc () .

Продолжим примеры, демонстрирующие, почему закрытие полезно.

5.Примеры закрытия

5.1 Обработчик событий

Давайте покажем, сколько раз была нажата кнопка:

  пусть countClicked = 0;

myButton.addEventListener ('щелчок', функция handleClick () {
  countClicked ++;
  myText.innerText = `Вы нажали $ {countClicked} раз`;
});  

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

При нажатии кнопки handleClick () выполняется где-то внутри кода DOM.Казнь происходит далеко от места определения.

Но будучи закрытием, handleClick () захватывает countClicked из лексической области видимости и обновляет его, когда происходит щелчок. Более того, myText тоже захватывается.

5.2 Обратные вызовы

Захват переменных из лексической области видимости полезен в обратных вызовах.

A setTimeout () обратный вызов:

  const message = 'Привет, мир!';

setTimeout (функция обратного вызова () {
  консоль.журнал (сообщение);
}, 1000);  

Функция итератора для forEach () :

  пусть countEven = 0;
const items = [1, 5, 100, 10];

items.forEach (итератор функции (число) {
  if (число% 2 === 0) {
    countEven ++;
  }
});

countEven;  

Итератор является закрытием, потому что он захватывает переменную countEven .

5.3 Функциональное программирование

Каррирование происходит, когда функция возвращает другую функцию до тех пор, пока не будут полностью предоставлены аргументы.

Например:

  функция умножить (а) {
  вернуть функцию executeMultiply (b) {
    вернуть a * b;
  }
}

const double = умножить (2);
двойной (3);
двойной (5);

const тройной = умножить (3);
тройной (4);  

multiply - каррированная функция, которая возвращает другую функцию.

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

executeMultiply (b) - это закрытие, которое захватывает и из своей лексической области видимости. Когда закрытие вызывается, захваченная переменная a и параметр b используются для вычисления a * b .

6. Заключение

Область действия определяет доступность переменных в JavaScript. Это может быть функция или область видимости блока.

Лексическая область видимости позволяет области действия функции получать статический доступ к переменным из внешних областей видимости.

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

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

Каждый разработчик JavaScript должен знать, как работают замыкания. Разобраться с этим ⌐ ■ _ ■.

А как насчет испытания? 7 вопросов для собеседования по закрытию JavaScript. Сможете ли вы им ответить?

Вам все еще сложно понять замыкания? Если да, задайте мне вопрос в комментарии ниже!

Замыкания (программирование) - Полезно

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

Замыкания достаточно легко определить технически.

Скажем, Фолдок говорит, что «замыкание - это структура данных, которая содержит выражение и среду привязок переменных, в которой это выражение должно быть вычислено.Переменные могут быть локальными или глобальными ».

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

Говоря чуть более обыденным языком, замыкания часто означают функцию, которая запоминает (часть) области видимости, из которой она возникла, в которой она была определена.

Рассмотрим следующий псевдокод:

 var add = function (a) {
  return function (b) {
    вернуть a + b;
  }
}
var add10 = добавить (10);

//Проверь это:
add10 (5); // 15, ура 

a

Внутренняя функция получает к ней доступ, потому что локальные / вложенные функции получают свою собственную область видимости блока, но также могут видеть область видимости своего родителя. Это половина причины, по которой такие функции полезны.

Но, по-видимому, это язык, который позволяет вам возвращать функции.

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

На языке, который допускает вложенные функции, но не закрытие, вероятно, сочтет этот недопустимый код, (точные причины могут немного отличаться в зависимости от того, как эти языки думают о сфере действия).

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

add

add

Использование JS / DOM

Использование Python

Замыкания существуют в python с 2.2.

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

 # То есть, если у вас есть помощник, определенный как:
def nth_lex (n):
    вернуть лямбда a, b: cmp (a [n], b [n]) 

 # ... тогда он позволяет:
matrixish.sort (nth_lex (2))

# Вместо того, чтобы писать:
matrixish.sort (лямбда a, b: cmp (a [2], b [2])) 

Есть несколько предостережений, которые не позволяют использовать некоторые из возможных применений.

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

 def foo ():
    х = 'а'
    def bar ():
        x = 'b'
    бар()
    печать x 

... вы можете ожидать, что он назначит и, следовательно, напечатает 'b', но область действия bar - foo и доступна только для чтения.

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

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

 def оплачено_more_than (сумма):
    сумма + = 10 #...cheapskate взлом
    вернуть лямбда-элемент: элемент ['зарплата']> сумма

ярмарка = pay_more_than (140)
дорого = pay_more_than (160)

сотрудники = [{'salary': 150}, {'salary': 170, 'isManager': True}, {'salary': 120}]
фильтр печати (ярмарка, сотрудники)
фильтр печати (дорого, сотрудники) 

справедливых и дорогих - это недавно созданные функции, и их переменная «сумма» основана на значении, которое она имела в определяющем контексте, то есть соответствующих выполнениях pay_more_than.

Это делает их независимыми (без побочных эффектов, например.грамм. внесение изменений в сумму не допускается).

Это также означает, что вы можете использовать их в генераторах списков и функциях:

 result = [e for e в служащих, если справедливо (e)]
 

Обратите внимание на то, что fair (e) более или менее похож на выражение pay_more_than (140) (e), за исключением того, что при каждом выполнении будет создаваться закрывающая функция.