Kotlin Bootcamp для программистов 3: Функции

Эта лабораторная работа является частью курса Kotlin Bootcamp for Programmers . Вы получите максимальную отдачу от этого курса, если будете последовательно работать с лабораториями кода. В зависимости от ваших знаний, вы можете просмотреть некоторые разделы. Этот курс ориентирован на программистов, которые знают объектно-ориентированный язык и хотят изучить Kotlin .

Введение

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

Вместо того, чтобы создавать один пример приложения, уроки этого курса предназначены для расширения ваших знаний, но они частично независимы друг от друга, поэтому вы можете просматривать разделы, с которыми вы знакомы. Чтобы связать их вместе, во многих примерах используется тема аквариума. А если вы хотите увидеть полную историю аквариума, ознакомьтесь с курсом Kotlin Bootcamp for Programmers Udacity.

Что вы уже должны знать

• Основы современного объектно-ориентированного языка программирования со статической типизацией
• Как программировать с классами, методами и обработкой исключений хотя бы на одном языке
• Как работать с Kotlin REPL (цикл чтения-оценки-печати) в IntelliJ IDEA
• Основы Kotlin, включая типы, операторы и циклы

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

Что вы узнаете

• Как создать программу с функцией main() и аргументами в IntelliJ IDEA
• Как использовать значения по умолчанию и компактные функции
• Как применять фильтры для списков
• Как создавать базовые лямбды и функции более высокого порядка

Что ты будешь делать

• Работайте с REPL, чтобы попробовать код.
• Работайте с IntelliJ IDEA для создания базовых программ Kotlin.

В этом задании вы создадите программу на Kotlin и узнаете о функции main() , а также о том, как передавать аргументы в программу из командной строки.

Возможно, вы помните printHello() , которую вы ввели в REPL в предыдущей кодовой лаборатории:

fun printHello() {
    println ("Hello World")
}

printHello()

⇒ Hello World

Вы определяете функции, используя ключевое слово fun , за которым следует имя функции. Как и в других языках программирования, круглые скобки () предназначены для аргументов функций, если они есть. Фигурные скобки {} обрамляют код функции. У этой функции нет возвращаемого типа, потому что она ничего не возвращает.

Шаг 1: Создайте файл Kotlin

1. Откройте IntelliJ IDEA.
2. На панели « Проект» слева в IntelliJ IDEA отображается список файлов и папок вашего проекта. Найдите и щелкните правой кнопкой мыши папку src в разделе Hello Kotlin. (У вас уже должен быть проект Hello Kotlin из предыдущей кодлабы.)
3. Выберите « Создать» > «Файл/класс Kotlin» .
4. Сохраните Kind as File и назовите файл Hello .
5. Нажмите ОК .

Теперь в папке src есть файл с именем Hello.kt .

Шаг 2. Добавьте код и запустите программу

1. Как и в других языках, функция main() в Kotlin указывает точку входа для выполнения. Любые аргументы командной строки передаются в виде массива строк.
   
   Введите или вставьте следующий код в файл Hello.kt :

fun main(args: Array<String>) {
    println("Hello, world!")
}

Совет: Начиная с Kotlin 1.3, если ваша функция main() не использует никаких параметров, вам не нужно определять args .

Как и ваша предыдущая printHello() , эта функция не имеет оператора return . Каждая функция в Kotlin что-то возвращает, даже если ничего не указано явно. Таким образом, функция, подобная этой функции main() , возвращает тип kotlin.Unit , что является способом Kotlin сказать «нет значения».

Примечание. Когда функция возвращает kotlin.Unit , вам не нужно указывать это явно. Это отличается от некоторых других языков, где вы должны явно указать, что ничего не возвращаете.

3. Чтобы запустить программу, щелкните зеленый треугольник слева от функции main() . Выберите «Выполнить HelloKt» в меню.
4. IntelliJ IDEA компилирует программу и запускает ее. Результаты отображаются на панели журнала внизу, как показано ниже.

Программистам Java: если вы используете ранее установленную версию IntelliJ IDEA вместо установки новой копии, на этом этапе у вас могут возникнуть проблемы с доступом к компилятору Kotlin. Убедитесь, что ваш проект ссылается на правильную версию JDK. См. это обсуждение переполнения стека и документацию SDK проекта изменения для IntelliJ IDEA.

Шаг 3: Передайте аргументы в main()

