symbol js зачем нужен
Особенности использования типа данных Symbol в JavaScript
Символьные примитивы — это одно из новшеств стандарта ES6, которое принесло в JavaScript некоторые ценные возможности. Символы, представленные типом данных Symbol, особенно полезны при использовании их в качестве идентификаторов свойств объектов. В связи с таким сценарием их применения напрашивается вопрос о том, что такого они могут, чего не могут строки.
В материале, перевод которого мы сегодня публикуем, речь пойдёт о типе данных Symbol в JavaScript. Начнём мы с обзора некоторых возможностей JavaScript, в которых нужно ориентироваться для того, чтобы разобраться с символами.
Предварительные сведения
Примитивные значения иммутабельны. Их нельзя изменять. Конечно, в переменную, хранящую примитивное значение, можно записать что-то новое. Например, здесь выполняется запись нового значения в переменную x :
В некоторых языках, например — в C, есть концепции передачи аргументов функций по ссылке и по значению. В JavaScript тоже есть нечто подобное. То, как именно организуется работа с данными, зависит от их типа. Если в функцию передают примитивное значение, представленное некоей переменной, а потом изменяют его в этой функции, значение, хранящееся в исходной переменной, при этом не меняется. Однако если в функцию передать объектное значение, представленное переменной, и модифицировать его, то изменится и то, что хранится в этой переменной.
Рассмотрим следующий пример:
Однако конструирование объектных значений, внешне выглядящих одинаково, не приведёт к тому, что получатся сущности, при сравнении которых будет выявлено их равенство друг другу. Проверить это можно так:
Объекты играют фундаментальную роль в JavaScript. Они применяются буквально повсюду. Например, часто их используют в виде коллекций вида ключ/значение. Но до появления типа данных Symbol в качестве ключей объектов можно было применять лишь строки. В этом крылось серьёзное ограничение использования объектов в виде коллекций. При попытке назначения нестрокового значения в виде ключа объекта это значение приводилось к строке. Убедиться в этом можно так:
Кстати, хотя это немного уводит нас от темы символов, хочется отметить, что структура данных Map была создана для того чтобы позволить использовать хранилища данных формата ключ/значение в ситуациях, когда ключ не является строкой.
Что такое символ?
Теперь, когда мы выяснили особенности примитивных значений в JavaScript, мы наконец готовы к тому, чтобы приступить к разговору о символах. Символ — это уникальное примитивное значение. Если подходить к символам с этой позиции, то можно заметить, что символы в этом плане похожи на объекты, так как создание нескольких экземпляров символов приведёт к созданию разных значений. Но символы, кроме того, являются иммутабельными примитивными значениями. Вот пример работы с символами:
При создании экземпляра символа можно воспользоваться необязательным первым строковым аргументом. Этот аргумент представляет собой описание символа, которое предназначено для использования при отладке. На сам символ это значение не влияет.
Символы как ключи свойств объектов
Символы можно использовать в качестве ключей свойств объектов. Это очень важно. Вот пример использования их в таком качестве:
На первый взгляд может показаться, что вышеописанные особенности символов позволяют использовать их для создания приватных свойств JS-объектов. Во многих других языках программирования можно создавать скрытые свойства объектов с использованием классов. Отсутствие этой возможности уже давно считается одним из недостатков JavaScript.
К сожалению, код, который работает с объектами, может беспрепятственно обращаться к их строковым ключам. Код может обращаться и к ключам, заданным символами, причём, даже в том случае, если у кода, из которого работают с объектом, нет доступа к соответствующему символу. Например, с помощью метода Reflect.ownKeys() можно получить список всех ключей объекта, и тех, что являются строками, и тех, что являются символами:
Обратите внимание на то, что в настоящее время ведётся работа над тем, чтобы оснастить классы возможностью использования приватных свойств. Эта возможность называется Private Fields (приватные поля). Она, правда, не затрагивает абсолютно все объекты, относясь лишь к тем из них, которые созданы на основе предварительно подготовленных классов. Поддержка приватных полей уже имеется в браузере Chrome версии 72 и старше.
Предотвращение коллизий имён свойств объектов
Символы, конечно, не добавляют в JavaScript возможностей по созданию приватных свойств объектов, но они являются ценным новшеством языка по другим причинам. А именно, они полезны в ситуациях, когда неким библиотекам нужно добавлять свойства в объекты, описанные за их пределами, и при этом не опасаться коллизии имён свойств объектов.
Если же воспользоваться в нашем примере символами, то каждая библиотека может сгенерировать, при инициализации, нужные ей символы. Затем эти символы могут быть использованы для назначения свойств объектам и для доступа к этим свойствам.
Именно глядя на подобный сценарий можно ощутить пользу от появления символов в JavaScript.
Однако тут может возникнуть вопрос, касающийся использования библиотеками, для имён свойств объектов, случайных строк или строк, со сложной структурой, включающих в себя, например, название библиотеки. Подобные строки могут образовывать нечто вроде пространств имён для идентификаторов, используемых библиотеками. Например, это может выглядеть так:
В общем-то, можно поступить и так. Подобные подходы, на самом деле, очень похожи на то, что происходит при использовании символов. И если, используя случайные идентификаторы или пространства имён, пара библиотек не сгенерирует, по воле случая, одинаковые имена свойств, то проблем с именами не будет.
Проницательный читатель сказал бы сейчас, что два рассматриваемых подхода к именованию свойств объектов не являются полностью эквивалентными. У имён свойств, которые формируются случайным образом или с использованием пространств имён, есть недостаток: соответствующие ключи очень легко обнаружить, особенно если в коде выполняется перебор ключей объектов или их сериализация. Рассмотрим следующий пример:
Если бы в этой ситуации для имени ключа использовался бы символ, тогда JSON-представление объекта не содержало бы значения символа. Почему это так? Дело в том, что то, что в JavaScript появился новый тип данных, ещё не означает того, что изменения внесены и в спецификацию JSON. JSON поддерживает, в качестве ключей свойств объектов, только строки. При сериализации объекта не делается попыток представить символы в каком-то особом виде.
Рассматриваемую проблему попадания имён свойств в JSON-представление объектов можно решить благодаря использованию Object.defineProperty() :
Однако между использованием имён-символов и имён, созданных с использованием других механизмов, есть одно маленькое различие. Так как строки иммутабельны, а символы гарантированно уникальны, всегда есть возможность того, что кто-то, перебрав все возможные сочетания символов в строке, вызовет коллизию имён. С математической точки зрения это означает, что символы действительно дают нам ценную возможность, которая отсутствует у строк.
Имитация приватных свойств
Вот интересный подход, который можно использовать для имитации приватных свойств объектов. Этот подход предусматривает применение ещё одной современной возможности JavaScript — прокси-объектов. Такие объекты служат обёртками для других объектов, которые позволяют программисту вмешиваться в действия, выполняемые с этими объектами.
Прокси-объекты предлагают много способов для перехвата действий, выполняемых над объектами. Нас интересует возможность управления операциями чтения ключей объекта. В подробности о прокси-объектах мы тут углубляться не будем. Если вам они интересны — взгляните на эту публикацию.
Тут надо отметить, что в Node.js есть одна особенность, нарушающая приватность прокси-объектов. Эта особенность не существует в самом языке, поэтому она не актуальна для других сред выполнения JS, таких, как браузер. Дело в том, что эта особенность позволяет получать доступ к объекту, скрытому за прокси-объектом, при наличии доступа к прокси-объекту. Вот пример, демонстрирующий возможность обхода механизмов, показанных в предыдущем фрагменте кода:
Итоги
Уважаемые читатели! Пользуетесь ли вы символами в своих JavaScript-проектах?
JavaScript Symbols. Новый тип примитивов
Введение
Например, в языке C и некоторых других есть понятие pass-by-reference и pass-by-value (передача аргументов в функцию по ссылке или по значению). В JavaScript тоже есть такое понятие в каком-то смысле, хотя всё зависит от типа передаваемых данных. Если вы передадите значение в функцию, то оно не изменится в вызываемом местоположении, даже если вы переназначите это значение. В случае с «непримитивным» значением, оно изменится и там, откуда был вызов.
Примитивные значения (за исключением мистического NaN ) всегда будут точно равны другим примитивам с эквивалентным значением. Пример:
Тем не менее создание эквивалентных непримитивных значений не приведёт к точному равенству значений. Это показывает следующий пример:
Объекты — это фундаментальная единица в JavaScript. Они используются везде. Объекты часто используются в качестве коллекций пар ключ/значение. Но это накладывает определённые ограничения. До появления символов, ключи объектов могли быть только строками. Если попытаться использовать «нестроковое» значение в качестве ключа для объекта, оно будет приведено к строке. Можете увидеть это на примере:
Примечание: это не совсем по теме, но структура данных Map была создана отчасти, чтобы позволить хранить пары ключ/значение в случае, когда ключ не является строкой.
Что такое Symbol?
Теперь, когда мы вспомнили, что такое примитивное значение, давайте поговорим о символах. Symbol — это примитив, который нельзя создать повторно. В каком-то смысле он подобен объекту, потому что создание нескольких экземпляров приводит к значениям, которые не будут точно равны. Но всё же, символ — это примитив, потому что он не может быть изменён. Пример использования:
У символов есть опциональный первый аргумент, который можно указать как строку. Это значение используют при отладке кода. В остальном оно не влияет на сам символ.
Symbol как свойство объекта
Есть и другое важное назначение символов. Их можно использовать в качестве ключей в объектах. Вот пример такого использования:
На первый взгляд кажется, что символы можно использовать для создания приватных свойств объекта. В других языках для этого есть скрытые свойства в классах. Отсутствие такой возможности всегда считалось недостатком JavaScript.
Примечание: в настоящее время разработчики решают проблему, связанную с добавлением приватных свойств в классы JavaScript. Эта фича называется Private Fields, и, хотя она не решит всех проблем, зато поможет работать с объектами, которые являются экземплярами класса. Private Fields поддерживаются в Chrome 74.
Предотвращение конфликтов в именах свойств
Символы не предоставляют полной приватности свойств, но они полезны в ситуациях, когда разным библиотекам необходимо добавить свойства к объектам без риска возникновения конфликтов имён.
Рассмотрим ситуацию, когда метаданные из двух разных библиотек нужно присоединить к объекту. Допустим, требуется установить идентификатор для объекта. Если просто задать ключ из двух букв строчного типа ( id ), существует огромный риск того, что несколько библиотек будут использовать один и тот же ключ.
Благодаря символам каждая библиотека может генерировать необходимые ей символы при создании экземпляра. Далее эти символы можно использовать для назначения свойств объектам.
Для подобных целей символы оказываются действительно полезными в JavaScript.
Но почему каждая библиотека не может просто генерировать случайную строку или использовать строку из специального пространства имён?
Звучит разумно. Такой подход очень похож на то, что происходит при использовании символов. Пока две библиотеки используют разные имена свойств, проблем не возникнет.
Здесь внимательный читатель заметил, что эти два подхода не были полностью эквивалентны. В именах свойств, где эти имена уникальны, всё ещё есть недостаток: их ключи очень легко обнаружить, особенно если код выполняется для итерации ключей, либо для сериализации объектов. Рассмотрим следующий пример:
Если бы в этой ситуации для имени ключа использовался символ, то JSON не содержал бы его значение на выходе. Почему? Потому что спецификация JSON не изменилась. JSON в качестве ключей допускает только строки, и JavaScript не представит свойства символов в конечной полезной нагрузке JSON.
Исправить проблему попадания имён свойств в вывод JSON можно с помощью Object.defineProperty() :
Но, есть ещё одна маленькая разница. Поскольку строки неизменяемы, а символы гарантированно уникальны, всегда есть возможность того, что кто-то, перебрав все возможные сочетания символов в строке, вызовет конфликт имён. Математически это показывает, что символы дают преимущество перед строками.
Имитация приватных свойств
Есть интересный подход для имитации приватных свойств объекта. Этот подход использует другую JavaScript функцию, доступную уже сегодня: прокси. Прокси, по сути, обёртывает объект и позволяет взаимодействовать с ним через себя.
У прокси есть множество способов перехватывать действия, выполняемые над объектом. Тот, который нас интересует, способен перехватывать попытки чтения ключей объекта.
Прокси можно использовать для управления тем, какие свойства объекта видны. Далее мы создадим прокси, который будет скрывать два известных свойства, одно из которых является строкой _favColor, а другой символом, назначенным favBook:
Тип данных Symbol
По спецификации, в качестве ключей для свойств объекта могут использоваться только строки или символы. Ни числа, ни логические значения не подходят, разрешены только эти два типа данных.
До сих пор мы видели только строки. Теперь давайте разберём символы, увидим, что хорошего они нам дают.
Символы
«Символ» представляет собой уникальный идентификатор.
Создаются новые символы с помощью функции Symbol() :
При создании символу можно дать описание (также называемое имя), в основном использующееся для отладки кода:
Символы гарантированно уникальны. Даже если мы создадим множество символов с одинаковым описанием, это всё равно будут разные символы. Описание – это просто метка, которая ни на что не влияет.
Например, вот два символа с одинаковым описанием – но они не равны:
Если вы знаете Ruby или какой-то другой язык программирования, в котором есть своего рода «символы» – пожалуйста, будьте внимательны. Символы в JavaScript имеют свои особенности, и не стоит думать о них, как о символах в Ruby или в других языках.
Большинство типов данных в JavaScript могут быть неявно преобразованы в строку. Например, функция alert принимает практически любое значение, автоматически преобразовывает его в строку, а затем выводит это значение, не сообщая об ошибке. Символы же особенные и не преобразуются автоматически.
К примеру, alert ниже выдаст ошибку:
Это – языковая «защита» от путаницы, ведь строки и символы – принципиально разные типы данных и не должны неконтролируемо преобразовываться друг в друга.
«Скрытые» свойства
Символы позволяют создавать «скрытые» свойства объектов, к которым нельзя нечаянно обратиться и перезаписать их из других частей программы.
Используем для этого символьный ключ:
Так как объект user принадлежит стороннему коду, и этот код также работает с ним, то нам не следует добавлять к нему какие-либо поля. Это небезопасно. Но к символу сложно нечаянно обратиться, сторонний код вряд ли его вообще увидит, и, скорее всего, добавление поля к объекту не вызовет никаких проблем.
Сторонний код может создать для этого свой символ Symbol(«id») :
Конфликта между их и нашим идентификатором не будет, так как символы всегда уникальны, даже если их имена совпадают.
А вот если бы мы использовали строку «id» вместо символа, то тогда был бы конфликт:
Символы в литеральном объекте
Если мы хотим использовать символ при литеральном объявлении объекта <. >, его необходимо заключить в квадратные скобки.
Это вызвано тем, что нам нужно использовать значение переменной id в качестве ключа, а не строку «id».
Символы игнорируются циклом for…in
Это – часть общего принципа «сокрытия символьных свойств». Если другая библиотека или скрипт будут работать с нашим объектом, то при переборе они не получат ненароком наше символьное свойство. Object.keys(user) также игнорирует символы.
Здесь нет никакого парадокса или противоречия. Так и задумано. Идея заключается в том, что, когда мы клонируем или объединяем объекты, мы обычно хотим скопировать все свойства (включая такие свойства с ключами-символами, как, например, id в примере выше).
Глобальные символы
Для этого существует глобальный реестр символов. Мы можем создавать в нём символы и обращаться к ним позже, и при каждом обращении нам гарантированно будет возвращаться один и тот же символ.
Символы, содержащиеся в реестре, называются глобальными символами. Если вам нужен символ, доступный везде в коде – используйте глобальные символы.
В некоторых языках программирования, например, Ruby, на одно имя (описание) приходится один символ, и не могут существовать разные символы с одинаковым именем.
В JavaScript, как мы видим, это утверждение верно только для глобальных символов.
Symbol.keyFor
Системные символы
Существует множество «системных» символов, использующихся внутри самого JavaScript, и мы можем использовать их, чтобы настраивать различные аспекты поведения объектов.
Эти символы перечислены в спецификации в таблице Well-known symbols:
В частности, Symbol.toPrimitive позволяет описать правила для объекта, согласно которым он будет преобразовываться к примитиву. Мы скоро увидим его применение.
С другими системными символами мы тоже скоро познакомимся, когда будем изучать соответствующие возможности языка.
Итого
Символ (symbol) – примитивный тип данных, использующийся для создания уникальных идентификаторов.
Даже если символы имеют одно и то же имя, это – разные символы. Если мы хотим, чтобы одноимённые символы были равны, то следует использовать глобальный реестр: вызов Symbol.for(key) возвращает (или создаёт) глобальный символ с key в качестве имени. Многократные вызовы команды Symbol.for с одним и тем же аргументом возвращают один и тот же символ.
Символы имеют два основных варианта использования:
Так что, используя символьные свойства, мы можем спрятать что-то нужное нам, но что другие видеть не должны.
JavaScript Symbols. Новый тип примитивов
Sep 11, 2019 · 7 min read
Введение
Например, в языке C и некоторых других есть понятие pass-by-reference и pass-by-value (передача аргументов в функцию по ссылке или по значению). В JavaScript тоже есть такое понятие в каком-то смысле, хотя всё зависит от типа передаваемых данных. Если вы передадите значение в функцию, то оно не изменится в вызываемом местоположении, даже если вы переназначите это значение. В случае с «непримитивным» значением, оно изменится и там, откуда был вызов.
Примитивные значения (за исключением мистического NaN ) всегда будут точно равны другим примитивам с эквивалентным значением. Пример:
Тем не менее создание эквивалентных непримитивных значений не приведёт к точному равенству значений. Это показывает следующий пример:
Объекты — это фундаментальная единица в JavaScript. Они используются везде. Объекты часто используются в качестве коллекций пар ключ/значение. Но это накладывает определённые ограничения. До появления символов, ключи объектов могли быть только строками. Если попытаться использовать «нестроковое» значение в качестве ключа для объекта, оно будет приведено к строке. Можете увидеть это на примере:
Примечание: это не совсем по теме, но структура данных Map была создана отчасти, чтобы позволить хранить пары ключ/значение в случае, когда ключ не является строкой.
Что такое Symbol?
Теперь, когда мы вспомнили, что такое примитивное значение, давайте поговорим о символах. Symbol — это примитив, который нельзя создать повторно. В каком-то смысле он подобен объекту, потому что создание нескольких экземпляров приводит к значениям, которые не будут точно равны. Но всё же, символ — это примитив, потому что он не может быть изменён. Пример использования:
У символов есть опциональный первый аргумент, который можно указать как строку. Это значение используют при отладке кода. В остальном оно не влияет на сам символ.
Symbol как свойство объекта
Есть и другое важное назначение символов. Их можно использовать в качестве ключей в объектах. Вот пример такого использования:
На первый взгляд кажется, что символы можно использовать для создания приватных свойств объекта. В других языках для этого есть скрытые свойства в классах. Отсутствие такой возможности всегда считалось недостатком JavaScript.
Примечание: в настоящее время разработчики решают проблему, связанную с добавлением приватных свойств в классы JavaScript. Эта фича называется Private Fields, и, хотя она не решит всех проблем, зато поможет работать с объектами, которые являются экземплярами класса. Private Fields поддерживаются в Chrome 74.
Предотвращение конфликтов в именах свойств
Символы не предоставляют полной приватности свойств, но они полезны в ситуациях, когда разным библиотекам необходимо добавить свойства к объектам без риска возникновения конфликтов имён.
Рассмотрим ситуацию, когда метаданные из двух разных библиотек нужно присоединить к объекту. Допустим, требуется установить идентификатор для объекта. Если просто задать ключ из двух букв строчного типа ( id ), существует огромный риск того, что несколько библиотек будут использовать один и тот же ключ.
Благодаря символам каждая библиотека может генерировать необходимые ей символы при создании экземпляра. Далее эти символы можно использовать для назначения свойств объектам.
Для подобных целей символы оказываются действительно полезными в JavaScript.
Но почему каждая библиотека не может просто генерировать случайную строку или использовать строку из специального пространства имён?
Звучит разумно. Такой подход очень похож на то, что происходит при использовании символов. Пока две библиотеки используют разные имена свойств, проблем не возникнет.
Здесь внимательный читатель заметил, что эти два подхода не были полностью эквивалентны. В именах свойств, где эти имена уникальны, всё ещё есть недостаток: их ключи очень легко обнаружить, особенно если код выполняется для итерации ключей, либо для сериализации объектов. Рассмотрим следующий пример:
Если бы в этой ситуации для имени ключа использовался символ, то JSON не содержал бы его значение на выходе. Почему? Потому что спецификация JSON не изменилась. JSON в качестве ключей допускает только строки, и JavaScript не представит свойства символов в конечной полезной нагрузке JSON.
Исправить проблему попадания имён свойств в вывод JSON можно с помощью Object.defineProperty() :
Но, есть ещё одна маленькая разница. Поскольку строки неизменяемы, а символы гарантированно уникальны, всегда есть возможность того, что кто-то, перебрав все возможные сочетания символов в строке, вызовет конфликт имён. Математически это показывает, что символы дают преимущество перед строками.
Имитация приватных свойств
Есть интересный подход для имитации приватных свойств объекта. Этот подход использует другую JavaScript функцию, доступную уже сегодня: прокси. Прокси, по сути, обёртывает объект и позволяет взаимодействовать с ним через себя.
У прокси есть множество способов перехватывать действия, выполняемые над объектом. Тот, который нас интересует, способен перехватывать попытки чтения ключей объекта.
Прокси можно использовать для управления тем, какие свойства объекта видны. Далее мы создадим прокси, который будет скрывать два известных свойства, одно из которых является строкой _favColor, а другой символом, назначенным favBook:
Зачем они нужны в JavaScript? Symbol, Iterator, Generator
Jun 1, 2018 · 5 min read
Кратко, просто и понятно, что это такое и как это применять.
Начнём с Symbol
Что это?
Пока всё просто. Теперь давайте посложнее.
Это удерживает разработчиков от создания явного объекта-обёртки Symbol вместо нового символьного значения. Создание явных объектов-обёрток для примитивных типов доступно (например, new Boolean, new String, new Number).
Простыми словами — от символа мы хотим получить уникальный идентификатор, то есть сам Символ, а new возвращает объект, объект нам не нужен.
И последнее про Symbol
Существуют «глобальные символы», они доступны во всех частях вашей программы. То есть вы можете создать символ и поместить его в некую базу, это делается с помощью функции Symbol.for()
Если мы ещё раз вызовем Symbol.for(“Kanye West”) он вернёт существующий символ, а не новый.
Представим, у вас есть некий объект в приложении, который используется много где, да и с ним работаете не только вы, он передаётся по разным функциям, над ним издеваются с помощью разных методов, и вдруг вам понадобилось запихнуть в этот объект свои данные, например логи.
Что вы будете делать — создадите новое поле объекта и присвоите ему свои логи. Но тут есть нюанс, если объект используется в большом количестве логики и другие разработчики как-то взаимодействуют с параметрами объекта, то есть шанс, что ваше новое поле где-то сможет сломать цикл, а где-то перезапишет собой другие поля.
Для решение этой проблемы, можно использовать symbol
Так что, Symbol — ваш друг.
Также есть и более замороченные применения, про них можно почитать тут https://www.keithcirkel.co.uk/metaprogramming-in-es6-symbols/
Iterator
Что это?
В JavaScript есть так называемые итерируемые объекты, то есть объекты содержимое которых мы можем перебрать. Как например массив. Сам перебор, в большинстве своём, осуществляется с помощью итераторов (к примеру конструкция for..of для перебора элементов использует итераторы)
Давайте сделаем один.
А теперь используем наш итератор.
Теперь более реальный пример.
У нас есть объект, который нужно «умно» перебрать.
Для того чтобы for..of выводил то, что мы хотим, нужно сделать объект range итерируемым.
Дальше без паники, всё объясню.
Как я говорил выше, конструкция for..of использует итераторы для перебора данных. В начале своего выполнения, for..of автоматически вызывает Symbol.iterator() для получения итератора и далее вызывает метод next() до получения < done: true >. Это внутренняя механика JavaScript, так уж он работает.
Когда хочешь перебирать объекты и другие типы данных по своему, итератор это отличный вариант.
Generator
Это функция которая может приостанавливать своё выполнение, возвращать промежуточный результат и далее возобновлять своё выполнение в произвольный момент времени. Слегка трудновато, но позже всё станет понятно.
Так выглядят генераторы.
В общем, это обычная функция перед которой стоит *
Когда мы вызываем функцию-генератор, она возвращает нам объект-итератор. Вы с ним уже познакомились.
Вот как это работает на практике
Yield как бы говорит — передаём name и ставим паузу, пока не произойдёт следующий вызов next()
Также yield может принимать значения из вне.
Разберём код выше типичной ситуацией из жизни.
Представим что наш генератор это Канье Уэст который лично привёз вам домой свой альбом. Когда происходит первый вызов myIterator.next() Канье заходит к вам в дом и дарит свой альбом (передается name ). Канье человек простой, он хочет услышать в ответ благодарность и готов ждать её хоть вечность.
Вот, вы послушали альбом, подходите к Канье и говорите Спасибо (с помощью myIterator.next(‘West’) передаётся ‘West’ обратно в функцию), Канье принимает благодарность (переменной who присваивается ‘West’ ) и тут же уходит по своим делам. Такой уж Канье.
В целом, его используют разные библиотеки как замену async/await для работы с асинхронными операциями. Сам async/await кстати, это high level абстракция над генераторами.
Также популярная redux-saga использует генераторы.
В остальных случаях их применяют очень редко.
Суммируем
И напоследок
Сегодня страшное стало понятным….слегка.
Если вы используете symbol, iterator и generator в своих проектах как-то по другому, пишите в комментариях, обязательно добавлю.
Если интересно как надо писать на React, то ниже есть гайд.
На этом всё! Спасибо!
CLAP. CLAP. CLAP.
Потому что, почему бы и нет? Ты можешь. 👏