🎯 Kotlin

Lambda-Funktionen und funktionaler Stil in Kotlin: Eine ausführliche Anleitung

Lektion 23 / 35 • Vollständige Lektüre-Theorie

Что это такое и зачем? (аналогия из реальной жизни)

Представьте, что вы — шеф-повар в ресторане. У вас есть поварская книга с рецептами (это обычные функции). Но иногда к вам приходит гость и говорит: «Я хочу, чтобы вы пожарили стейк, но прямо сейчас придумали для него особый соус, которого нет в книге». Вы не будете ради одного соуса писать новую главу в книге рецептов — вы просто возьмете листок бумаги, набросаете рецепт и тут же его используете.

Лямбда-функция — это и есть такой «рецепт на листочке». Вы не даёте ей имени, не храните её вечно в памяти компьютера. Вы просто говорите: «Вот действие, выполни его прямо здесь и сейчас». В программировании это называется анонимной функцией (функцией без имени).

Зачем это нужно? Представьте, что вы сортируете список книг. Обычно вы пишете:

fun сравнитьПоЦене(книга1: Книга, книга2: Книга): Int { ... }

А потом передаёте эту функцию в сортировщик. Но если вам нужно отсортировать книги всего один раз и по странному правилу (например, сначала по цвету обложки, потом по количеству страниц), то писать целую функцию ради одного использования — это как заводить новый почтовый ящик ради одного письма. Лямбда позволяет написать правило прямо на месте:

книги.sortBy { it.цветОбложки }

Лямбда-функции — это способ писать код короче, понятнее и ближе к тому, как мы мыслим: «сделай это с тем-то».

Теория: как это работает изнутри

Когда вы пишете лямбду, компилятор Kotlin делает примерно следующее:

Создаёт объект-функцию — в памяти появляется специальный объект, который умеет выполнять ваш код.
Захватывает переменные — если внутри лямбды вы используете переменные из внешнего кода (например, счётчик или флаг), компилятор «запоминает» их текущие значения. Это называется замыкание (closure).
Передаёт ссылку — вместо того чтобы копировать весь код, программа передаёт ссылку на этот объект-функцию.

В Kotlin всё является объектом, и функции — не исключение. У каждой лямбды есть тип. Например:

val квадрат: (Int) -> Int = { x -> x * x }

Тип (Int) -> Int читается как «функция, которая принимает Int и возвращает Int». Это как объявление: «у меня есть коробка, в которую можно положить только такие функции».

Важное отличие от обычных функций: лямбда всегда возвращает последнее выражение. Если вы напишете:

val пример = { println("Привет"); 42 }

То эта лямбда напечатает «Привет» и вернёт число 42. Вам не нужно писать return — он там запрещён (если только вы не используете специальную форму).

Лямбда — это не магия, а просто удобная упаковка для кода, который можно передавать как данные.

Синтаксис в Kotlin: все формы и варианты

Kotlin предлагает несколько способов записать лямбду. Давайте разберём их от самого полного до самого краткого.

1. Полная форма

val сумма: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

Здесь всё явно: тип переменной, типы параметров, тело после стрелки.

2. С выведением типов

val сумма = { x: Int, y: Int -> x + y }

Kotlin сам догадывается, что результат — Int, потому что складываются два Int.

3. С выведением типов параметров

val сумма: (Int, Int) -> Int = { x, y -> x + y }

Типы параметров известны из объявления переменной, поэтому их можно опустить.

4. С одним параметром — неявное имя it

val удвоить: (Int) -> Int = { it * 2 }

Если у лямбды ровно один параметр, можно не давать ему имя — Kotlin сам назовёт его it. Это очень удобно для коротких преобразований.

5. Лямбда как последний аргумент

В Kotlin есть специальное правило: если лямбда — последний (или единственный) аргумент функции, её можно вынести за скобки:

// Обычный вызов
list.filter({ x -> x > 0 })

// С вынесением за скобки
list.filter { x -> x > 0 }

// С it
list.filter { it > 0 }

Это делает код похожим на встроенные конструкции языка.

6. Ссылка на функцию

Если у вас уже есть обычная функция, вы можете превратить её в лямбду с помощью :::

fun isPositive(x: Int) = x > 0
list.filter(::isPositive)

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

Таблица: все формы записи

Форма	Пример	Когда использовать
Полная	`{ x: Int -> x + 1 }`	Для сложных лямбд с несколькими параметрами
С it	`{ it + 1 }`	Для простых однострочных преобразований
За скобками	`list.map { it * 2 }`	Почти всегда — это идиоматичный Kotlin
Ссылка на метод	`list.map(::имяФункции)`	Когда функция уже существует и переиспользуется