Поскольку вы запускаете свою программу из IntelliJ IDEA, а не из командной строки, вам нужно указать любые аргументы для программы немного по-другому.

1. Выберите «Выполнить» > «Редактировать конфигурации» . Откроется окно конфигураций запуска/отладки .
2. Типа Kotlin! в поле Аргументы программы .
3. Нажмите ОК .

Шаг 4. Измените код, чтобы использовать строковый шаблон

Строковый шаблон вставляет переменную или выражение в строку, а $ указывает, что часть строки будет переменной или выражением. Фигурные скобки {} обрамляют выражение, если оно есть.

1. В Hello.kt измените приветственное сообщение, чтобы использовать первый аргумент, переданный в программу, args[0] вместо "world" .

fun main(args: Array<String>) {
    println("Hello, ${args[0]}")
}

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

⇒ Hello, Kotlin!

В этом задании вы узнаете, почему почти все в Kotlin имеет значение и почему это полезно.

В некоторых других языках есть операторы , представляющие собой строки кода, не имеющие значения. В Kotlin почти все является выражением и имеет значение, даже если это значение kotlin.Unit .

1. В Hello.kt напишите код в main() , чтобы присвоить println() переменной с именем isUnit и распечатать ее. ( println() не возвращает значение, поэтому он возвращает kotlin.Unit .)

// Will assign kotlin.Unit
val isUnit = println("This is an expression")
println(isUnit)

2. Запустите вашу программу. Первый println() печатает строку "This is an expression" . Второй println() печатает значение первого оператора println() , то есть kotlin.Unit .

⇒ This is an expression
kotlin.Unit

3. val значение с именем temperature и инициализируйте его значением 10.
4. Объявите еще один val с именем isHot и назначьте возвращаемое значение оператора if / else для isHot , как показано в следующем коде. Поскольку это выражение, вы можете сразу же использовать значение выражения if .

val temperature = 10
val isHot = if (temperature > 50) true else false
println(isHot)

⇒ false

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

val temperature = 10
val message = "The water temperature is ${ if (temperature > 50) "too warm" else "OK" }."
println(message)

⇒ The water temperature is OK.

Примечание. Циклы являются исключениями из правила «все имеет значение». Для циклов for или while нет разумного значения, поэтому они не имеют значений. Если вы попытаетесь присвоить значение цикла чему-либо, компилятор выдаст ошибку.

В этом задании вы узнаете больше о функциях в Kotlin when а также об очень полезных условных выражениях.

Шаг 1: Создайте несколько функций

На этом шаге вы объедините часть того, что вы узнали, и создадите функции разных типов. Вы можете заменить содержимое Hello.kt этим новым кодом.

1. Напишите функцию с именем feedTheFish() , которая вызывает randomDay() для получения случайного дня недели. Используйте строковый шаблон, чтобы напечатать food , которую рыба будет есть в этот день. На данный момент рыбы едят одну и ту же пищу каждый день.

fun feedTheFish() {
    val day = randomDay()
    val food = "pellets"
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

2. Напишите randomDay() , чтобы выбрать случайный день из массива и вернуть его.

Функция nextInt() принимает целочисленное ограничение, которое ограничивает число от Random() до значений от 0 до 6, чтобы соответствовать массиву week .

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
            "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

3. Функции Random() и nextInt() определены в java.util.* . Вверху файла добавьте нужный импорт:

import java.util.*    // required import

Совет. Перед добавлением импорта Random() выдает неразрешенную ошибку ссылки в IntelliJ IDEA. Чтобы добавить импорт автоматически, нажмите Random() , затем нажмите Alt+Enter ( Option+Enter на Mac). Выберите Импорт > java.util.Random .

4. Запустите вашу программу и проверьте вывод.

⇒ Today is Tuesday and the fish eat pellets

Шаг 2. Используйте выражение «когда»

Расширяя это, измените код, чтобы выбрать разные продукты для разных дней, используя выражение when . Оператор when похож на switch в других языках программирования, но when автоматически прерывается в конце каждой ветви. Это также гарантирует, что ваш код покрывает все ветки, если вы проверяете перечисление.

1. В Hello.kt добавьте функцию fishFood() , которая принимает день в виде String и возвращает корм для рыбы за день в виде String . Используйте when() , чтобы каждый день рыба получала определенный корм. Запустите вашу программу несколько раз, чтобы увидеть разные результаты.

fun fishFood (day : String) : String {
    var food = ""
    when (day) {
        "Monday" -> food = "flakes"
        "Tuesday" -> food = "pellets"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Saturday" -> food = "lettuce"
        "Sunday" -> food = "plankton"
    }
    return food
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)

    println ("Today is $day and the fish eat $food")
}

