Чому програма використовує закриття?

Прочитавши багато публікацій, де пояснюються питання про закриття, я все ще пропускаю ключове поняття: Чому писати про закриття? Яке конкретно завдання виконає програміст, який може бути найкращим чином виконаний при закритті?

Прикладами закриттів у Swift є доступ до NSUrl та використання зворотного геокодера. Ось один із таких прикладів. На жаль, ці курси просто представлені на закритті; вони не пояснюють, чому рішення коду пишеться як закриття.

Приклад реальної проблеми програмування у світі, який може змусити мій мозок сказати: "ага, я мушу написати це завершення", був би більш інформативним, ніж теоретична дискусія. На цьому веб-сайті немає дефіциту теоретичних дискусій.

Перш за все, немає нічого неможливого без використання закривань. Ви завжди можете замінити закриття об'єктом, що реалізує певний інтерфейс. Це лише питання стислості та зменшеної зв'язку.

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

Там, де закриття дійсно світяться над іншими конструкціями, це при використанні функцій вищого порядку, коли вам потрібно фактично спілкуватися, і ви можете зробити його однолінійним, як у цьому прикладі JavaScript на сторінці вікіпедії про закриття :

// Return a list of all books with at least 'threshold' copies sold.
function bestSellingBooks(threshold) {
  return bookList.filter(
      function (book) { return book.sales >= threshold; }
    );
}

Тут thresholdдуже коротко і природно передається звідки визначено, де воно використовується. Її обсяг точно обмежений, наскільки це можливо. filterне повинно бути записаним, щоб передбачити можливість передачі визначених клієнтом даних, таких як поріг. Нам не потрібно визначати будь-які проміжні структури з єдиною метою передачі порогу в цій одній невеликій функції. Це повністю самостійно.

Ви можете написати це без закриття, але це зажадає набагато більше коду, і буде важче дотримуватися. Також у JavaScript є досить багатослівний синтаксис лямбда. Наприклад, у Scala все тіло функції було б:

bookList filter (_.sales >= threshold)

Якщо ви можете використовувати ECMAScript 6 , завдяки функції жирної стрілки навіть JavaScript-код стає набагато простішим і його можна фактично поставити в один рядок.

const bestSellingBooks = (threshold) => bookList.filter(book => book.sales >= threshold);

У власному коді шукайте місця, де ви генеруєте велику кількість котлів просто для передачі тимчасових значень з одного місця в інше. Це відмінні можливості розглянути можливість заміни закриття.

Як пояснення, я збираюся запозичити якийсь код із цієї чудової публікації в блозі про закриття . Це JavaScript, але це мова більшості дописів у блогах, що говорять про використання закриттів, оскільки закриття настільки важливі в JavaScript.

Скажімо, ви хотіли вивести масив у вигляді таблиці HTML. Ви можете зробити це так:

function renderArrayAsHtmlTable (array) {
  var table = "<table>";
  for (var idx in array) {
    var object = array[idx];
    table += "<tr><td>" + object + "</td></tr>";
  }
  table += "</table>";
  return table;
}

Але вам належить на милість JavaScript щодо того, як буде відображатися кожен елемент масиву. Якщо ви хочете контролювати візуалізацію, ви можете зробити це:

function renderArrayAsHtmlTable (array, renderer) {
  var table = "<table>";
  for (var idx in array) {
    var object = array[idx];
    table += "<tr><td>" + renderer(object) + "</td></tr>";
  }
  table += "</table>";
  return table;
}

А тепер ви можете просто передати функцію, яка повертає потрібну візуалізацію.

Що робити, якщо ви хочете відобразити загальний обсяг у кожному рядку таблиці? Вам знадобиться змінна, щоб відстежувати цю загальну суму, чи не так? Закриття дозволяє записати функцію візуалізації, яка закривається над загальною змінною, що працює, і дозволяє записати рендер, який може відслідковувати поточну загальну кількість:

function intTableWithTotals (intArray) {
  var total = 0;
  var renderInt = function (i) {
    total += i;
    return "Int: " + i + ", running total: " + total;
  };
  return renderObjectsInTable(intArray, renderInt);
}

Магія, яка відбувається тут, полягає в тому, що renderInt зберігається доступ до totalзмінної, хоча renderIntвона неодноразово викликається і виходить.

Більш традиційно об'єктно-орієнтованою мовою, ніж JavaScript, ви можете написати клас, який містить цю загальну змінну, і передати це навколо, а не створювати закриття. Але закриття - це набагато більш потужний, чистий та елегантний спосіб зробити це.

Подальше читання

• MDN про закриття
• Як працюють закриття JavaScript?