Примеры кода — от простого к сложному

Пример 1: Приветствие (самое простое)

// Лямбда, которая принимает имя и возвращает приветствие
val приветствие = { имя: String -> "Привет, $имя!" }

// Используем
println(приветствие("Анна"))  // Выведет: Привет, Анна!

// Объяснение:
// { имя: String -> ... } — это лямбда с одним параметром "имя" типа String
// "Привет, $имя!" — это тело, которое возвращается автоматически
// val приветствие — мы сохраняем лямбду в переменную

Пример 2: Фильтрация списка

val числа = listOf(1, 2, 3, 4, 5, 6)

// Отфильтруем только чётные числа
val чётные = числа.filter { число -> число % 2 == 0 }

// Ещё короче с it
val чётныеКороче = числа.filter { it % 2 == 0 }

println(чётные)  // [2, 4, 6]

// Объяснение:
// filter — это функция, которая принимает лямбду-предикат
// Предикат должен вернуть true, если элемент нужно оставить
// { it % 2 == 0 } — проверяем, делится ли число на 2 без остатка

Пример 3: Трансформация списка (map)

val слова = listOf("кот", "собака", "слон")

// Преобразуем в длины слов
val длины = слова.map { слово -> слово.length }

// Или с it
val длиныКороче = слова.map { it.length }

println(длины)  // [3, 6, 4]

// Объяснение:
// map — применяет лямбду к каждому элементу и собирает результаты
// слово.length — берём длину строки
// Результат — новый список с длинами

Пример 4: Сортировка по нескольким полям

data class Товар(val название: String, val цена: Double, val рейтинг: Int)

val товары = listOf(
    Товар("Телефон", 50000.0, 4),
    Товар("Книга", 500.0, 5),
    Товар("Телефон", 30000.0, 3)
)

// Сортируем сначала по названию, потом по цене (по убыванию)
val отсортированные = товары.sortedWith(compareBy(
    { it.название },           // сначала по названию
    { -it.цена }               // потом по цене (минус для обратного порядка)
))

println(отсортированные)
// Выведет: Книга (500.0, 5), Телефон (50000.0, 4), Телефон (30000.0, 3)

// Объяснение:
// compareBy принимает несколько лямбд для последовательного сравнения
// { it.название } — сравниваем строки (лексикографически)
// { -it.цена } — отрицание цены, чтобы сортировать от большей к меньшей

Пример 5: Замыкание (захват переменной)

fun создатьСчётчик(): () -> Int {
    var счётчик = 0  // переменная "захватывается" лямбдой
    
    // Возвращаем лямбду, которая увеличивает счётчик
    return {
        счётчик++     // изменяет внешнюю переменную
        счётчик       // возвращает новое значение
    }
}

val мойСчётчик = создатьСчётчик()
println(мойСчётчик())  // 1
println(мойСчётчик())  // 2
println(мойСчётчик())  // 3

// Объяснение:
// Лямбда "запоминает" переменную счётчик, даже после того, 
// как функция создатьСчётчик завершила работу
// Это называется замыкание (closure)
// Каждый вызов мойСчётчик() увеличивает значение на 1

Пример 6: Лямбда с несколькими параметрами

// Функция, которая принимает два числа и операцию
fun выполнитьОперацию(a: Int, b: Int, операция: (Int, Int) -> Int): Int {
    return операция(a, b)
}

// Используем с разными лямбдами
val сумма = выполнитьОперацию(10, 5) { x, y -> x + y }
val разность = выполнитьОперацию(10, 5) { x, y -> x - y }
val произведение = выполнитьОперацию(10, 5) { x, y -> x * y }

println("Сумма: $сумма")        // 15
println("Разность: $разность")  // 5
println("Произведение: $произведение")  // 50

// Объяснение:
// Параметр операция имеет тип (Int, Int) -> Int
// Мы передаём разные лямбды, и функция выполняет их
// Лямбда вынесена за скобки, так как она последний аргумент

Пример 7: Обработка списка с условием

data class Студент(val имя: String, val баллы: Int)

val студенты = listOf(
    Студент("Иван", 85),
    Студент("Мария", 92),
    Студент("Пётр", 70),
    Студент("Анна", 95)
)

// Найдём имена отличников (баллы >= 90) в верхнем регистре
val отличники = студенты
    .filter { it.баллы >= 90 }           // оставляем только с баллами >= 90
    .map { it.имя.uppercase() }          // преобразуем имена в верхний регистр
    .sorted()                            // сортируем по алфавиту

println(отличники)  // [АННА, МАРИЯ]