⇒ Today is Thursday and the fish eat granules

2. Добавьте ветку по умолчанию в выражение when , используя else . Для тестирования, чтобы убедиться, что в вашей программе иногда используется значение по умолчанию, удалите ветви Tuesday и Saturday .
   
   Наличие ветки по умолчанию гарантирует, что food получит значение перед возвратом, поэтому его больше не нужно инициализировать. Поскольку теперь код присваивает строку food только один раз, вы можете объявить food с помощью val вместо var .

fun fishFood (day : String) : String {
    val food : String
    when (day) {
        "Monday" -> food = "flakes"
        "Wednesday" -> food = "redworms"
        "Thursday" -> food = "granules"
        "Friday" -> food = "mosquitoes"
        "Sunday" -> food = "plankton"
        else -> food = "nothing"
    }
    return food
}

3. Поскольку каждое выражение имеет значение, вы можете сделать этот код немного более кратким. Верните значение выражения when напрямую и удалите переменную food . Значением выражения when является значение последнего выражения ветки, удовлетворяющей условию.

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

Окончательная версия вашей программы выглядит примерно так, как показано ниже.

import java.util.*    // required import

fun randomDay() : String {
    val week = arrayOf ("Monday", "Tuesday", "Wednesday", "Thursday",
        "Friday", "Saturday", "Sunday")
    return week[Random().nextInt(week.size)]
}

fun fishFood (day : String) : String {
    return when (day) {
        "Monday" -> "flakes"
        "Wednesday" -> "redworms"
        "Thursday" -> "granules"
        "Friday" -> "mosquitoes"
        "Sunday" -> "plankton"
        else -> "nothing"
    }
}

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
}

fun main(args: Array<String>) {
    feedTheFish()
}

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

Шаг 1. Создайте значение по умолчанию для параметра

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

1. В Hello.kt напишите функцию swim() со String параметром с именем speed , которая выводит скорость рыбы. Параметр speed имеет значение по умолчанию "fast" .

fun swim(speed: String = "fast") {
   println("swimming $speed")
}

2. Из функции main() вызовите функцию swim() тремя способами. Сначала вызовите функцию, используя значение по умолчанию. Затем вызовите функцию и передайте параметр speed без имени, затем вызовите функцию, назвав параметр speed .

swim()   // uses default speed
swim("slow")   // positional argument
swim(speed="turtle-like")   // named parameter

⇒ swimming fast
swimming slow
swimming turtle-like

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

Шаг 2: Добавьте необходимые параметры

Если для параметра не указано значение по умолчанию, всегда должен передаваться соответствующий аргумент.

1. В Hello.kt напишите функцию shouldChangeWater() , которая принимает три параметра: day , temperature и уровень dirty . Функция возвращает true , если воду нужно заменить, что происходит, если сейчас воскресенье, если температура слишком высокая или вода слишком грязная. Требуется указать день недели, но температура по умолчанию равна 22, а уровень загрязнения по умолчанию — 20.
   
   Используйте выражение when без аргумента, которое в Kotlin действует как серия проверок if/else if .

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        temperature > 30 -> true
        dirty > 30 -> true
        day == "Sunday" ->  true
        else -> false
    }
}

2. Вызовите shouldChangeWater() из feedTheFish() и укажите день. Параметр day не имеет значения по умолчанию, поэтому необходимо указать аргумент. Два других параметра shouldChangeWater() имеют значения по умолчанию, поэтому вам не нужно передавать для них аргументы.
   

fun feedTheFish() {
    val day = randomDay()
    val food = fishFood(day)
    println ("Today is $day and the fish eat $food")
    println("Change water: ${shouldChangeWater(day)}")
}

=> Today is Thursday and the fish eat granules
Change water: false

Шаг 3: Сделайте компактные функции

Выражение when , которое вы написали на предыдущем шаге, упаковывает много логики в небольшой объем кода. Если вы хотите немного распаковать его или если условия для проверки более сложные, вы можете использовать некоторые хорошо названные локальные переменные. Но способ Kotlin сделать это с помощью компактных функций.