Мета closures- просто зберегти державу; звідси назва closure- вона закривається над станом. Для зручності подальшого пояснення я буду використовувати Javascript.

Зазвичай у вас є функція

function sayHello(){
    var txt="Hello";
    return txt;
}

де область змінної (змінних) пов'язана з цією функцією. Тож після виконання змінна txtвиходить за межі області. Немає способу отримати доступ до нього або використовувати його після завершення виконання функції.

Закриття - це мовна конструкція, яка дозволяє - як було сказано раніше - зберегти стан змінних і так розширити область застосування.

Це може бути корисно в різних випадках. Одним із випадків використання є побудова функцій вищого порядку .

У математиці та інформатиці функція вищого порядку (також функціональна форма, функціональна чи функтор) - це функція, яка виконує хоча б одну з наступних дій: 1

• приймає одну або кілька функцій як вхід
• виводить функцію

Простий, але, правда, не дуже корисний приклад:

 makeadder=function(a){
     return function(b){
         return a+b;
     }
 }

 add5=makeadder(5);
 console.log(add5(10)); 

Ви визначаєте функцію makedadder, яка приймає один параметр як вхідний і повертає функцію . Є зовнішня функція function(a){}і внутрішня function(b){}{} . Крім того, ви визначаєте (неявно) іншу функцію add5в результаті виклику функції вищого порядку makeadder. makeadder(5)повертає анонімну ( внутрішню ) функцію, яка в свою чергу приймає 1 параметр і повертає суму параметра зовнішньої функції та параметра внутрішньої функції.

Трик в тому, що при поверненні на внутрішню функцію, яка робить фактичне додавання, обсяг параметра зовнішньої функції ( a) зберігаються. add5 пам'ятає , що параметр aбув 5.

Або показати один хоча б якось корисний приклад:

  makeTag=function(openTag, closeTag){
     return function(content){
         return openTag +content +closeTag;
     }
 }

 table=makeTag("<table>","</table>")
 tr=makeTag("<tr>", "</tr>");
 td=makeTag("<td>","</td>");
 console.log(table(tr(td("I am a Row"))));

Інший розповсюджений випадок - так званий IIFE = негайно викликаний вираз функції. У javascript дуже часто зустрічаються з підробленими змінними приватних членів. Це робиться за допомогою функції, яка створює приватний діапазон = closure, оскільки це негайно після виклику визначення. Структура є function(){}(). Зауважте дужки ()після визначення. Це дає можливість використовувати його для створення об'єктів із виявленням шаблону модуля . Трюк полягає у створенні області та поверненні об’єкта, який має доступ до цієї області після виконання IIFE.

Приклад Адді виглядає приблизно так:

 var myRevealingModule = (function () {

         var privateVar = "Ben Cherry",
             publicVar = "Hey there!";

         function privateFunction() {
             console.log( "Name:" + privateVar );
         }

         function publicSetName( strName ) {
             privateVar = strName;
         }

         function publicGetName() {
             privateFunction();
         }


         // Reveal public pointers to
         // private functions and properties

         return {
             setName: publicSetName,
             greeting: publicVar,
             getName: publicGetName
         };

     })();

 myRevealingModule.setName( "Paul Kinlan" );

Повертається об'єкт має посилання на функції (наприклад publicSetName), які, в свою чергу, мають доступ до "приватних" змінних privateVar.

Але це більш спеціальні випадки використання для Javascript.

Яке конкретно завдання виконає програміст, який може бути найкращим чином виконаний при закритті?

Для цього є кілька причин. Можна сказати, що для нього це природно, оскільки він дотримується функціональної парадигми . Або в Javascript: просто необхідно покладатися на закриття, щоб обійти деякі примхи мови.

Є два основні випадки використання для закриття:

1. Асинхронність. Скажімо, ви хочете виконати завдання, яке займе певний час, а потім зробіть щось, коли воно буде виконано. Ви можете або змусити свій код чекати його завершення, що блокує подальше виконання, і може зробити вашу програму безрезультатною, або викликати ваше завдання асинхронно і сказати "розпочати це довге завдання у фоновому режимі, а після його завершення виконайте це закриття", де закриття містить код, який потрібно виконати після його завершення.

2. Відкликання дзвінків Вони також відомі як "делегати" або "обробники подій" залежно від мови та платформи. Ідея полягає в тому, що у вас є об'єкт, що настроюється, який у певні чітко визначені моменти буде виконувати подію , яка виконує закриття, передане кодом, який її встановлює. Наприклад, в інтерфейсі вашої програми у вас може бути кнопка, і ви даєте їй закриття, яке містить код, який повинен виконуватися, коли користувач натискає кнопку.

