зачем нужны анонимные функции
Анонимные функции в JavaScript
Разбираемся в том, что является анонимной функцией или какая связь между анонимными функциями в JavaScript и подбрасыванием монетки? Может ли функция с именем быть анонимной?
JavaScript-разработчик, запомни! Если после function есть имя — функция именованная, во всех остальных случая анонимная.
В интернете кто-то не прав
Все началось с простого вопроса в канале Telegram для изучающих JavaScript, в котором, помимо всего прочего, появился вопрос касательно обработчиков событий в браузере. Вопрос был в том, как они «навешиваются» и «снимаются» с DOM-элемента. Среди ответов от вполне опытного разработчика был следующий:
Обработчик снимается также, как он вешался. Если вешалась анонимная функция, то никак. Только удалять элемент из DOM и из памяти.
Далее ответ был подкреплен блоком кода похожим на этот:
На что в качестве возражения с моей стороны был приведен следующий блок кода, показывающий, что анонимная функция может быть удалена как обработчик:
В twitter как на работу
После этого недопонимания мною же было решено поинтересоваться у общественности через twitter, касательно вытекающего вопроса, что же является анонимной функцией, а что нет?
И для этого было вполне достаточно спросить насчёт небольшого блока кода:
Учитывая возможные колебания в результатах из-за появившихся ответов в комментариях, статистика практически 50/50, это все равно, если бы мы подбрасывали монетку.
Также задавал этот вопрос в личной беседе опытным JavaScript-разработчикам, выступающим на митапах с докладами, и людям не из мира фронтенда, результат развед-опроса был сильно похож на статистику ответов в twitter.
Я знал ответ, это же просто
Если на опрос выше вы ответили, что функция myFunc является анонимной, поздравляю—это правильно! Отметьте этот день красным цветом в календаре, позовите родных и близких, начинайте разливать шампанское по бокалам.
Итак, значит функция в коде блока выше является анонимной:
А что, если я тебе скажу, что ты можешь обратится к свойству name, и получить конкретное значение?
Полученное значение не пустое, но при этом функция выше, как мы выяснили, анонимная, но это же какой-то понятийный коллапс, товарищи! Не торопитесь уходить в backend-разработку, Шерлок Холмс уже начал свое расследование.
Как задать функцию в JavaScript
К тому же, не стоит забывать о существовании Generator Function и об специальном синтаксисе с использованием async, плюс вспомним о setters, getters. Все это добавляет вариации в вышеуказанные способы определения функций.
Усиливаем пример с определением имени. Тесты
Теперь, используя описанные способы выше, возьмём у каждой функции свойство name, и начнем с функций, заданных как Function expression:
Функции, объявленные как Object Method:
Вопросов возникает ещё больше. А может функция в опросе из twitter все таки именованная? Может я ввел вас в заблуждение?
Спецификация. Хардкор
Возможно кто-то считает, что когда-то трава была зеленее, небо голубее и вода мокрее, но в мире JavaScript раньше было определенно хуже! И только начиная со стандарта ECMA-262 6th Edition появилась определенность в понятии анонимной функции, в частности в главе 14 ECMAScript Language: Functions and Classes, посвященной функциям и классам, в пункте 14.1.9 IsAnonymousFunctionDefinition :
Откуда получаем, что для полного понимания придется разобраться в семантике IsFunctionDefinition :
А также разобраться в семантике hasName :
Из семантики hasName для Arrow Function следует, что стрелочные функции всегда анонимны:
С описанием метода объекта дела обстоят несколько сложнее, поскольку может использоваться старый синтаксис через AssignmentExpression или новый через MethodDefinition:
Также помним, что свойству объекта может быть присвоена в качестве значения функция, откуда получаем следующие вариации для метода:
Не удивлюсь, если вы уже устали и запутались, а ведь это далеко не все и я опустил часть перекрестных ссылок между разделами и пунктами спецификации. Лично мне в процессе подготовки статьи удалось запутаться дважды.
Что же стоит запомнить? Все случаи с описанием методов сводятся к Function Expression, где свойству объекта задается в качестве значения функция.
Собирая все воедино, для себя выделил простое правило: если после function есть идентификатор, другими словами имя, тогда функция именованная, во всех остальных случаях анонимная.
Возвращаемся к тестам и ставим точку.
Весь этот путь был проделан не зря, теперь мы с полной уверенностью и без капли сомнения сможем определить, когда функция именованная, когда нет:
Стойте! А как же name?
Не стоит забывать, что JavaScript мультипарадигмальный язык программирования, где есть элементы объектно-ориентированного подхода, где функцию можно рассматривать как объект со своими свойствами. К таким свойствам относится свойство name, и в спецификации легко обнаружить (нет) описание SetFunctionName в 9.2. ECMAScript Function Objects:
И собственно в описаниях классов, методов и функций используется эта абстрактная операция SetFunctionName, которая описывает алгоритм как задается свойство name.
Например, для методов именем функции будет являться имя свойства, согласно 14.3.8 Runtime Semantics: DefineMethod и 14.3.9 Runtime Semantics: PropertyDefinitionEvaluation, а для функций созданных с помощью конструктора Function, именем функции будет “anonymous”:
И лично для себя открыл в спецификации то, как задается имя для функции, привязанной к контексту с помощью метода bind, что описано в разделе 19.2.3.2 Function.prototype.bind, например:
Также подобные префиксы в именах имеют функции, созданные как getter-метод объекта или setter-метод объекта, согласно 14.3.9 Runtime Semantics: PropertyDefinitionEvaluation, например:
AST-ановитесь!
На мой субъективный взгляд, по большей мере спецификация это предписание для интерпретатора EcmaScript, держать такой же в собственной голове есть дело тяжелое и неблагодарное.
Чтобы не тратить драгоценное мыслетопливо на разбор синтаксиса, как вариант, достаточно воспользоваться одним из существующих EcmaScript-парсеров, который поможет определить наличие идентификатора функции и каким способом она была задана.
Например, здесь представлено абстрактное синтаксическое дерево, для ранее созданных тестов, с помощью инструмента ASTExplorer.
Вывод
Как мы выяснили функция, будучи анонимной, может иметь имя, поскольку одновременно является также и объектом, что есть следствие мультипарадигмальной природы языка JavaScript.
В спорах о синтаксисе языка, обращайтесь к первоисточнику, то есть к спецификации EcmaScript актуальной версии.
Изучайте JavaScript! JavaScript — во имя добра!
Что такое анонимная функция и с чем ее едят?
На самом деле классика случая анонимной+замыкание:
А анонимная функция без имени, а без имени она потому что ее вызывают не по имени, а по ссылке на нее.
т.е полный пример с замыканием:
Аудитория требует более тонкого примера применения.
Анонимные функции очень часто используются для выполнения какого-то кода в коллбэках, где в целом не нужно создавать отдельную именную функцию под это действие. Например:
Замыкания же, это такой прием для хранения скрытых данных, и тут конечно тоже можно использовать анонимные функции, но соль не в этом.
Анонимная функция это функция без имени
Вот самый лучший пример использования
Про замыкания с помощью анонимной функции не слыхал.
Ещё можно тебе голову сломать вот этим:
Объяснение нужно? Если что, объясню!
А вообще иногда бывает бессмысленно давать имя функции которая используется только один раз, и кол-во имёт, с которым работаешь ограниченно (если только не имена a, b, c. ).
Это наверно следовало автору написать, надеюсь прочтёт
вы о чём?
По-моему я тоже самое настрочил
Вы вообще к чему разговор ведёте? Анонимные функции не любите? И от меня хотите «услышать», что лучше их не использовать или что.
С самого первого вашего коммента, понять не могу смысл ваших вопросов, я лишь показал возможности и не собираюсь вступать с кем-то в холивар.
Не нравится вам какая-то возможность, не используйте.
Тут парень просто попросил рассказать об этом (и о замыканиях), не больше!
Я всего лишь попросил объяснить, чем отличается в вашем примере работа с анонимными функциями и именованными. А вы стали писать такое, что. Ну вот опять:
$(function()<>)
$(document).ready(function()<>)
Это — вообще одно и то же. Если у вас ошибка, проверьте, так ли записали.
К анонимным функциям имеет опосредованное отношение. Выше показано, как можно передать ссылку на именованную функцию без каких-либо последствий.
!function()<>()
(function()<>)()
Это — способ применения FE там, где ожидается FD. И вот это и есть один из примеров применения анонимных функций.
Я написал вам тот пример и думал, что вы напишете — вот, вот применение анонимных функций. Увы.
А замыкание — это вообще организация работы функций. Любых. Именованных, анонимных. FE, FD, new Function(). Потому что по ECMAScript при создании функции всегда возвращается closure.
Насчёт FE FD я не слышал раньше эти термины, за расшифровку или ссылку на статью (если в двух словах не объяснишь) буду благодарен
Объясните, зачем нужна анонимные самовызов. функции и замыкания?
P.S. Прошу прощения за столь глупые вопросы, но правда, самого понимания пока что не могу найти, а во всяких видео-уроках зачастую просто говорят что она/они делают и т.п.
Если видео уроки не воспринимаются, то почитайте книги, хорошо описывается что это такое в книге Девида Фленагана(6-е издание), затем вас возможно заинтересует «карринг», «мемоизация».
Объясняется в книге Марейна Хавербека, вскользь, но на пальцах.
Много интересного по части функций можно найти в книге Стояна Стефанова «Шаблоны» в разделе Функции, также в разделе Шаблоны создания объектов «Частные свойства и методы».
Функции на самом деле в js очень много интересного выполняют, создаётся объект prototype, arguments, происходит подъём всех переменных в начало функции, создаётся объект для хранения локальных переменных функции во время её вызова, также функции создают так называемую «локальную область видимости», при вызове функции используется лексическая область видимости, функции потенциально являются конструкторами, с помощью функций создаётся пространство имён(модули) и это далеко не полный перечень, поэтому уделите функциям большое внимание.
Засорять глобальную область видимости нехорошо, потому что сложно следить, чтобы эти имена не пересекались в разных файлах, не использовались и не перезаписывались там, где не нужно. Например, если нужно вывести алертом сумму двух чисел numberOne и numberTwo:
Этот пример, конечно, искусственный (потому что на самом деле alert(numberOne + numberTwo) ), но если заменить сложение и алерт на какие-то более-менее объёмные вычисления, то тот факт, что мы не перезаписываем глобальные функции (как в примере было бы с функцией add, если бы мы не обернули код в анонимную функцию), не засоряем глобальную область видимости счётчиками циклов и т. д., может предотвратить некоторые ошибки.
Ещё один пример с замыканием:
Возвращаемая функция берёт значение переменной a из области видимости внешней функции.
Лямбда-выражения в С++
На этом уроке мы рассмотрим лямбда-выражения, их типы и использование в языке C++.
Зачем нужны лямбда-выражения?
Рассмотрим следующий пример:
Хотя это и рабочий код, но мы можем его улучшить.
Проблема кроется в том, что функция std::find_if() требует указатель на функцию в качестве аргумента. Из-за этого мы вынуждены определить новую функцию, которая будет использована только один раз, дать ей имя и поместить её в глобальную область видимости (т.к. функции не могут быть вложенными!). При этом она будет настолько короткой, что быстрее и проще понять её смысл, посмотрев лишь на одну строку кода, нежели изучать описание этой функции и её имя.
Введение в лямбда-выражения
Лямбда-выражение (или просто «лямбда») в программировании позволяет определить анонимную функцию внутри другой функции. Возможность сделать функцию вложенной является очень важным преимуществом, так как позволяет избегать как захламления пространства имен лишними объектами, так и определить функцию как можно ближе к месту её первого использования.
Синтаксис лямбда-выражений является одним из самых странных в языке C++, и вам может потребоваться некоторое время, чтобы к нему привыкнуть.
Лямбда-выражения имеют следующий синтаксис:
Поля captureClause и параметры могут быть пустыми, если они не требуются программисту.
Поле возвращаемыйТип является опциональным, и, если его нет, то будет использоваться вывод типа с помощью ключевого слова auto. Хотя мы ранее уже отмечали, что следует избегать использования вывода типа для возвращаемых значений функций, в данном контексте подобное использование допускается (поскольку обычно такие функции являются тривиальными).
Также обратите внимание, что лямбда-выражения не имеют имен, поэтому нам и не нужно будет их предоставлять. Из этого факта следует, что тривиальное определение лямбды может иметь следующий вид:
Давайте перепишем предыдущий пример, но уже с использованием лямбда-выражений:
При этом всё работает точно так же, как и в случае с указателем на функцию. Результат выполнения программы аналогичен:
Обратите внимание, насколько наша лямбда похожа на функцию containsNut(). Они обе имеют одинаковые параметры и тела функций. Отметим, что у лямбды отсутствует поле captureClause (детально о captureClause мы говорим на уроке о лямбда-захватах), т.к. оно не нужно. Также для краткости мы пропустили синтаксис типа возвращаемого значения trailing, но из-за того, что operator!= возвращает значение типа bool, наша лямбда также будет возвращать логическое значение.
Тип лямбда-выражений
В примере, приведенном выше, мы определили лямбду прямо в том месте, где она была нам нужна. Такое использование лямбда-выражения иногда еще называют функциональным литералом.
Однако написание лямбды в той же строке, где она используется, иногда может затруднить чтение кода. Подобно тому, как мы можем инициализировать переменную с помощью литерала (или указателя на функцию) для использования в дальнейшем, так же мы можем инициализировать и лямбда-переменную с помощью лямбда-определения для её дальнейшего использования. Именованная лямбда вместе с удачным именем функции может облегчить чтение кода.
Например, в следующем фрагменте кода мы используем функцию std::all_of() для того, чтобы проверить, являются ли все элементы массива чётными:
Мы можем улучшить читабельность кода следующим образом:
Обратите внимание, как просто читается последняя строка кода: «… возвращаем все элементы массива, которые являются чётными …».
Оказывается, у лямбд нет типа, который мы могли бы явно использовать. Когда мы пишем лямбду, компилятор генерирует уникальный тип лямбды, который нам не виден.
Для продвинутых читателей: На самом деле, лямбды не являются функциями (что и помогает им избегать ограничений языка C++, которые накладываются на использование вложенных функций). Лямбды являются особым типом объектов, который называется функтором. Функторы — это объекты, содержащие перегруженный operator(), который и делает их вызываемыми подобно обычным функциям.
Хотя мы не знаем тип лямбды, есть несколько способов её хранения для использования после определения. Если лямбда ничего не захватывает, то мы можем использовать обычный указатель на функцию. Как только лямбда что-либо захватывает, указатель на функцию больше не будет работать. Однако std::function может использоваться для лямбд, даже если они что-то захватывают:
К сожалению, мы не всегда можем использовать auto. В тех случаях, когда фактический тип лямбды неизвестен (например, из-за того, что мы передаем лямбду в функцию в качестве параметра, и вызывающий объект сам определяет какого типа лямбда будет передана), мы не можем использовать auto. В таких случаях следует использовать std::function :
Результат выполнения программы:
Правило: Используйте auto при инициализации переменных с помощью лямбд и std::function, если вы не можете инициализировать переменную с помощью лямбд.
Общие/Обобщённые лямбды
По большей части лямбда-параметры работают так же, как и обычные параметры функций.
Одним примечательным исключением является то, что, начиная с C++14, нам разрешено использовать auto с параметрами функций.
Примечание: В C++20 обычные функции также могут использовать auto с параметрами.
Если у лямбды есть один или несколько параметров auto, то компилятор определит необходимые типы параметров из вызовов лямбд-выражений.
Поскольку лямбды с одним или несколькими параметрами типа auto потенциально могут работать с большим количество типов данных, то они называются общими (или «обобщёнными», от англ. «generic lambdas») лямбдами.
Рассмотрим использование общей лямбды на практике:
Результат выполнения программы:
June and July start with the same letter
Однако auto не всегда является лучшим выбором. Рассмотрим следующую программу:
Результат выполнения программы:
There are 2 months with 5 letters
Общие лямбды и статические переменные
Следует иметь в виду, что для каждого отдельного типа, выводимого с помощью auto, будет сгенерирована уникальная лямбда. В следующем примере показано, как общая лямбда разделяется на две отдельные:
Результат выполнения программы:
0: hello
1: world
0: 1
1: 2
2: ding dong
В примере, приведенном выше, мы определяем лямбду и затем вызываем её с двумя различными параметрами (строковым литералом и целочисленным типом). При этом генерируются две различные версии лямбды (одна с параметром строкового литерала, а другая — с параметром в виде целочисленного типа).
В большинстве случаев это не существенно. Однако, обратите внимание, что если в общей лямбде используются статические переменные, то эти переменные не являются общими для генерируемых лямбд.
Если бы мы хотели, чтобы callCount был общим для лямбд, то нам пришлось бы объявить его вне лямбды и захватить его по ссылке, чтобы он мог быть изменен лямбдой.
Вывод возвращаемого типа и возвращаемые типы trailing
Если использовался вывод возвращаемого типа, то возвращаемый тип лямбды выводится из стейтментов return внутри лямбды. Если использовался вывод возвращаемого типа, то все возвращаемые стейтменты внутри лямбды должны возвращать значения одного и того же типа (иначе компилятор не будет знать, какой из них ему следует использовать). Например:
Это приведет к ошибке компиляции, так как тип возвращаемого значения первого стейтмента return ( int ) не совпадает с типом возвращаемого значения второго стейтмента return ( double ).
В случае, когда у нас используются разные возвращаемые типы, у нас есть два варианта:
выполнить явные преобразования в один тип;
явно указать тип возвращаемого значения для лямбды и позволить компилятору выполнить неявные преобразования.
Второй вариант обычно является более предпочтительным:
Таким образом, если вы когда-либо решите изменить тип возвращаемого значения, вам (как правило) нужно будет изменить только тип возвращаемого значения лямбды и ничего внутри основной части.
Функциональные объекты Стандартной библиотеки С++
Для основных операций (например, сложения, вычитания или сравнения) вам не нужно писать свои собственные лямбды, потому что Стандартная библиотека С++ поставляется со многими базовыми вызываемыми объектами, которые вы можете использовать. Эти объекты определены в заголовочном файле functional. Например:
Результат выполнения программы:
Вместо преобразования функции greater() в лямбду, мы можем использовать std::greater :
Результат выполнения программы:
Заключение
Лямбда-выражения и библиотека алгоритмов могут показаться излишне сложными по сравнению с обычными решениями, использующими циклы. Однако эта комбинация позволяет выполнять некоторые очень мощные операции всего в несколько строчек кода и может быть куда читабельнее, чем ваши «самописные» циклы. Кроме того, библиотека алгоритмов обладает мощным и простым в использовании параллелизмом, который вы не получите при использовании циклов. Обновление исходного кода, использующего библиотечные функции, проще, чем обновление кода, использующего циклы.
Лямбды великолепны, но они не заменяют обычные функции для всех случаев. Используйте обычные функции для нетривиальных случаев.
Задание №1
При использовании следующего массива:
Результатом выполнения вашей программы должно быть следующее:
Dan is the best student
Показать подсказку
Ответ №1
Задание №2
Используйте std::sort() и лямбду в следующем коде для сортировки времен года по возрастанию средней температуры:
Результатом выполнения вашей программы должно быть следующее:
Winter
Spring
Fall
Summer
Ответ №2
Поделиться в социальных сетях:
Алгоритмы в Стандартной библиотеке С++
Комментариев: 16
В первом задании теста не мог понять, о какой функции max_element() идёт речь. Решил посмотреть что там в подсказке, понятнее не стало.
Погуглил и выяснил, что это алгоритм, подключаемый заголовочным файлом algoritm. В ответе он не подключён.
Использую VisualStudio. Это с моей стороны что-то не так или же нужно просто подключить заголовочный файл?
Все нормально, подключать #include надо
std::string_view::npos — это специальная константа. Точное значение зависит от контекста, но обычно она используется как индикатор достижения конца строки в процессе некоторого поиска.
Функция str.find(«nut») возвращает либо индекс первого элемента подстроки (если она найдена), либо — npos (если такой подстроки не нашлось) 🙂
Почему в первом задании теста uniform-инициализация происходит так:
?
Попробовал в VS второй вариант, и действительно, студия ругается. Но почему, в таком случае, можно спокойно объявить с помощью uniform-инициализации массив std::array целых чисел следующим образом:
И студия не будет ругаться? Почему при объявлении структур таким образом она ругается (говорит, что слишком много значений инициализатора (компилятор)). Нелогично, на мой взгляд.
Потому что ты невнимательный. В твоем примере массив из фундаментальных типов int, и он(int) принимает 1 параметр.
А в случае того же массива из структур Student, и он(Student) принимает 2 параметра.
Будь внимательней.
Вопрос про второй комплект угловых скобок. Причем здесь второй параметр?
На сколько я понял, они здесь вместо знака равно, тоесть обычное присваивание.
Вот мои наблюдения:
«Правило: Используйте auto при инициализации переменных с помощью лямбд и std::function, если вы не можете инициализировать переменную с помощью лямбд.»
А мне кажется, что лучше всегда использовать std::function, тем более что после C++17 и тип возврата, и типы параметров указывать необязательно. На мой взгляд ключевое слово auto уже немного устарел 🙂
Здравствуйте) Если кому то не сложно, не могли бы вы обьяснить предложение «Функция std::max_element() принимает begin и end списка и функцию с двумя параметрами, которая возвращает true, если первый аргумент меньше второго.». Я не совсем понимаю зачем в этой функции нужен третий параметр в виде лямбды. Заранее благодарю всех кто ответит.
Так а как вы собираетесь сравнивать двух студентов между собой? Это же составной тип данных, С++ ничего не знает про сравнение подобных переменных. Поэтому вы сами должны написать эту функцию (в виде лямбды) 🙂
Я прочитала этот урок дважды с перерывом в неделю. И всё равно есть чувство, что я поняла не всё.
Во-первых, урок очень длинный.
Во-вторых, в примерах используется std::string_view, о котором до конца апреля в этих уроках ничего не было. Также используются алгоритмы STL, которые здесь также объяснялись скорее для расширения кругозора.
В-третьих, кусок «Если лямбда ничего не захватывает, мы можем использовать обычный указатель на функцию. Как только лямбда захватывает что-либо, указатель на функцию больше не будет работать. » не ясно, что значит, что лямбда что-то захватывает. Я подозреваю, что это связано с [Capture clause], который здесь никак не поясняется, но должен быть раскрыт в следующем уроке.
В-четвёртых, главное правило данного урока «Используйте auto при инициализации переменных с помощью лямбд и std::function, если вы не можете инициализировать переменную с помощью лямбд.» тоже не до конца раскрыто. Я прочитала пример, но до конца так и не поняла, в чём разница, и как это на практике разделять. Возможно, причина в том, что слово «лямбда» в данном уроке заменяет несколько разных смыслов, связанных с лямбда-выражениями. Скорей всего, речь идёт о том, что когда мы даём имя нашему лямбда-выражению, мы можем указать только тип auto. Или другие, более конкретные типы тоже возможны? Судя по тому, что я прочитала, нет, но ведь auto превращается в конкретный тип из return…
В-пятых, абзац «Если использовался вывод возвращаемого типа, то возвращаемый тип лямбды выводится из стейтментов return внутри лямбды. Если использовался вывод возвращаемого типа, то все возвращаемые стейтменты внутри лямбды должны возвращать значения одного и того же типа…» Два предложения, начинающихся с одного и того же условия «Если использовался вывод возвращаемого типа» почему бы тогда не переписать это как-то так, чтобы не путать читателя:
Если использовался вывод возвращаемого типа:
1) возвращаемый тип лямбды выводится из стейтментов return внутри лямбды
2) все возвращаемые стейтменты внутри лямбды должны возвращать значения одного и того же типа
Хотя нет, даже так не понятно, что имеется в виду под «вывод» — печать на экране? В лямбда-выражении или в вызывающей функции?
В общем, здесь я попыталась проанализировать, что же заставило меня прокрастинировать с этим уроком целую неделю и почему до сих пор даже после второго прочтения у меня нет чувства, что «всё понятно». Хотя, судя по всему, тема несложная.
1. Урок действительно больше обычного урока по С++, но посмотрите на уроки по OpenGL и тогда этот урок Вам не будет казаться таким уж большим 🙂
2. Вместе с этим уроком были добавлены уроки по std::string_view и по алгоритмам.
3. Есть отдельный урок и по лямбда-захватам (они же capture clause).