Компактные функции, или функции с одним выражением , являются распространенным шаблоном в Kotlin. Когда функция возвращает результаты одного выражения, вы можете указать тело функции после символа = , опустить фигурные скобки {} и опустить return .

1. в Hello.kt добавьте компактные функции для проверки условий.

fun isTooHot(temperature: Int) = temperature > 30

fun isDirty(dirty: Int) = dirty > 30

fun isSunday(day: String) = day == "Sunday"

2. Измените shouldChangeWater() для вызова новых функций.

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20): Boolean {
    return when {
        isTooHot(temperature) -> true
        isDirty(dirty) -> true
        isSunday(day) -> true
        else  -> false
    }
}

3. Запустите вашу программу. Вывод от println() с shouldChangeWater() должен быть таким же, как и до того, как вы перешли на использование компактных функций.

Значения по умолчанию

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

fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = getDirtySensorReading()): Boolean {
    ...

Примечание. Функция, используемая в качестве значения по умолчанию, оценивается во время выполнения, поэтому не добавляйте в функцию дорогостоящую операцию, такую ​​как чтение файла или выделение большого объема памяти. Операция выполняется каждый раз при вызове вашей функции, что может замедлить работу вашей программы.

В этом задании вы немного узнаете о фильтрах в Kotlin. Фильтры — это удобный способ получить часть списка на основе некоторого условия.

Шаг 1. Создайте фильтр

1. В Hello.kt определите список украшений для аквариума на верхнем уровне с помощью listOf() . Вы можете заменить содержимое Hello.kt .

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

2. Создайте новую функцию main() со строкой для печати только тех украшений, которые начинаются с буквы «p». Код условия фильтра заключен в фигурные скобки {} it ссылается на каждый элемент по мере прохождения фильтра. Если выражение возвращает true , элемент включен.

fun main() {
    println( decorations.filter {it[0] == 'p'})
}

3. Запустите вашу программу, и вы увидите следующий вывод в окне « Выполнить» :

⇒ [pagoda, plastic plant]

Шаг 2. Сравните энергичные и ленивые фильтры

Если вы знакомы с фильтрами на других языках, вы можете задаться вопросом, являются ли фильтры в Kotlin активными или ленивыми . Список результатов создается сразу или при доступе к списку? В Котлине это происходит так, как вам нужно. По умолчанию filter активен, и каждый раз, когда вы используете фильтр, создается список.

Чтобы сделать фильтр ленивым, вы можете использовать Sequence , который представляет собой коллекцию, которая может просматривать только один элемент за раз, начиная с начала и до конца. Удобно, это именно тот API, который нужен ленивому фильтру.

1. В Hello.kt измените свой код, чтобы присвоить отфильтрованный список переменной с именем eager , а затем распечатайте его.

fun main() {
    val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

    // eager, creates a new list
    val eager = decorations.filter { it [0] == 'p' }
    println("eager: " + eager)

2. Ниже этого кода оцените фильтр, используя Sequence с asSequence() . Назначьте последовательность переменной с именем filtered и распечатайте ее.

   // lazy, will wait until asked to evaluate
    val filtered = decorations.asSequence().filter { it[0] == 'p' }
    println("filtered: " + filtered)

Когда вы возвращаете результаты фильтра в виде Sequence , filtered переменная не будет содержать новый список — она будет содержать Sequence элементов списка и информацию о фильтре, который нужно применить к этим элементам. Всякий раз, когда вы получаете доступ к элементам Sequence , фильтр применяется, и результат возвращается вам.

3. Принудительно оценить последовательность, преобразовав ее в List с помощью toList() . Распечатайте результат.

    // force evaluation of the lazy list
    val newList = filtered.toList()
    println("new list: " + newList)

4. Запустите вашу программу и наблюдайте за выводом.

⇒ eager: [pagoda, plastic plant]
filtered: kotlin.sequences.FilteringSequence@386cc1c4
new list: [pagoda, plastic plant]

Чтобы визуализировать, что происходит с Sequence и ленивой оценкой, используйте функцию map() . Функция map() выполняет простое преобразование каждого элемента последовательности.

5. С тем же списком decorations , что и выше, сделайте преобразование с помощью map() , которое ничего не делает и просто возвращает переданный элемент. Добавьте println() для отображения каждый раз при доступе к элементу и назначьте последовательность переменной с именем lazyMap .

    val lazyMap = decorations.asSequence().map {
        println("access: $it")
        it
    }

6. Распечатайте lazyMap , распечатайте первый элемент lazyMap используя first() , и распечатайте lazyMap , преобразованный в List .

    println("lazy: $lazyMap")
    println("-----")
    println("first: ${lazyMap.first()}")
    println("-----")
    println("all: ${lazyMap.toList()}")

7. Запустите вашу программу и наблюдайте за выводом. При печати lazyMap просто печатается ссылка на Sequence — внутренняя println() не вызывается. Печать первого элемента обращается только к первому элементу. Преобразование Sequence в List обеспечивает доступ ко всем элементам.

⇒ lazy: kotlin.sequences.TransformingSequence@5ba23b66
-----
access: rock
first: rock
-----
access: rock
access: pagoda
access: plastic plant
access: alligator
access: flowerpot
all: [rock, pagoda, plastic plant, alligator, flowerpot]

8. Перед применением map создайте новую Sequence , используя исходный фильтр. Распечатайте этот результат.

    val lazyMap2 = decorations.asSequence().filter {it[0] == 'p'}.map {
        println("access: $it")
        it
    }
    println("-----")
    println("filtered: ${ lazyMap2.toList() }")

9. Запустите вашу программу и посмотрите на дополнительный вывод. Как и при получении первого элемента, внутренний метод println() вызывается только для тех элементов, к которым осуществляется доступ.

⇒
-----
access: pagoda
access: plastic plant
filtered: [pagoda, plastic plant]

В этом задании вы познакомитесь с лямбда-выражениями и функциями высшего порядка в Kotlin.

лямбды

Помимо традиционных именованных функций, Kotlin поддерживает лямбда-выражения. Лямбда — это выражение, которое создает функцию. Но вместо объявления именованной функции вы объявляете функцию без имени. Часть того, что делает это полезным, заключается в том, что лямбда-выражение теперь может быть передано как данные. В других языках лямбда-выражения называются анонимными функциями , функциональными литералами или подобными именами.

Функции высшего порядка

Вы можете создать функцию более высокого порядка, передав лямбда-выражение другой функции. В предыдущей задаче вы создали функцию более высокого порядка с именем filter . Вы передали следующее лямбда-выражение для filter в качестве условия для проверки:
{it[0] == 'p'}

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

Шаг 1. Узнайте о лямбда-выражениях

1. Как и именованные функции, лямбда-выражения могут иметь параметры. Для лямбда-выражений параметры (и их типы, если необходимо) идут слева от того, что называется функциональной стрелкой -> . Код для выполнения идет справа от стрелки функции. Как только лямбда присваивается переменной, вы можете вызывать ее точно так же, как функцию.
   
   Используя REPL ( Tools > Kotlin > Kotlin REPL ), попробуйте этот код:

var dirtyLevel = 20
val waterFilter = { dirty : Int -> dirty / 2}
println(waterFilter(dirtyLevel))

⇒ 10

В этом примере лямбда принимает Int с именем dirty и возвращает dirty / 2 . (Потому что фильтрация удаляет грязь.)

2. Синтаксис Kotlin для типов функций тесно связан с синтаксисом лямбда-выражений. Используйте этот синтаксис, чтобы четко объявить переменную, содержащую функцию:

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }

Вот что говорит код:

• Создайте переменную с именем waterFilter .
• waterFilter может быть любой функцией, которая принимает Int и возвращает Int .
• Назначьте лямбда для waterFilter .
• Лямбда возвращает значение dirty аргумента, деленное на 2.

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

Шаг 2: Создайте функцию высшего порядка

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

1. Напишите функцию высшего порядка. Вот простой пример, функция, которая принимает два аргумента. Первый аргумент является целым числом. Второй аргумент — это функция, которая принимает целое число и возвращает целое число. Попробуйте в REPL.

fun updateDirty(dirty: Int, operation: (Int) -> Int): Int {
   return operation(dirty)
}

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

2. Чтобы вызвать эту функцию, передайте ей целое число и функцию.

val waterFilter: (Int) -> Int = { dirty -> dirty / 2 }
println(updateDirty(30, waterFilter))

⇒ 15

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

3. Попробуйте передать обычную именованную функцию в updateDirty() .

fun increaseDirty( start: Int ) = start + 1

println(updateDirty(15, ::increaseDirty))

⇒ 16

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

var dirtyLevel = 19;
dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}
println(dirtyLevel)