// Объяснение:
// Цепочка вызовов — это функциональный стиль
// Каждый шаг преобразует данные и передаёт дальше
// filter -> map -> sorted — читается как "отфильтруй, преобразуй, отсортируй"

Пример 8: Использование with и apply

// Лямбды с контекстом объекта
data class Человек(var имя: String = "", var возраст: Int = 0)

val человек = Человек().apply {
    имя = "Ольга"      // this.имя — контекст объекта
    возраст = 25       // this.возраст
}

// with — выполняет код с объектом как контекстом
val описание = with(человек) {
    "Имя: $имя, Возраст: $возраст"
}

println(описание)  // Имя: Ольга, Возраст: 25

// Объяснение:
// apply и with — это функции, которые принимают лямбду с контекстом
// Внутри лямбды this ссылается на объект
// apply возвращает сам объект, with возвращает результат лямбды

Сравнение с Python: чем похоже и чем отличается

Характеристика	Kotlin	Python
Синтаксис	`{ x -> x * 2 }`	`lambda x: x * 2`
Неявное имя параметра	`it` (только для одного параметра)	Нет, нужно всегда указывать
Захват переменных	Да, переменные можно изменять	Да, но только чтение (в Python 3)
Многострочные лямбды	Да, можно писать несколько строк	Нет, только одно выражение
Типизация	Строгая, статическая	Динамическая
Ссылка на функцию	`::имяФункции`	`имя_функции` (без скобок)
Вынесение за скобки	Да, если лямбда последний аргумент	Нет

Пример сравнения:

// Kotlin
val числа = listOf(1, 2, 3, 4, 5)
val чётные = числа.filter { it % 2 == 0 }
val квадраты = числа.map { it * it }

# Python
числа = [1, 2, 3, 4, 5]
чётные = list(filter(lambda x: x % 2 == 0, числа))
квадраты = list(map(lambda x: x * x, числа))

Главное отличие: в Kotlin лямбды — это основной способ работы с коллекциями, и синтаксис специально заточен под это. В Python лямбды — это дополнительная возможность, но чаще используют списковые включения (list comprehensions).

Kotlin пошёл дальше Python в интеграции лямбд в язык: вынесение за скобки, неявное it, контекстные лямбды — всё это делает функциональный стиль естественным.

Типичные ошибки и подводные камни

Ошибка 1: Использование return внутри лямбды

// НЕПРАВИЛЬНО
val числа = listOf(1, 2, 3)
числа.forEach {
    if (it == 2) return  // Ошибка! return здесь недопустим
    println(it)
}

// ПРАВИЛЬНО
числа.forEach {
    if (it != 2) println(it)  // Просто не печатаем двойку
}

// Или используйте return@forEach для выхода из лямбды
числа.forEach {
    if (it == 2) return@forEach  // Выход только из этой итерации
    println(it)
}

Ошибка 2: Путаница с it при вложенных лямбдах

// НЕПРАВИЛЬНО — два it в разных контекстах
val списки = listOf(listOf(1, 2), listOf(3, 4))
val результат = списки.map { 
    it.map { it * 2 }  // Какой it? Внешний или внутренний?
}

// ПРАВИЛЬНО — дайте имена
val результат = списки.map { внешний ->
    внешний.map { внутренний -> внутренний * 2 }
}

// Или используйте разные уровни
val результат = списки.map { список ->
    список.map { элемент -> элемент * 2 }
}

Ошибка 3: Изменение внешних переменных в многопоточном коде

// ОПАСНО — гонка данных
var счётчик = 0
val потоки = List(100) {
    thread {
        repeat(1000) {
            счётчик++  // Неатомарная операция!
        }
    }
}

// ПРАВИЛЬНО — используйте атомарные типы
val счётчик = AtomicInteger(0)
val потоки = List(100) {
    thread {
        repeat(1000) {
            счётчик.incrementAndGet()
        }
    }
}

Ошибка 4: Забыли про производительность

// МЕДЛЕННО — цепочка из многих операций
val результат = большойСписок
    .filter { it > 0 }
    .map { it * 2 }
    .filter { it < 100 }
    .map { it.toString() }

// БЫСТРЕЕ — используйте sequence
val результат = большойСписок.asSequence()
    .filter { it > 0 }
    .map { it * 2 }
    .filter { it < 100 }
    .map { it.toString() }
    .toList()

// Sequence обрабатывает элементы лениво, по одному

Ошибка 5: Слишком сложная лямбда

// ПЛОХО — лямбда на 20 строк
val сложнаяОбработка = список.map { элемент ->
    // ... много кода ...
    // ... трудно читать ...
    // ... трудно тестировать ...
}

