В этом тьюториале мы рассмотрим с вами, что такое лямбда-функции и замыкания, а также примеры их использования.
Чтобы выполнить задания, вам потребуются следующие программы:
Примечания:
- Мы предполагаем, что у вас есть базовые знания PHP.
Что это за функции такие: лямбда и замыкание?
В PHP 5.3 есть множество интересных возможностей, которые приближают его синтаксис к таким языкам программирования как: JavaScript, Python, Ruby и т.д. И, что более важно, эти возможности полезны и стали популярными.
Лямбда-функции и замыкания — это программные объекты, не обладающие именем, они реализуются там, где потребовалась их помощь. Обратите внимание, лямбда-функции не захватывают контекст, а замыкания предназначены для его захвата. Сразу скажем, обе эти функций в PHP по типу соответствуют классу Closure , и указанные выше отличия не принципиальны для практического использования в PHP. В практике вы заметите только то, что от класса Closure ни наследоваться нельзя, ни экземпляры создавать. Его ввели только для внутреннего использования — для типизации.
Лямбда-функции
- Научится использовать лямбда функции в качестве параметров других функций
Лямбда-функции , оказывается, очень полезны для “здоровья” некоторых функций , особенно тех, которые требуют в качестве параметра функцию .
Давайте рассмотрим функцию usort() , сортирующую любые массивы. Для своей работы она требует два параметра. Первый — массив, который надо отсортировать. Второй — функция, с двумя аргументами. В этой функции сравниваются два значения, которые ей передали. Она должна возвращать 0 если они равны, -1 если первое меньше и 1 если второе меньше.
Представьте, что нам всего в одном месте программы нужно отсортировать массив объектов по некоторому полю, нам не нужно объявлять отдельную функцию, мы воспользуемся лямбда-функцией. В Листинге №1 показано как использовать лямбда-функцию для сортировки массива.
Листинг №1 (строки лямбда-функции подсвечены):
number = $number; } public function getNumber() { return $this->number; } } $aNumber = array(); for($i = 0; $i < 10; $i++) { $oNumber = new naturalNumber(); $oNumber->setNumber(rand(1, 10)); $aNumber = $oNumber; } echo "До сортировки:
"; print_r($aNumber); echo ""; usort($aNumber, function($oFirst, $oSecond) { if($oFirst->getNumber() < $oSecond->getNumber()) { return -1; } $result = ($oFirst->getNumber() == $oSecond->getNumber()) ? 0: 1; return $result; }); echo "После сортировки:
"; print_r($aNumber); echo ""; ?>
В этом примере происходит заполнение массива $aNumber объектами, которые создаются на основе класса naturalNumber . В каждом объекте хранится случайное число, доступ к которому осуществляется через функции getNumber() и setNumber() . Затем происходит сортировка массива с использованием лямбда-функции. Для usort() необходимо, чтобы вторым параметром была указана функция с двумя аргументами, каждый из которых должен соответствовать по типу элементам сортируемого массива. После заполнения массива и в конце программы происходит вывод массива.
Замыкания
- Использовать контекст функции
Замыкания тоже «вкусны» по-своему, оттенки их «вкуса» можно заметить не всегда. Их применение в коде похоже по стилю на JavaScript. Замыкания, кроме того что они используют переменные контекста, в котором они определены, обладают ещё одним замечательным свойством — их время жизни может быть больше, чем у той функции, в которой их определили.
Для примера захвата значений переменных, возьмём суммирование массива и возвращение результата в контекст программы. Если точнее, захватываться будет ссылка на переменную, в которой будет происходить суммирование. Для полного счастья, суммировать будем рекурсивно по массиву:), побываем во всех его уголках. Пример программы показан в Листинге №2 :
Листинг №2 (строки замыкания подсвечены):
"; ?>
В этом примере происходит создание строки из многомерного массива, путём склеивания всех его элементов через пробел. Стандартно для склеивания используется функция implode() , но здесь не тот случай — она не склеивает многомерные массивы. Может для кого-то этот пример будет кстати.
Существует особенность, которую нужно учитывать, когда вы используете замыкание в методе (метод — функция, член класса). Оказывается оно (замыкание) не захватывает внутреннюю переменную $this (отвечающую за текущий экземпляр). Для того, чтобы её всё-таки передать в замыкание, нужно использовать локальную переменную, например вот так $self = $this , а затем уже передавать в замыкание use($self) .
Способов применения этим функциям можно найти массу. К примеру, можно создавать проекты в стиле JavaScript, можно продлевать жизнь параметрам и переменным и ещё многое. Будем надеяться, что в PHP 6 этот механизм станет более похож на то, что уже есть в других языках.
Есть вопросы? Добро пожаловать в коментарии.
Среди новшеств, которые были привнесены в язык Java с выходом JDK 8, особняком стоят лямбда-выражения. Лямбда представляет набор инструкций, которые можно выделить в отдельную переменную и затем многократно вызвать в различных местах программы.
Основу лямбда-выражения составляет лямбда-оператор , который представляет стрелку -> . Этот оператор разделяет лямбда-выражение на две части: левая часть содержит список параметров выражения, а правая собственно представляет тело лямбда-выражения, где выполняются все действия.
Лямбда-выражение не выполняется само по себе, а образует реализацию метода, определенного в функциональном интерфейсе . При этом важно, что функциональный интерфейс должен содержать только один единственный метод без реализации.
Рассмотрим пример:
Public class LambdaApp { public static void main(String args) { Operationable operation; operation = (x,y)->x+y; int result = operation.calculate(10, 20); System.out.println(result); //30 } } interface Operationable{ int calculate(int x, int y); }
В роли функционального интерфейса выступает интерфейс Operationable , в котором определен один метод без реализации - метод calculate . Данный метод принимает два параметра - целых числа, и возвращает некоторое целое число.
По факту лямбда-выражения являются в некотором роде сокращенной формой внутренних анонимных классов, которые ранее применялись в Java. В частности, предыдущий пример мы можем переписать следующим образом:
Public class LambdaApp { public static void main(String args) { Operationable op = new Operationable(){ public int calculate(int x, int y){ return x + y; } }; int z = op.calculate(20, 10); System.out.println(z); // 30 } } interface Operationable{ int calculate(int x, int y); }
Чтобы объявить и использовать лямбда-выражение, основная программа разбивается на ряд этапов:
Operationable operation;
Создание лямбда-выражения:
Operation = (x,y)->x+y;
Причем параметры лямбда-выражения соответствуют параметрам единственного метода интерфейса Operationable, а результат соответствует возвращаемому результату метода интерфейса. При этом нам не надо использовать ключевое слово return для возврата результата из лямбда-выражения.
Так, в методе интерфейса оба параметра представляют тип int , значит, в теле лямбда-выражения мы можем применить к ним сложение. Результат сложения также представляет тип int , объект которого возвращается методом интерфейса.
Использование лямбда-выражения в виде вызова метода интерфейса:
Int result = operation.calculate(10, 20);
Так как в лямбда-выражении определена операция сложения параметров, результатом метода будет сумма чисел 10 и 20.
При этом для одного функционального интерфейса мы можем определить множество лямбда-выражений. Например:
Operationable operation1 = (int x, int y)-> x + y; Operationable operation2 = (int x, int y)-> x - y; Operationable operation3 = (int x, int y)-> x * y; System.out.println(operation1.calculate(20, 10)); //30 System.out.println(operation2.calculate(20, 10)); //10 System.out.println(operation3.calculate(20, 10)); //200
Отложенное выполнение
Одним из ключевых моментов в использовании лямбд является отложенное выполнение (deferred execution). То есть мы определяем в одном месте программы лямбда-выражение и затем можем его вызывать при необходимости неопределенное количество раз в различных частях программы. Отложенное выполнение может потребоваться, к примеру, в следующих случаях:
Выполнение кода отдельном потоке
Выполнение одного и того же кода несколько раз
Выполнение кода в результате какого-то события
Выполнение кода только в том случае, когда он действительно необходим и если он необходим
Передача параметров в лямбда-выражение
Параметры лямбда-выражения должны соответствовать по тип параметрам метода из функционального интерфейса. При написании самого лямбда-выражения тип параметров писать необязательно, хотя в принципе это можно сделать, например:
Operation = (int x, int y)->x+y;
Если метод не принимает никаких параметров, то пишутся пустые скобки, например:
()-> 30 + 20;
Если метод принимает только один параметр, то скобки можно опустить:
N-> n * n;
Терминальные лямбда-выражения
Выше мы рассмотрели лямбда-выражения, которые возвращают определенное значение. Но также могут быть и терминальные лямбды, которые не возвращают никакого значения. Например:
Interface Printable{ void print(String s); } public class LambdaApp { public static void main(String args) { Printable printer = s->System.out.println(s); printer.print("Hello Java!"); } }
Лямбды и локальные переменные
Лямбда-выражение может использовать переменные, которые объявлены во вне в более общей области видимости - на уровне класса или метода, в котором лямбда-выражение определено. Однако в зависимости от того, как и где определены переменные, могут различаться способы их использования в лямбдах. Рассмотрим первый пример - использования переменных уровня класса:
Public class LambdaApp { static int x = 10; static int y = 20; public static void main(String args) { Operation op = ()->{ x=30; return x+y; }; System.out.println(op.calculate()); // 50 System.out.println(x); // 30 - значение x изменилось } } interface Operation{ int calculate(); }
Переменные x и y объявлены на уровне класса, и в лямбда-выражении мы их может получить и даже изменить. Так, в данном случае после выполнения выражения изменяется значение переменной x.
Теперь рассмотрим другой пример - локальные переменные на уровне метода:
Public static void main(String args) { int n=70; int m=30; Operation op = ()->{ //n=100; - так нельзя сделать return m+n; }; // n=100; - так тоже нельзя System.out.println(op.calculate()); // 100 }
Локальные переменные уровня метода мы также может использовать в лямбдах, но изменять их значение мы уже не сможем. Если мы попробуем это сделать, то среда разработки (Netbeans) может нам высветить ошибку и то, что такую переменную надо пометить с помощью ключевого слова final , то есть сделать константой: final int n=70; . Однако это необязательно.
Более того, мы не сможем изменить значение переменной, которая используется в лямбда-выражении, вне этого выражения. То есть даже если такая переменная не объявлена как константа, по сути она является константой.
Блоки кода в лямбда-выражениях
Существуют два типа лямбда-выражений: однострочное выражение и блок кода. Примеры однострочных выражений демонстрировались выше. Блочные выражения обрамляются фигурными скобками. В блочных лямбда-выражениях можно использовать внутренние вложенные блоки, циклы, конструкции if, switch, создавать переменные и т.д. Если блочное лямбда-выражение должно возвращать значение, то явным образом применяется оператор return:
Operationable operation = (int x, int y)-> { if(y==0) return 0; else return x/y; }; System.out.println(operation.calculate(20, 10)); //2 System.out.println(operation.calculate(20, 0)); //0
Обобщенный функциональный интерфейс
Функциональный интерфейс может быть обобщенным, однако в лямбда-выражении использование обобщений не допускается. В этом случае нам надо типизировать объект интерфейса определенным типом, который потом будет применяться в лямбда-выражении. Например:
Public class LambdaApp {
public static void main(String args) {
Operationable
Таким образом, при объявлении лямбд-выражения ему уже известно, какой тип параметры будут представлять и какой тип они будут возвращать.
Эта документация перемещена в архив и не поддерживается.
Самая актуальная документация по Visual Studio 2017: Документация по Visual Studio 2017 .
Лямбда-выражение (или просто лямбда ) в C++11 - это удобный способ определения анонимного объекта-функции непосредственно в месте его вызова или передачи в функцию в качестве аргумента. Обычно лямбда-выражения используются для инкапсуляции нескольких строк кода, передаваемых алгоритмам или асинхронным методам. В этой статье приводится определение лямбда-выражений, их сравнение с другими методами программирования, описание их преимуществ и простой пример.
В стандарте ISO C++ демонстрируется простое лямбда-выражение, передаваемое функции std::sort() в качестве третьего аргумента:
#include
На следующем рисунке показана структура лямбда-выражения:
предложение фиксации (в спецификации C++ это lambda-introducer .)
список параметров (необязательно). (Также именуется как lambda declarator .)
отключаемая спецификация (необязательно).
спецификация исключений (необязательно).
завершающий возвращаемый тип (необязательно).
тело лямбда-выражения )
Предложение фиксации
В теле лямбда-выражения могут вводиться новые переменные (в C ++14 ). Кроме того, лямбда-выражения могут использовать, или фиксировать , переменные из окружающей области видимости. Лямбда-выражение начинается с предложения фиксации (в синтаксисе стандарта - lambda-introducer ), в котором указываются фиксируемые переменные, а также способ фиксации: по значению или по ссылке. Доступ к переменным с префиксом с амперсандом (&) осуществляется по ссылке, а к переменным без префикса - по значению.
Пустое предложение фиксации () показывает, что тело лямбда-выражения не осуществляет доступ к переменным во внешней области видимости.
Чтобы задать способ фиксации внешних переменных, на которые ссылается лямбда-выражение, вы можете использовать режим фиксации по умолчанию (в синтаксисе стандарта - capture-default): [&] - все переменные фиксируются по ссылке, [=] - по значению. Можно сначала использовать режим фиксации по умолчанию, а затем применить для определенных переменных другой режим. Например, если тело лямбда-выражения осуществляет доступ к внешней переменной total по ссылке, а к внешней переменной factor по значению, следующие предложения фиксации эквивалентны:
[&total, factor] [&, factor] [=, &total] [&total, =]
При использовании capture-default фиксируются только переменные, упомянутые в лямбда-выражении.
Если предложение фиксации включает capture-default & , ни один identifier в параметре capture этого предложения фиксации не может иметь форму & identifier . Аналогично, если предложение фиксации включает capture-default = , ни один параметр capture этого предложения фиксации не может иметь форму = identifier . Идентификатор или this не могут использоваться более одного раза в предложении захвата. В следующем фрагменте кода приводится несколько примеров.
struct S { void f(int i); }; void S::f(int i) { [&, i]{}; // OK [&, &i]{}; // ERROR: i preceded by & when & is the default [=, this ]{}; // ERROR: this when = is the default {}; // ERROR: i repeated }
capture с последующим многоточием является расширением пакета, как показано в следующем примере :
template
Чтобы использовать лямбда-выражения в теле метода класса, необходимо передать указатель this предложению фиксации, чтобы обеспечить доступ к методам и данным-членам включающего класса. Пример использования лямбда-выражений с методами классов см. в разделе (подраздел "Использование лямбда-выражения в методе").
Фиксацию ссылок можно использовать для изменения переменных снаружи, тогда как фиксацию значений нельзя. (mutable позволяет изменять копии, но не оригиналы.)
Фиксация ссылок отражает изменение переменных снаружи, тогда как фиксация значений - нет.
Фиксация ссылки вводит зависимость от времени существования, тогда как фиксация значения не обладает зависимостями от времени существования. Это особенно важно в случае асинхронного использования лямбда-выражений. Если в асинхронном лямбда-выражении по ссылке фиксируется локальная переменная, вполне вероятно, что к моменту его вызова она станет недоступной, что вызовет исключение нарушения прав доступа во время выполнения.
Обобщенная фиксация (C++14)
В C++14 вы можете объявлять и инициализировать новые переменные в предложении фиксации. Для этого не требуется, чтобы эти переменные существовали во внешней области видимости лямбда-функции. Инициализация может быть выражена в качестве любого произвольного выражения. Тип новой переменной определяется типом, который создается выражением. Одно из преимуществ этой возможности заключается в том, что в C++14 таким образом можно фиксировать переменные из окружающей области видимости, доступные только для перемещения (например std::unique_ptr), и использовать их в лямбда-выражении.
pNums = make_unique
Список параметров
В дополнение к возможности фиксации переменных, лямбда-выражения могут принимать входные параметры. Список параметров (в синтаксисе стандарта - lambda declarator ) является необязательным элементом и, по большей части, походит на список параметров функции.
int y = (int first, int second) { return first + second; };
В C++14 , если используются универсальные параметры, в качестве спецификатора типа можно задействовать ключевое слово auto. Это отдает компилятору команду создать оператор вызова функции в качестве шаблона. Каждый экземпляр ключевого слова auto в списке параметров эквивалентен параметру отдельного типа.
auto y = (auto first, auto second) { return first + second; };
Лямбда-выражение может принимать другое лямбда-выражение в качестве своего аргумента. Дополнительные сведения см. в разделе (подраздел "Лямбда-выражения высшего порядка").
Поскольку список параметров является необязательным, можно опустить пустые скобки, если аргументы не передаются в лямбда-выражение и lambda-declarator: не содержит элементы exception-specification , trailing-return-type или mutable .
Отключаемая спецификация
Как правило, оператор вызова функции лямбда-выражения является константой по значению, но ключевое слово mutable отменяет это. Он не создает изменяемые данные-члены. Отключаемая спецификация позволяет телу лямбда-выражения изменять переменные, захваченные по значению. Некоторые примеры далее в этой статье демонстрируют использование ключевого слова mutable .
Спецификация исключений
Можно использовать спецификацию исключений throw() , чтобы указать, что лямбда-выражение не создает исключений. Как и в случае с обычными функциями, компилятор Visual C++ создает предупреждение , если лямбда-выражение объявляет спецификацию исключения throw() , и тело лямбда-выражения вызывает исключение, как показано ниже:
// throw_lambda_expression.cpp // compile with: /W4 /EHsc int main() // C4297 expected { () throw () { throw 5; }(); }
Тип возвращаемого значения
Возвращаемый тип лямбда-выражения выводится автоматически. Использовать ключевое слово не нужно, если не указывается завершающий возвращающий тип . trailing-return-type похож на часть стандартного метода или функции, содержащую возвращаемый тип. Однако тип возвращаемого значения следует списку параметров, и необходимо включить ключевое слово -> элемента trailing-return-type перед типом возвращаемого значения.
Можно опустить часть возвращаемого типа лямбда-выражения, если тело лямбда-выражения содержит только один оператор return или лямбда-выражение не возвращает значение. Если тело лямбда-выражения содержит один оператор return, компилятор выводит тип возвращаемого значения из типа возвращаемого выражения. В противном случае компилятор выводит следующий тип возвращаемого значения: void . Рассмотрим следующие примеры кода, иллюстрирующие этот принцип.
auto x1 = (int i){ return i; }; // OK: return type is int auto x2 = { return { 1, 2 }; }; // ERROR: return type is void, deducing // return type from braced-init-list is not valid
Лямбда-выражение может создавать другое лямбда-выражение в качестве своего возвращаемого значения. Дополнительные сведения см. в разделе (подраздел "Лямбда-выражения высшего порядка").
Тело лямбда-выражения
Часть лямбда-выражения, содержащая его тело (compound-statement в синтаксисе стандарта), может содержать те же элементы, что и тело обычного метода или функции. Тело обычной функции и лямбда-выражения может осуществлять доступ к следующим типам переменных:
Фиксированные переменные из внешней области видимости (см. выше).
Параметры
Локально объявленные переменные
Данные-члены класса (при объявлении внутри класса и фиксации this)
Любая переменная, которая имеет статическую длительность хранения (например, глобальная переменная)
В следующем примере содержится лямбда-выражение, которое явно фиксирует переменную n по значению и неявно фиксирует переменную m по ссылке.
// captures_lambda_expression.cpp
// compile with: /W4 /EHsc
#include
Результат:
5
0
Поскольку переменная n фиксируется по значению, ее значение после вызова лямбда-выражения остается равным 0 . Спецификация mutable позволяет изменять n внутри лямбда-выражения.
Несмотря на то что лямбда-выражение может фиксировать только переменные с автоматической длительностью хранения, в теле лямбда-выражения можно использовать переменные, которые имеют статическую длительность хранения. В следующем примере функция generate и лямбда-выражение используются для присвоения значения каждому элементу объекта vector . Лямбда-выражение изменяет статическую переменную для получения значения следующего элемента.
void
fillVector(vector
Дополнительные сведения см. разделе .
В следующем примере кода используется функция из предыдущего примера и добавляется пример лямбда-выражения с алгоритмом STL generate_n . Это лямбда-выражение назначает элемент объекта vector сумме предыдущих двух элементов. Ключевое слово mutable используется, чтобы тело лямбда-выражения могло изменять соответствующие копии внешних переменных x и y , захваченные лямбда-выражением по значению. Поскольку лямбда-выражение захватывает исходные переменные x и y по значению, их значения остаются равными 1 после выполнения лямбда-выражения.
NextValue++; });
//WARNING: this is not thread-safe and is shown for illustration only
}
int
main()
{
// The number of elements in the vector.
const
int
elementCount = 9;
// Create a vector object with each element set to 1.
vector
Результат:
vector v after call to generate_n() with lambda: 1 1 2 3 5 8 13 21 34
x: 1 y: 1
vector v after 1st call to fillVector(): 1 2 3 4 5 6 7 8 9
vector v after 2nd call to fillVector(): 10 11 12 13 14 15 16 17 18
Дополнительные сведения см. в разделе .
Лямбда-выражения не поддерживаются в следующих управляемых сущностях среды CLR: ref class , ref struct , value class и value struct .
Если вы используете модификаторы, характерные для систем Майкрософт, такие как , их можно вставить в лямбда-выражение сразу после parameter-declaration-clause , например:
Необязательный параметр attribute-specifier-seq не поддерживается в этой версии.
Visual Studio включает следующие функции в дополнение к функциям лямбда-выражений стандарта C++11:
Не имеющие состояний лямбда-выражения являются универсально преобразуемыми в указатели функций с произвольными соглашениями о вызовах.
Автоматически выведенные возвращаемые типы для тела лямбда-выражений, которые сложнее, чем { return expression; } , при условии, что все возвращаемые выражения относятся к одному типу. (Эта функция является частью предложенного стандарта C++14.)
Показ:
Высокоуровневая функция - это функция, которая принимает другую функцию в качестве входного аргумента, либо имеет функцию в качестве возвращаемого результата. Хорошим примером такой функции является lock() , которая берёт залоченный объект и функцию, применяет лок, выполняет функцию и отпускает lock:
Fun
Давайте проанализируем этот блок. Параметр body имеет функциональный тип: () -> T , то есть предполагается, что это функция, которая не имеет никаких входных аргументов и возвращает значение типа T . Она вызывается внутри блока try , защищена lock , и её результат возвращается функцией lock() .
Fun toBeSynchronized() = sharedResource.operation() val result = lock (lock, ::toBeSynchronized)
Другой, наиболее удобный способ применения лямбда-выражения :
Val result = lock(lock, { sharedResource.operation() })
Лямбда-выражения более подробно описаны , но в целях продолжить этот раздел, давайте произведём краткий обзор:
- Лямбда-выражения всегда заключены в фигурные скобки,
- Параметры этого выражения (если такие есть) объявлены до знака -> (параметры могут быть опущены),
- Тело выражения идёт после знака -> .
В Kotlin существует конвенция, по которой, если последний параметр функции является функцией, и вы применяете лямбда- выражение в качестве аргумента, вы можете указать её вне скобок:
Lock (lock) { sharedResource.operation() }
Другим примером функции высшего порядка служит функция map() :
Fun
Эта функция может быть вызвана следующим образом:
Val doubled = ints.map { it -> it * 2 }
Обратите внимание, что параметры могут быть проигнорированы при вызове функции в том случае, если лямбда является единственным аргументом для её вызова.
Ключевое слово it: неявное имя единственного параметра
Ещё одной полезной особенностью синтаксиса является возможность опустить объявление параметра функции в случае, если он единственный (вместе с ->). Слово it будет принято в качестве имени для такой функции:
Ints.map { it * 2 }
Это соглашение позволяет писать код в LINQ стиле:
Strings.filter { it.lenght == 5 }.sortBy { it }.map { it.toUpperCase() }
Инлайн функции
Иногда необходимо улучшить производительность высокоуровневых функций, используя инлайн функции .
Лямбда-выражения и анонимные функции
Лямбда-выражения или анонимные функции являются "функциональными константами" (ориг. "functional literal") , то есть функциями, которые не были объявлены, но сразу были переданы в качестве выражения. Рассмотрим следующий пример:
Max(strings, { a, b -> a.length < b.length })
Функция max - высокоуровневая функция, так как она принимает другую функцию в качестве входного аргумента. Этот второй аргумент является выражением, которое само по себе представляет из себя функцию, то есть functional literal .
Fun compare(a: String, b: String): Boolean = a.length < b.length
Типы функций
Для того, чтобы функция принимала другую функцию в качестве входного параметра, нам необходимо указать её (входящей функции) тип. К примеру, вышеуказанная функция max определена следующим образом:
Fun
Параметр "less" является (T, T) -> Boolean типом, то есть функцией, которая принимает два параметра типа T и возвращает "Boolean":"true", если первый параметр меньше, чем второй.
В теле функции, строка 4, less используется в качестве функции: она вызывается путём передачи двух аргументов типа T .
Тип функции может быть написан так, как указано выше, или же может иметь определённые параметры, если вы хотите обозначить значения каждого из параметров.
Val compare: (x: T, y: T) -> Int = ...
Синтаксис лямбда-выражений
Полная синтаксическая форма лямбда-выражений, таких как literals of function types , может быть представлена следующим образом:
Val sum = { x: Int, y: Int -> x + y }
Лямбда-выражение всегда заключено в скобки {...} , объявление параметров при таком синтаксисе происходит внутри этих скобок и может включать в себя аннотации типов (опционально), тело функции начинается после знака -> . Если тип возвращаемого значения не Unit , то в качестве возвращаемого типа принимается последнее (а возможно и единственное) выражение внутри тела лямбды.
Если мы вынесем все необязательные объявления, то, что останется, будет выглядеть следующим образом:
Val sum: (Int, Int) -> Int = { x, y -> x + y }
Обычное дело, когда лямбда-выражение имеет только один параметр. Если Kotlin может определить сигнатуру метода сам, он позволит нам не объявлять этот единственный параметр, и объявит его сам под именем it:
Ints.filter { it > 0 } //Эта константа имеет тип "(it: Int) -> Boolean"
Мы можем явно вернуть значение из лямбды, используя qualified return синтаксис:
Ints.filter { val shouldFilter = it > 0 shouldFilter } ints.filter { val shouldFilter = it > 0 return@filter shouldFilter }
Обратите внимение, что функция принимает другую функцию в качестве своего последнего параметра, аргумент лямбда-выражения в таком случае может быть принят вне списка аргументов, заключённого в скобках. См. callSuffix .
Анонимные функции
Единственной особенностью синтаксиса лямбда-выражений, о которой ещё не было сказано, является способность определять и назначать возвращаемый функцией тип. В большинстве случаев в этом нет особой необходимости, потому что он может быть вычислен автоматически. Однако, если у вас есть потребность в определении возвращаемого типа, вы можете воспользоваться альтернативным синтаксисом:
Fun(x: Int, y: Int): Int = x + y
Объявление анонимной функции выглядит очень похоже на обычное объявление функции, за исключением того, что её имя опущено. Тело такой функции может быть описано и выражением (как показано выше), и блоком:
Fun(x: Int, y: Int): Int { return x + y }
Параметры функции и возвращаемый тип обозначаются таким же образом, как в обычных функциях. Правда, тип параметра может быть опущен, если его значение следует из контекста:
Ints.filter(fun(item) = item > 0)
Аналогично и с типом возвращаемого значения: он вычисляется автоматически для функций-выражений или же должен быть определён вручную (если не является типом Unit) для анонимных функций, которые имеют в себе блок.
Обратите внимание, что параметры анонимных функций всегда заключены в скобки {...} . Приём, позволяющий оставлять параметры вне скобок, работает только с лямбда-выражениями.
Одним из отличий лямбда-выражений от анонимных функций является поведение оператора return (non-local returns). Слово return , не имеющее метки (@), всегда возвращается из функции, объявленной ключевым словом fun . Это означает, что return внутри лямбда-выражения возвратит выполнение к функции, включающей в себя это лямбда-выражение. Внутри анонимных функций оператор return , в свою очередь, выйдет, собственно, из анонимной функции.
Замыкания
Лямбда-выражение или анонимная функция (так же, как и локальная функция или object expression) имеет доступ к своему замыканию, то есть к переменным, объявленным вне этого выражения или функции. В отличае от Java, переменные, захваченные в замыкании, могут быть изменены:
Var sum = 0 ints.filter { it > 0 }.forEach { sum += it } print(sum)
Литералы функций с объектом-приёмником
Kotlin предоставляет возможность вызывать литерал функции с указаным объектом-приёмником. Внутри тела литерала вы можете вызывать методы объекта-приёмника без дополнительных определителей. Это схоже с принципом работы расширений , которые позволяют получить доступ к членам объекта-приёмника внутри тела функции. Один из самых важных примеров использования литералов с объектом-приёмником это Type-safe Groovy-style builders .
Тип такого литерала - это тип функции с приёмником:
Sum: Int.(other: Int) -> Int
По аналогии с расширениями, литерал функции может быть вызван так, будто он является методом объекта-приёмника:
1.sum(2)
Синтаксис анонимной функции позволяет вам явно указать тип приёмника. Это может быть полезно в случае, если вам нужно объявить переменную типа нашей функции для использования в дальнейшем.
Val sum = fun Int.(other: Int): Int = this + other
Лямбда-выражения могут быть использованы как литералы функций с приёмником, когда тип приёмника может быть выведен из контекста.
Class HTML { fun body() { ... } } fun html(init: HTML.() -> Unit): HTML { val html = HTML() // создание объекта-приёмника html.init() // передача приёмника в лямбду return html } html { // лямбда с приёмником начинается тут body() // вызов метода объекта-приёмника }
Java изначально полностью объектно-ориентированный язык. За исключением примитивных типов, все в Java – это объекты. Даже массивы являются объектами. Экземпляры каждого класса – объекты. Не существует ни единой возможности определить отдельно (вне класса – прим. перев.
) какую-нибудь функцию. И нет никакой возможности передать метод как аргумент или вернуть тело метода как результат другого метода. Все так. Но так было до Java 8.
Со времен старого доброго Swing, надо было писать анонимные классы, когда нужно было передать некую функциональность в какой-нибудь метод. Например, так выглядело добавление обработчика событий:
someObject.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
//Event listener implementation goes here...
}
});
Здесь мы хотим добавить некоторый код в слушатель событий от мыши. Мы определили анонимный класс MouseAdapter и сразу создали объект из него. Таким способом мы передали дополнительную функциональность в метод addMouseListener.
Короче говоря, не так-то просто передать простой метод (функциональность) в Java через аргументы. Это ограничение вынудило разработчиков Java 8 добавить в спецификацию языка такую возможность как Lambda-выражения.
Зачем яве Lambda-выражения?
С самого начала, язык Java особо не развивался, если не считать такие вещи как аннотации (Annotations), дженерики (Generics) и пр. В первую очередь, Java всегда оставался объектно-ориентированным. После работы с функциональными языками, такими как JavaScript, можно понять насколько Java строго объектно-ориентирован и строго типизирован. Функции в Java не нужны. Сами по себе их нельзя встретить в мире Java.В функциональных языках программирования на первый план выходят функции. Они существуют сами по себе. Можно присваивать их переменным и передавать через аргументы другим функциям. JavaScript один из лучших примеров функциональных языков программирования. На просторах Интернета можно найти хорошие статьи, в которых детально описаны преимущества JavaScript как функционального языка. Функциональные языки имеют в своем арсенале такие мощные инструменты как замыкания (Closure), которые обеспечивают ряд преимуществ на традиционными способами написания приложений. Замыкание – это функция с привязанной к ней средой - таблицей, хранящей ссылки на все нелокальные переменные функции. В Java замыкания можно имитировать через Lambda-выражения. Безусловно между замыканиями и Lambda-выражениями есть отличия и не малые, но Lambda-выражения являются хорошей альтернативой замыканиям.
В своем саркастичном и забавном блоге, Стив Иег (Steve Yegge) описывает насколько мир Java строго завязан на имена существительные (сущности, объекты – прим. перев. ). Если вы не читали его блог, рекомендую. Он забавно и интересно описывает точную причину того, почему в Java добавили Lambda-выражения.
Lambda-выражения привносят в Java функциональное звено, которого так давно не хватало. Lambda-выражения вносят в язык функциональность на равне с объектами. Хотя это и не на 100% верно, можно видеть, что Lambda-выражения не являясь замыканиями предоставляют схожие возможности. В функциональном языке lambda-выражения – это функции; но в Java, lambda-выражения – представляются объектами, и должны быть связаны с конкретным объектным типом, который называется функциональный интерфейс. Далее мы рассмотри, что он из себя представляет.
В статье Марио Фаско (Mario Fusco) “Зачем в Java нужны Lambda-выражения” (“Why we need Lambda Expression in Java”) подробно описано, зачем всем современным языкам нужны возможности замыканий.
Введение в Lambda-выражения
Lambda-выражения – это анонимные функции (может и не 100% верное определение для Java, но зато привносит некоторую ясность). Проще говоря, это метод без объявления, т.е. без модификаторов доступа, возвращающие значение и имя.Короче говоря, они позволяют написать метод и сразу же использовать его. Особенно полезно в случае однократного вызова метода, т.к. сокращает время на объявление и написание метода без необходимости создавать класс.
Lambda-выражения в Java обычно имеют следующий синтаксис (аргументы) -> (тело)
. Например:
(арг1, арг2...) -> { тело }
(тип1 арг1, тип2 арг2...) -> { тело }
Далее идет несколько примеров настоящих Lambda-выражений:
(int a, int b) -> { return a + b; }
() -> System.out.println("Hello World");
(String s) -> { System.out.println(s); }
() -> 42
() -> { return 3.1415 };
Структура Lambda-выражений
Давайте изучим структуру lambda-выражений:Lambda-выражения могут иметь от 0 и более входных параметров.
Тип параметров можно указывать явно либо может быть получен из контекста. Например (int a) можно записать и так (a)
Параметры заключаются в круглые скобки и разделяются запятыми. Например (a, b) или (int a, int b) или (String a, int b, float c)
Если параметров нет, то нужно использовать пустые круглые скобки. Например () -> 42
Когда параметр один, если тип не указывается явно, скобки можно опустить. Пример: a -> return a*a
Тело Lambda-выражения может содержать от 0 и более выражений.
Если тело состоит из одного оператора, его можно не заключать в фигурные скобки, а возвращаемое значение можно указывать без ключевого слова return.
В противном случае фигурные скобки обязательны (блок кода), а в конце надо указывать возвращаемое значение с использованием ключевого слова return (в противном случае типом возвращаемого значения будет void).
Что такое функциональный интерфейс
В Java, маркерные интерфейсы (Marker interface) – это интерфейсы без объявления методов и полей. Другими словами маркерные интерфейсы – это пустые интерфейсы. Точно также, функциональные интерфейсы (Functional Interface) – это интерфейсы только с одним абстрактным методом, объявленным в нем.java.lang.Runnable
– это пример функционального интерфейса. В нем объявлен только один метод void run(). Также есть интерфейс ActionListener – тоже функциональный. Раньше нам приходилось использовать анонимные классы для создания объектов, реализующих функциональный интерфейс. С Lambda-выражениями, все стало проще.
Каждое lambda-выражение может быть неявно привязано к какому-нибудь функциональному интерфейсу. Например, можно создать ссылку на Runnable интерфейс, как показано в следующем примере:
Runnable r = () -> System.out.println("hello world");
Подобное преобразование всегда осуществляется неявно, когда мы не указываем функциональный интерфейс:
new Thread(() -> System.out.println("hello world")).start();
В примере выше, компилятор автоматически создает lambda-выражение как реализацию Runnable интерфейса из конструктора класса Thread: public Thread(Runnable r) { }
.
Приведу несколько примеров lambda-выражений и соответствующих функциональных интерфейсов:
Consumer
Аннотация @FunctionalInterface
, добавленная в Java 8 согласно Java Language Specification, проверяет является ли объявляемый интерфейс функциональным. Кроме того, в Java 8 включен ряд готовых функциональных интерфейсов для использования с Lambda-выражениями. @FunctionalInterface
выдаст ошибку компиляции, если объявляемый интерфейс не будет функциональным.
Далее приводится пример определения функционального интерфейса:
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
}
Как следует из определения, функциональный интерфейс может иметь только один абстрактный метод. Если попытаться добавить еще один абстрактный метод, то вылезет ошибка компиляции. Пример:
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
public void doSomeMoreWork();
}
Error
:
Unexpected @FunctionalInterface annotation
@FunctionalInterface ^ WorkerInterface is not a functional interface multiple
non-overriding abstract methods found in interface WorkerInterface 1 error
После определения функционального интерфейса, мы можем его использовать и получать все преимущества Lambda-выражений. Пример:
// определении функционального интерфейса
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
}
public class WorkerInterfaceTest {
public static void execute(WorkerInterface worker) {
worker.doSomeWork();
}
public static void main(String args) {
// вызов метода doSomeWork через анонимный класс
// (классический способ)
execute(new WorkerInterface() {
@Override
public void doSomeWork() {
System.out.println("Worker вызван через анонимный класс");
}
});
// вызов метода doSomeWork через Lambda-выражения
// (нововведение Java 8)
execute(() -> System.out.println("Worker вызван через Lambda"));
}
}
Вывод
:
Worker вызван через анонимный класс
Worker вызван через Lambda
Здесь мы определили свой собственный функциональный интерфейс и воспользовались lambda-выражением. Метод execute() способен принимать lambda-выражения в качестве аргумента.
Примеры Lambda-выражений
Лучший способ вникнуть в Lambda-выражения – это рассмотреть несколько примеров:Поток Thread можно проинициализировать двумя способами:
// Старый способ: new Thread(new Runnable() { @Override public void run() { System.out.println("Hello from thread"); } }).start();
// Новый способ: new Thread(() -> System.out.println("Hello from thread")).start();
Управление событиями в Java 8 также можно осуществлять через Lambda-выражения. Далее представлены два способа добавления обработчика события ActionListener в компонент пользовательского интерфейса:
// Старый способ: button.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println("Кнопка нажата. Старый способ!"); } });
// Новый способ: button.addActionListener((e) -> { System.out.println("Кнопка нажата. Lambda!"); });
Простой пример вывода всех элементов заданного массива. Заметьте, что есть более одного способа использования lambda-выражения. Ниже мы создаем lambda-выражение обычным способом, используя синтаксис стрелки, а также мы используем оператор двойного двоеточия (::), который в Java 8 конвертирует обычный метод в lambda-выражение:
// Старый способ: List
// Новый способ: List
// Новый способ с использованием оператора двойного двоеточия:: list.forEach(System.out::println);
В следующем примере мы используем функциональный интерфейс Predicate для создания теста и печати элементов, прошедших этот тест. Таким способом вы можете помещать логику в lambda-выражения и делать что-либо на ее основе.
import java.util.Arrays; import java.util.List; import java.util.function.Predicate; public class Main { public static void main(String a) { List
Вывод :
Выводит все числа: 1 2 3 4 5 6 7 Не выводит ни одного числа: Вывод четных чисел: 2 4 6 Вывод нечетных чисел: 1 3 5 7 Вывод чисел больше 5: 6 7
Поколдовав над Lambda-выражениями можно вывести квадрат каждого элемента списка. Заметьте, что мы используем метод stream(), чтобы преобразовать обычный список в поток. Java 8 предоставляет шикарный класс Stream (java.util.stream.Stream ). Он содержит тонны полезных методов, с которыми можно использовать lambda-выражения. Мы передаем lambda-выражение x -> x*x в метод map(), который применяет его ко всем элементам в потоке. После чего мы используем forEach для печати всех элементов списка.
// Старый способ: List
// Новый способ: List
Дан список, нужно вывести сумму квадратов всех элемента списка. Lambda-выражения позволяет достигнуть этого написанием всего одной строки кода. В этом примере применен метод свертки (редукции) reduce(). Мы используем метод map() для возведения в квадрат каждого элемента, а потом применяем метод reduce() для свертки всех элементов в одно число.
// Старый способ: List
// Новый способ: List
Отличие Lambda-выражений от анонимных класов
Главное отличие состоит в использовании ключевого слова this . Для анонимных классов ключевое слово ‘this ’ обозначает объект анонимного класса, в то время как в lambda-выражении ‘this ’ обозначает объект класса, в котором lambda-выражение используется.Другое их отличие заключается в способе компиляции. Java компилирует lambda-выражения с преобразованием их в private-методы класса. При этом используется инструкция invokedynamic , появившаяся в Java 7 для динамической привязки метода. Тал Вайс (Tal Weiss) описал в своем блоге как Java компилирует lambda-выражения в байт-код