⇒ 42

• Чтобы создать исходный файл Kotlin в IntelliJ IDEA, начните с проекта Kotlin.
• Чтобы скомпилировать и запустить программу в IntelliJ IDEA, щелкните зеленый треугольник рядом с функцией main() . Вывод появляется в окне журнала ниже.
• В IntelliJ IDEA укажите аргументы командной строки для передачи функции main() в Run > Edit Configurations .
• Почти все в Котлине имеет ценность. Вы можете использовать этот факт, чтобы сделать свой код более кратким, используя значение if или when в качестве выражения или возвращаемого значения.
• Аргументы по умолчанию устраняют необходимость в нескольких версиях функции или метода. Например:
  fun swim(speed: String = "fast") { ... }
• Компактные функции или функции с одним выражением могут сделать ваш код более читабельным. Например:
  fun isTooHot(temperature: Int) = temperature > 30
• Вы узнали некоторые основы фильтров, использующих лямбда-выражения. Например:
  val beginsWithP = decorations.filter { it [0] == 'p' }
• Лямбда-выражение — это выражение, которое создает безымянную функцию. Лямбда-выражения определяются между фигурными скобками {} .
• В функции высшего порядка вы передаете функцию, такую ​​как лямбда-выражение, другой функции в качестве данных. Например:
  dirtyLevel = updateDirty(dirtyLevel) { dirtyLevel -> dirtyLevel + 23}

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