Є кілька інших застосувань для закриття, але це два основних.

Кілька інших прикладів:

Сортування
Більшість функцій сортування діють шляхом порівняння пар об'єктів. Потрібна певна техніка порівняння. Обмеження порівняння певним оператором означає досить негнучку. Набагато кращим підходом є отримання функції порівняння як аргументу функції сортування. Іноді функція порівняння без стану працює непогано (наприклад, сортування списку чисел чи імен), але що робити, якщо для порівняння потрібно стан?

Наприклад, розглянемо сортування списку міст за відстані до певного місця. Неприємним рішенням є зберігання координат цього місця в глобальній змінній. Це робить функцію порівняння самою без громадянства, але ціною глобальної змінної.

Цей підхід виключає наявність декількох потоків одночасно сортування одного і того ж списку міст за їх відстані до двох різних місць. Закриття, яке закриває місцеположення, вирішує цю проблему, і вона позбавляється від необхідності глобальної змінної.

Випадкові числа
Оригінал rand()не брав аргументів. Генератори псевдовипадкових чисел потребують стану. Деяким (наприклад, Mersenne Twister) потрібно багато штату. Навіть проста, але страшна rand()потрібна держава. Прочитайте журнал з математичного журналу на новому генераторі випадкових чисел, і ви неминуче побачите глобальні змінні. Це приємно для розробників техніки, не так приємно для абонентів. Інкапсуляція цього стану в структуру та передача структури генератору випадкових чисел є одним із способів вирішення глобальної проблеми даних. Це підхід, який застосовується у багатьох мовах, що не входять в ООС, до створення генератора випадкових чисел. Закриття приховує цей стан від абонента. Замикання пропонує просту послідовність виклику rand()та перенапруження інкапсульованого стану.

Випадкових чисел більше, ніж просто PRNG. Більшість людей, які хочуть випадковості, хочуть, щоб це було розподілено певним чином. Почну з числа, випадковим чином виведених від 0 до 1, або U (0,1) для коротких. Буде виконано будь-який PRNG, який генерує цілі числа від 0 до деякого максимуму; просто розділіть (як плаваючу крапку) випадкове ціле число на максимум. Зручним і загальним способом реалізації цього є створення закриття, яке приймає закриття (PRNG) і максимум як вхідні дані. Зараз у нас є загальний і простий у використанні випадковий генератор для U (0,1).

Окрім U (0,1), існує ряд інших розподілів. Наприклад, нормальний розподіл з певним середнім і стандартним відхиленням. Кожен алгоритм генератора звичайного розподілу, який я працював, використовує генератор U (0,1). Зручним і загальним способом створення нормального генератора є створення замикання, яке інкапсулює генератор U (0,1), середнє значення та стандартне відхилення як стан. Це, принаймні концептуально, закриття, яке приймає закриття, яке приймає закриття як аргумент.

Замикання еквівалентні об'єктам, що реалізують метод run (), і навпаки, об'єкти можуть бути імітовані закриттями.

• Перевага закриттів полягає в тому, що їх можна легко використовувати в будь-якому місці, де ви очікуєте функцію: також функції вищого порядку, прості зворотні дзвінки (або стратегія). Вам не потрібно визначати інтерфейс / клас для створення спеціальних закриттів.

