Функции

Именованные аргументы

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

fun printMessageWithPrefix(message: String, prefix: String) {
    println("[$prefix] $message")
}

fun main() {
    // Uses named arguments with swapped parameter order
    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // [Log] Hello
}

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

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

fun printMessageWithPrefix(message: String, prefix: String = "Info") {
    println("[$prefix] $message")
}

fun main() {
    // Function called with both parameters
    printMessageWithPrefix("Hello", "Log") 
    // [Log] Hello
    
    // Function called only with message parameter
    printMessageWithPrefix("Hello")        
    // [Info] Hello
    
    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // [Log] Hello
}

Функции без возвращаемого значения

Если функция не возвращает полезное значение, её тип возвращаемого значения — Unit. Unit — это тип, имеющий только одно значение: Unit. Не нужно явно указывать в теле функции, что возвращается Unit. Это значит, что ключевое слово return и тип возвращаемого значения можно не указывать:

fun printMessage(message: String) {
    println(message)
    // `return Unit` or `return` is optional
}

fun main() {
    printMessage("Hello")
    // Hello
}

Функции с одним выражением

Чтобы сделать код лаконичнее, можно использовать функции с одним выражением. Например, функцию sum() можно сократить:

fun sum(x: Int, y: Int): Int {
    return x + y
}

fun main() {
    println(sum(1, 2))
    // 3
}

Можно убрать фигурные скобки {} и объявить тело функции с помощью оператора присваивания =. При использовании оператора присваивания = Kotlin выводит тип автоматически, поэтому тип возвращаемого значения тоже можно опустить. Тогда функция sum() будет записана в одну строку:

fun sum(x: Int, y: Int) = x + y

fun main() {
    println(sum(1, 2))
    // 3
}

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

Досрочный выход из функции

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

// A list of registered usernames
val registeredUsernames = mutableListOf("john_doe", "jane_smith")

// A list of registered emails
val registeredEmails = mutableListOf("john@example.com", "jane@example.com")

fun registerUser(username: String, email: String): String {
    // Early return if the username is already taken
    if (username in registeredUsernames) {
        return "Username already taken. Please choose a different username."
    }

    // Early return if the email is already registered
    if (email in registeredEmails) {
        return "Email already registered. Please use a different email."
    }

    // Proceed with the registration if the username and email are not taken
    registeredUsernames.add(username)
    registeredEmails.add(email)

    return "User registered successfully: $username"
}

fun main() {
    println(registerUser("john_doe", "newjohn@example.com"))
    // Username already taken. Please choose a different username.
    println(registerUser("new_user", "newuser@example.com"))
    // User registered successfully: new_user
}

Практика: функции

import kotlin.math.PI

// Write your code here

fun main() {
    println(circleArea(2))
}

import kotlin.math.PI

// Write your code here

fun main() {
    println(circleArea(2))
}

fun intervalInSeconds(hours: Int, minutes: Int, seconds: Int) =
    ((hours * 60) + minutes) * 60 + seconds

fun main() {
    println(intervalInSeconds(1, 20, 15))
    println(intervalInSeconds(0, 1, 25))
    println(intervalInSeconds(2, 0, 0))
    println(intervalInSeconds(0, 10, 0))
    println(intervalInSeconds(1, 0, 1))
}

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

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

Например, следующую функцию uppercaseString():

fun uppercaseString(text: String): String {
    return text.uppercase()
}
fun main() {
    println(uppercaseString("hello"))
    // HELLO
}

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

fun main() {
    val upperCaseString = { text: String -> text.uppercase() }
    println(upperCaseString("hello"))
    // HELLO
}

На первый взгляд лямбда-выражения могут показаться сложными, поэтому разберём их подробнее. Лямбда-выражения записываются в фигурных скобках {}.

Внутри лямбда-выражения указываются:

• Параметры, за которыми следует ->.

• Тело функции после ->.

В предыдущем примере:

• text — параметр функции.

• Тип text — String.

• Функция возвращает результат вызова функции .uppercase() для text.

• Всё лямбда-выражение присваивается переменной upperCaseString с помощью оператора присваивания =.

• Лямбда-выражение вызывается с помощью переменной upperCaseString, как функции, и строки "hello" в качестве параметра.

• Функция println() выводит результат.

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

• Передать лямбда-выражение в качестве параметра другой функции

• Вернуть лямбда-выражение из функции

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

fun main() {
    //sampleStart
    val numbers = listOf(1, -2, 3, -4, 5, -6)
    
    val positives = numbers.filter ({ x -> x > 0 })
    
    val isNegative = { x: Int -> x < 0 }
    val negatives = numbers.filter(isNegative)
    
    println(positives)
    // [1, 3, 5]
    println(negatives)
    // [-2, -4, -6]
    //sampleEnd
}

fun main() {
    //sampleStart
    val numbers = listOf(1, -2, 3, -4, 5, -6)
    val doubled = numbers.map { x -> x * 2 }
    
    val isTripled = { x: Int -> x * 3 }
    val tripled = numbers.map(isTripled)
    
    println(doubled)
    // [2, -4, 6, -8, 10, -12]
    println(tripled)
    // [3, -6, 9, -12, 15, -18]
    //sampleEnd
}

val upperCaseString: (String) -> String = { text -> text.uppercase() }

fun main() {
    println(upperCaseString("hello"))
    // HELLO
}

fun toSeconds(time: String): (Int) -> Int = when (time) {
    "hour" -> { value -> value * 60 * 60 }
    "minute" -> { value -> value * 60 }
    "second" -> { value -> value }
    else -> { value -> value }
}

fun main() {
    val timesInMinutes = listOf(2, 10, 15, 1)
    val min2sec = toSeconds("minute")
    val totalTimeInSeconds = timesInMinutes.map(min2sec).sum()
    println("Total time is $totalTimeInSeconds secs")
    // Total time is 1680 secs
}

fun main() {
    //sampleStart
    println({ text: String -> text.uppercase() }("hello"))
    // HELLO
    //sampleEnd
}

fun main() {
    //sampleStart
    // The initial value is zero. 
    // The operation sums the initial value with every item in the list cumulatively.
    println(listOf(1, 2, 3).fold(0, { x, item -> x + item })) // 6

    // Alternatively, in the form of a trailing lambda
    println(listOf(1, 2, 3).fold(0) { x, item -> x + item })  // 6
    //sampleEnd
}

Практика: лямбда-выражения

fun main() {
    val actions = listOf("title", "year", "author")
    val prefix = "https://example.com/book-info"
    val id = 5
    val urls = // Write your code here
    println(urls)
}

fun repeatN(n: Int, action: () -> Unit) {
    // Write your code here
}

fun main() {
    // Write your code here
}