Примечание. Возможно, вы заметили, что в Kotlin, как и в некоторых других языках, существует более одного правильного способа выполнения действий. Создание более компактного кода иногда улучшает читабельность и даже производительность, а иногда нет. По мере того, как вы узнаете больше о Kotlin, вы можете найти более простые и лаконичные способы делать вещи.

Котлин документация

Если вам нужна дополнительная информация по какой-либо теме этого курса или если вы застряли, https://kotlinlang.org — лучшая отправная точка.

• Соглашения о кодировании Kotlin
• Котлинские идиомы

• Строковые шаблоны
• when выражение
• Функции с одним выражением
• Функции высшего порядка и лямбда-выражения
• Фильтры
• Последовательности
• Синтаксис вызова последнего параметра

Учебники по Котлину

На веб-сайте https://try.kotlinlang.org есть подробные руководства под названием Kotlin Koans, веб-интерпретатор и полный набор справочной документации с примерами.

Удасити курс

Чтобы просмотреть курс Udacity по этой теме, см. Kotlin Bootcamp for Programmers .

IntelliJ ИДЕЯ

Документацию по IntelliJ IDEA можно найти на веб-сайте JetBrains.

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

• При необходимости задайте домашнее задание.
• Объясните учащимся, как сдавать домашние задания.
• Оценивайте домашние задания.

Преподаватели могут использовать эти предложения так мало или так часто, как они хотят, и должны свободно давать любые другие домашние задания, которые они считают подходящими.

Если вы работаете с этой кодовой лабораторией самостоятельно, не стесняйтесь использовать эти домашние задания, чтобы проверить свои знания.

Ответьте на эти вопросы

Вопрос 1

Функция contains(element: String) возвращает значение true , если строковый element содержится в строке, для которой он вызывается. Каким будет вывод следующего кода?

val decorations = listOf ("rock", "pagoda", "plastic plant", "alligator", "flowerpot")

println(decorations.filter {it.contains('p')})

▢ [pagoda, plastic, plant]

▢ [pagoda, plastic plant]

▢ [pagoda, plastic plant, flowerpot]

▢ [rock, alligator]

вопрос 2

Какой из параметров является обязательным в следующем определении функции?
fun shouldChangeWater (day: String, temperature: Int = 22, dirty: Int = 20, numDecorations: Int = 0): Boolean {...}

numDecorations

▢ dirty

▢ day

▢ temperature

Вопрос 3

Вы можете передать обычную именованную функцию (а не результат ее вызова) другой функции. Как бы вы передали increaseDirty( start: Int ) = start + 1 в updateDirty(dirty: Int, operation: (Int) -> Int) ?

▢ updateDirty(15, &increaseDirty())

▢ updateDirty(15, increaseDirty())

▢ updateDirty(15, ("increaseDirty()"))

▢ updateDirty(15, ::increaseDirty)

Перейти к следующему уроку: 4. Классы и объекты

Обзор курса, включая ссылки на другие лаборатории кода, см. в разделе «Kotlin Bootcamp for Programmers: Добро пожаловать на курс».