• Перевагою об'єктів є можливість більш складних взаємодій: декілька методів та / або різних інтерфейсів.

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

 (let ((seen))
    (defun register-name (name)
       (pushnew name seen :test #'string=))

    (defun all-names ()
       (copy-seq seen))

    (defun reset-name-registry ()
       (setf seen nil)))

В основному, ви інкапсулюєте прихований стан, доступ до якого здійснюється лише через глобальне закриття: вам не потрібно посилатися ні на який об’єкт, використовуйте лише протокол, визначений трьома функціями.

• Я поширюю відповідь, щоб вирішити цей коментар від supercat *.

Я довіряю першому коментарю supercat про те, що в деяких мовах можна точно контролювати термін експлуатації об'єктів, тоді як те ж саме не стосується закриттів. Що стосується мов, що збираються зі сміттям, то термін експлуатації об'єктів, як правило, не обмежений, і таким чином можливо створити закриття, яке можна було б викликати в динамічному контексті, де воно не повинно викликатись (читання із закриття після потоку закритий, наприклад).

Однак запобігти такому зловживанню досить просто, захопивши керуючу змінну, яка буде охороняти виконання закриття. Точніше, ось що я маю на увазі (у Common Lisp):

(defun guarded (function)
  (let ((active t))
    (values (lambda (&rest args)
              (when active
                (apply function args)))
            (lambda ()
              (setf active nil)))))

Тут ми беремо позначення функції functionі повертаємо два закриття, обидва вони захоплюють локальну змінну з назвою active:

• перший делегується function, лише коли activeце правда
• другий встановлюється actionна nilака false.

Замість цього (when active ...), звичайно, можливо мати (assert active)вираз, який може кинути виняток у випадку, якщо закриття викликається, коли його не повинно бути. Крім того, майте на увазі, що небезпечний код вже може викинути виняток сам по собі при поганому використанні, тому вам рідко потрібна така обгортка.

Ось як би ви його використовували:

(use-package :metabang-bind) ;; for bind

(defun example (obj1 obj2)
  (bind (((:values f f-deactivator)(guarded (lambda () (do-stuff obj1))))
         ((:values g g-deactivator)(guarded (lambda () (do-thing obj2)))))

    ;; ensure the closure are inactive when we exit
    (unwind-protect
         ;; pass closures to other functions
         (progn
           (do-work f)
           (do-work g))

      ;; cleanup code: deactivate closures
      (funcall f-deactivator)
      (funcall g-deactivator))))

Зауважте, що дезактиваційні закриття можуть бути надані і іншим функціям; тут локальні activeзмінні не поділяються між fта g; також, крім того active, fлише посилається obj1і gтільки на нього obj2.

Інший момент, про який згадує supercat, полягає в тому, що закриття може призвести до витоку пам’яті, але, на жаль, це стосується майже всього в місцях, де збираються сміття. Якщо вони доступні, це можна вирішити слабкими покажчиками (саме закриття може зберігатися в пам'яті, але не перешкоджає збору сміття інших ресурсів).

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

Ось приклад JavaScript з використанням таймаутів:

// Example function that logs something to the browser's console after a given delay
function delayedLog(message, delay) {
  // this function will be called when the timer runs out
  var fire = function () {
    console.log(message); // closure magic!
  };

  // set a timeout that'll call fire() after a delay
  setTimeout(fire, delay);
}

Тут відбувається те, що при delayedLog()виклику він повертається одразу після встановлення тайм-ауту, і час очікування залишається на задньому плані.

Але коли час закінчиться і зателефонує у fire()функцію, на консолі буде відображено те, messageщо було передано спочатку delayedLog(), оскільки воно все ще доступне fire()через закриття. Ви можете телефонувати delayedLog()скільки завгодно, з різним повідомленням та затримувати кожен раз, і це зробить правильно.

Але давайте уявимо, що JavaScript не має закриття.

Одним із способів було б зробити setTimeout()блокування - більше схоже на функцію "сну" - так delayedLog()що сфера дії не зникає, поки не закінчиться час очікування. Але блокувати все не дуже приємно.

Іншим способом було б помістити messageзмінну в якусь іншу область, яка буде доступна після того delayedLog(), як область зникне.

Ви можете використовувати глобальні - або, принаймні, "ширші рамки" - змінні, але вам доведеться розібратися, як слідкувати за тим, яке повідомлення йде з тим часом очікування. Але це не може бути просто послідовною чергою FIFO, тому що ви можете встановити будь-яку затримку, яку хочете. Тож це може бути "перше, третє" або щось таке. Тож вам знадобляться інші засоби для прив’язки приуроченої функції до потрібних змінних.

Ви можете створити об'єкт таймауту, який "групує" таймер із повідомленням. Контекст об'єкта - це більш-менш сфера, яка дотримується. Тоді ви мали б виконати таймер у контексті об'єкта, щоб він мав доступ до потрібного повідомлення. Але вам доведеться зберігати цей об’єкт, тому що без будь-яких посилань він збирає сміття (без закриття також не буде неявних посилань на нього). І вам доведеться видалити об'єкт, як тільки він буде запущений, інакше він просто приклеїться. Тож вам знадобиться якийсь список об’єктів таймауту та періодично перевіряйте його на "витрачені" об'єкти для видалення - або об'єкти додаватимуть і видалятимуть себе зі списку, і ...

Отже ... так, це стає нудно.

На щастя, вам не доведеться використовувати ширший спектр чи переплутати об'єкти, щоб утримати певні змінні. Оскільки у JavaScript є закриття, у вас вже є саме той обсяг, який потрібно. Область, яка надає вам доступ до messageзмінної, коли вона вам потрібна. І через це ви можете піти delayedLog()як писати вище.

PHP може бути використаний, щоб показати реальний приклад іншою мовою.

protected function registerRoutes($dic)
{
  $router = $dic['router'];

  $router->map(['GET','OPTIONS'],'/api/users',function($request,$response) use ($dic)
  {
    $controller = $dic['user_api_controller'];
    return $controller->findAllAction($request,$response);
  })->setName('api_users');
}

Таким чином, я в основному реєструю функцію, яка буде виконуватися для / api / користувачів URI . Це насправді функція середнього програмного забезпечення, яка в кінцевому підсумку зберігається в стеці. Інші функції будуть обгорнуті навколо нього. Настільки ж, як і Node.js / Express.js .

Ін'єкції залежностей контейнера можна ( з допомогою пункту використання) всередині функції , коли вона викликається. Можна зробити якийсь клас дії маршруту, але цей код виявляється простішим, швидшим та легшим у обслуговуванні.

Замикання є частиною довільного коду, включаючи змінні, які можуть бути оброблені як дані першим класом.

Тривіальний приклад - хороший старий qsort: це функція сортування даних. Ви повинні дати йому вказівник на функцію, яка порівнює два об'єкти. Отже, ви повинні написати функцію. Цю функцію може знадобитися параметризувати, це означає, що ви надаєте їй статичні змінні. Це означає, що це не безпечно для потоків. Ви в ДС. Отже, ви пишете альтернативу, яка займає закриття замість вказівника функції. Ви моментально вирішуєте проблему параметризації, оскільки параметри стають частиною закриття. Ви зробите свій код більш читаним, оскільки ви записуєте, як об'єкти порівнюються безпосередньо з кодом, який викликає функцію сортування.

Існує безліч ситуацій, коли потрібно виконати певну дію, яка вимагає великої кількості коду плит котла, плюс один крихітний, але важливий фрагмент коду, який потрібно адаптувати. Ви уникаєте кодового коду, записуючи один раз функцію, яка приймає параметр закриття та виконує весь код котла, а потім ви можете викликати цю функцію та передати код, який буде адаптований як закриття. Дуже компактний і читаний спосіб написання коду.

У вас є функція, коли деякий нетривіальний код потрібно виконувати в різних ситуаціях. Це використовувалося для створення дублювання коду або перекрученого коду, щоб нетривіальний код був присутній лише один раз. Trivial: Ви присвоюєте закриття змінній і називаєте її найбільш очевидним способом, де це потрібно.

Багатопотоковість: iOS / MacOS X має функції робити такі дії, як "виконати це закриття на фоновому потоці", "... на головному потоці", "... на головному потоці, через 10 секунд". Це робить багатопотокове тривіальне .

Асинхронні дзвінки: Ось, що побачила ОП. Будь-який дзвінок, який має доступ до Інтернету чи будь-що інше, що може зайняти час (наприклад, зчитування координат GPS) - це те, чого ви не можете дочекатися результату. Отже, у вас є функції, які роблять речі у фоновому режимі, а потім ви проходите закриття, щоб сказати їм, що робити, коли вони закінчаться.

Це невеликий початок. П'ять ситуацій, коли закриття є революційними з точки зору створення компактного, читабельного, надійного та ефективного коду.

Закриття - це скорочений спосіб написання методу, де його слід використовувати. Це економить ваші зусилля щодо оголошення та написання окремого методу. Це корисно, коли метод буде використаний лише один раз, а визначення методу - коротке. Переваги зменшуються введення тексту, оскільки немає необхідності вказувати назву функції, тип її повернення або модифікатор доступу. Також при читанні коду не потрібно шукати деінде десь визначення методу.

Викладене вище - це короткий зміст розуміння лямбдаських виразів Дана Авідара.

Це пояснило використання закриття для мене, оскільки воно роз'яснює альтернативи (закриття проти методу) та переваги кожного.

Наступний код використовується один раз і лише один раз під час налаштування. Записавши його на місце в режимі viewDidLoad економить проблеми пошуку в іншому місці та скорочує розмір коду.

myPhoton!.getVariable("Temp", completion: { (result:AnyObject!, error:NSError!) -> Void in
  if let e = error {
    self.getTempLabel.text = "Failed reading temp"
  } else {
    if let res = result as? Float {
    self.getTempLabel.text = "Temperature is \(res) degrees"
    }
  }
})

Крім того, він передбачає завершення асинхронного процесу без блокування інших частин програми, а, закриття, збереже значення для повторного використання в наступних викликах функцій.

Ще одне закриття; цей фіксує значення ...

let animals = ["fish", "cat", "chicken", "dog"]
let sortedStrings = animals.sorted({ (one: String, two: String) -> Bool in return one > two
}) println(sortedStrings)