Kotlin | Лямбда-выражения и анонимные функции

В этой статье мы собираемся изучить выражение лямбда-выражения и анонимную функцию в Kotlin. Синтаксически сходные лямбды Kotlin и Java имеют очень разные функции.

Выражение лямбда-выражения и функция Anonymous означают, что эти функции не объявлены, а переданы немедленно как выражение.

Лямбда-выражение —

Как известно, синтаксис Kotlin lambdas похож на Java Lambdas. Функция без имени называется анонимной функцией. Для лямбда-выражения можно сказать, что это анонимная функция.

Пример:

fun main(args: Array<String>) {

    val company = { println("Data science")}

    // вызов функции method1

    company()  

    // вызывая функцию method2

    company.invoke() 

}

Выход:

Data science
Data science

Синтаксис лямбда-выражения —

val lambda_name : Data_type = { argument_List -> code_body }

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

Пример:

val sum = {a: Int , b: Int -> a + b}

В Kotlin лямбда-выражение содержит необязательную часть, кроме code_body. Ниже приведено лямбда-выражение после исключения необязательной части.

val sum:(Int,Int) -> Int = { a, b -> a + b}

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

Kotlin программа использования лямбда-выражения

// с аннотацией типа в лямбда-выражении

val sum1 = { a: Int, b: Int -> a + b }

// без аннотации типа в лямбда-выражении

val sum2:(Int,Int)-> Int = { a , b -> a + b}

fun main(args: Array<String>) {

    val result1 = sum1(2,3)

    val result2 = sum2(3,4)

    println("The sum of two numbers is: $result1")

    println("The sum of two numbers is: $result2")

    // напрямую выводим возвращаемое значение лямбды

    // без сохранения в переменной.

    println(sum1(5,7))

}

Выход:

The sum of two numbers is: 5
The sum of two numbers is: 7
12

Вывод типа в лямбда-

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

val sum = {a: Int , b: Int -> a + b}

Здесь компилятор Kotlin самостоятельно оценивает его как функцию, которая принимает два параметра типа Int и возвращает значение Int.

(Int,Int) -> Int

Если мы хотим вернуть значение String, мы можем сделать это с помощью встроенной функции toString() .

val sum1 = { a: Int, b: Int ->

    val num = a + b

    num.toString()     // конвертировать целое число в строку

}

fun main(args: Array<String>) {

    val result1 = sum1(2,3)

    println("The sum of two numbers is: $result1")

}

Выход:

The sum of two numbers is: 5

В приведенной выше программе компилятор Kotlin самостоятельно оценивает ее как функцию, которая принимает два целочисленных значения и возвращает String.

(Int,Int) -> String 

Объявление типа в лямбдах —

Мы должны явно объявить тип нашего лямбда-выражения. Если лямбда не возвращает значение, тогда мы можем использовать:

Шаблон: (Вход) -> Выход

Примеры лямбда-выражений с типом возврата —

val lambda1 (Int) -> Int = (a -> a * a)
val lambda2 (String,String) -> String = { a , b -> a + b }
val lambda3 (Int)-> Unit = {print(Int)}

Лямбды можно использовать как расширение класса:

val lambda4: String.(Int) -> String = {this + it} 

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

Программа Kotlin, когда лямбды используются как расширение класса —

val lambda4 : String.(Int) -> String = { this + it }

fun main(args: Array<String>) {

    val result = "Data".lambda4(50)

    print(result)

}

Выход:

Data 50

Объяснение:

В приведенном выше примере мы используем лямбда-выражение в качестве расширения класса. Мы передали параметры в соответствии с форматом, указанным выше. это ключевое слово используется для строки и используется ключевое слово для параметра Int передается в лямбда. Затем code_body объединяет оба значения и возвращает результат переменной.

это: неявное имя одного параметра —

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

Программа Kotlin, использующая сокращенную форму лямбда-функции —

val numbers = arrayOf(1,-2,3,-4,5)

fun main(args: Array<String>) {

      println(numbers.filter { it > 0 })

}

Выход:

[1, 3, 5]

Программа Kotlin, использующая произвольную форму лямбда-функции —

val numbers = arrayOf(1,-2,3,-4,5)

fun main(args: Array<String>) {

     println(numbers.filter {item -> item > 0 })

}

Выход:

[1, 3, 5]

Возврат значения из лямбда-выражения —

После выполнения лямбды окончательное значение возвращается лямбда-выражением. Любое из этих значений типа Integer, String или Boolean может быть возвращено лямбда-функцией.

Программа Kotlin для возврата строкового значения лямбда-функцией —

val find =fun(num: Int): String{

if(num % 2==0 && num < 0) {

    return "Number is even and negative"

   }

    else if (num %2 ==0 && num >0){

    return "Number is even and positive"

    }

    else if(num %2 !=0 && num < 0){

    return "Number is odd and negative"

    }

    else {

    return "Number is odd and positive"

    }

}

fun main(args: Array<String>) {

    val result = find(112)

    println(result)

}

Выход:

Number is even and positive

Анонимная функция

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

Пример 1: тело функции как выражение

fun(a: Int, b: Int) : Int = a * b

Пример 2: Функциональное тело как блок

fun(a: Int, b: Int): Int {
    val mul = a * b
    return mul
}

Тип возврата и параметры

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

Разница между лямбда-выражениями и анонимными функциями

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

Программа Kotlin для вызова анонимной функции

// анонимная функция с телом в качестве выражения

val anonymous1 = fun(x: Int, y: Int): Int = x + y

// анонимная функция с телом в виде блока

val anonymous2 = fun(a: Int, b: Int): Int {

            val mul = a * b

            return mul

            }

fun main(args: Array<String>) {

    // вызывая функции

    val sum = anonymous1(3,5)

    val mul = anonymous2(3,5)

    println("The sum of two numbers is: $sum")

    println("The multiply of two numbers is: $mul")

}

Выход:

The sum of two numbers is: 8
The multiply of two numbers is: 15