// ХОРОШО — вынесите в отдельную функцию
fun обработатьЭлемент(элемент: Тип): Результат {
    // ... понятный код ...
}

val простаяОбработка = список.map(::обработатьЭлемент)

Лучшие практики и советы профессионалов

Используйте it только для очень простых лямбд — если лямбда длиннее одной строки или содержит вложенные вызовы, дайте параметру осмысленное имя.
Предпочитайте цепочки вызовов циклам — list.filter { ... }.map { ... } читается лучше, чем вложенные циклы с условиями.
Используйте ссылки на функции для переиспользования — если одна и та же логика встречается в нескольких местах, вынесите её в функцию и используйте ::.
Не бойтесь создавать свои функции высшего порядка — если вы замечаете, что часто пишете одинаковые паттерны, создайте функцию, которая принимает лямбду.
Для больших данных используйте sequences — asSequence() перед цепочкой операций может значительно ускорить обработку.
Избегайте побочных эффектов в лямбдах — лямбда должна возвращать значение, а не изменять внешнее состояние. Это делает код предсказуемым.
Используйте контекстные лямбды (apply, with, let, run) — они делают код более лаконичным и выразительным.

Хороший функциональный код — это код, который можно читать как предложение: «Возьми список, отфильтруй чётные, умножь на два и отсортируй».

Вопросы для самопроверки

Что такое лямбда-функция?
Ответ: Это анонимная функция (без имени), которую можно создать прямо в месте использования. В Kotlin записывается в фигурных скобках.
Какой тип имеет лямбда, принимающая Int и возвращающая String?
Ответ: (Int) -> String
Что означает ключевое слово it в лямбде?
Ответ: Это неявное имя для единственного параметра лямбды. Kotlin автоматически называет параметр it, если вы не указали имя.
Можно ли использовать return внутри обычной лямбды?
Ответ: Нет, return в обычной лямбде запрещён. Лямбда автоматически возвращает последнее выражение. Для выхода из лямбды используйте return@имяФункции.
Что такое замыкание (closure)?
Ответ: Это способность лямбды «запоминать» и использовать переменные из внешней области видимости, даже после того, как эта область завершила работу.
Как передать существующую функцию как лямбду?
Ответ: Используйте оператор :: перед именем функции, например: list.filter(::isPositive).
В чём разница между filter и map?
Ответ: filter оставляет элементы, удовлетворяющие условию (возвращает те же элементы, но меньше). map преобразует каждый элемент (возвращает столько же элементов, но другого типа).
Что такое sequence и зачем он нужен?
Ответ: Sequence — это ленивая последовательность. Операции над ней выполняются не сразу, а только когда запрашивается результат. Это позволяет избежать создания промежуточных списков и ускоряет обработку больших данных.
Какой синтаксис используется для лямбды с двумя параметрами?
Ответ: { x, y -> x + y }. Параметры перечисляются через запятую перед стрелкой.
Почему лямбды часто выносят за скобки в Kotlin?
Ответ: Если лямбда — последний аргумент функции, её можно вынести за скобки. Это делает код более читаемым и похожим на встроенные конструкции языка.

Итог и что изучить дальше

Лямбда-функции — это не просто синтаксический сахар, а фундаментальная часть современного программирования. Они позволяют писать код, который:

Короче — не нужно объявлять отдельные функции для простых операций
Выразительнее — логика видна прямо на месте использования
Гибче — можно создавать функции на лету, подстраиваясь под конкретную задачу
Безопаснее — меньше кода = меньше ошибок

Освоив лямбды, вы открываете дверь в мир функционального программирования. Вот что стоит изучить дальше:

Функции высшего порядка — функции, которые принимают или возвращают другие функции. Примеры: filter, map, flatMap, fold.
Неизменяемость (immutability) — работа с неизменяемыми данными делает код предсказуемым и безопасным в многопоточных приложениях.
Чистые функции — функции, которые не имеют побочных эффектов и всегда возвращают одинаковый результат для одинаковых аргументов.
Монады и функторы — продвинутые концепции, которые помогают работать с nullable-значениями, ошибками и асинхронностью.
Библиотека Arrow — добавляет в Kotlin мощные функциональные конструкции, такие как Either, Option, Validated.

Помните: лямбды — это инструмент, а не цель. Используйте их там, где они делают код понятнее, и не бойтесь писать обычные функции, когда логика становится сложной.

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

← Vorherige Methoden für Arrays und Sammlungen in Kotlin: Eine Weiter → Generics und parametrische Typen in Kotlin: Eine a