Объявление функций

Декомпозиция программы

Kotlin поддерживает функции, что очень полезно. Функция — это последовательность инструкций, собранных вместе для работы. В некотором смысле это своего рода подпрограмма. У функции есть имя, поэтому вы можете вызвать её, когда вам это нужно. Стандартная библиотека Kotlin имеет множество функций, например println. Если их недостаточно, вы можете объявить новую функцию, а затем вызвать её так же, как стандартную функцию.

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

Базовый синтаксис

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

fun functionName(p1: Type1, p2: Type2): ReturnType {
    // тело функции
    return result
}

Функция состоит из следующих компонентов:

• имя, которое соответствует тем же правилам и рекомендациям, что и имя переменной

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

• тип возвращаемого значения (необязательно)

• тело функции, содержащее инструкции и выражения

• ключевое слово return, за которым следует результат (также необязательно).

Типы параметров и результат могут быть любого типа, включая Int, Double, Boolean, String и так далее.

Объявление простой функции

Давайте объявим функцию, которая вычисляет сумму целых чисел, а затем вызывает ее.

fun sum(a: Int, b: Int): Int {
    val result = a + b
    return result
}

fun main() {
    val result1 = sum(2, 5)
    println(result1) // 7

    val result2 = sum(result1, 4)
    println(result2) // 11
}

Когда мы вызываем нашу функцию в первый раз, мы передаем ей два значения 2 и 5. Мы присваиваем им параметры a и b соответственно. Функция возвращает значение результата. Тип result совпадает с типом возвращаемого значения, объявленного в функции (Int). Когда мы вызываем функцию во второй раз, мы передаем значение result1, 7 и 4 в качестве её аргументов. Функция возвращает значение 11.

!> Доступ к аргументам функции возможен только в самой функции.

Параметры функции

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

Вот несколько примеров:

/**
 * Функция возвращает её аргумент
 */
fun identity(a: Int): Int {
    return a
}

/**
 * Функция возвращает сумму двух Int
 */
fun sum(a: Int, b: Int): Int {
    return a + b
}

/**
 * Функция возвращает просто 3
 */
fun get3(): Int {
    return 3
}

fun main() {
    println(identity(1000)) // 1000
    println(sum(200, 300)) // 500    
    println(get3()) // 3
}

Как вы можете видеть, мы можем вызвать функцию из основной функции, но также возможно вызвать функцию из другой обычной функции.

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

fun sum(a: Int, b: Int, ): Int { // вы можете легко добавить новые аргументы
    // 
}

fun max(
    a: Int,
    b: Int,
): Int { // вы можете менять местами аргументы, не беспокоясь о запятых
    // 
}

Возвращаемый тип

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

• опустите часть возвращаемого типа:

/**
 * Функция выводит значения a и b
 */
fun printAB(a: Int, b: Int) {
    println(a)
    println(b)
}

• укажите специальный тип Unit в качестве возвращаемого типа:

/**
 * Функция выводит сумму a и b
 */
fun printSum(a: Int, b: Int): Unit {
    println(a + b)
}

Тело функции

Вы можете писать любые инструкции в теле функции, например, внутри main функции. В дополнение к параметрам вы можете объявлять новые переменные, которые видны только в функции.

Например, эта функция извлекает последнюю цифру числа, а затем возвращает ее.

fun extractLastDigit(number: Int): Int {
    val lastDigit = number % 10
    return lastDigit
}

Вы можете упростить этот код, исключив дополнительную переменную:

fun extractLastDigit(number: Int): Int {
    return number % 10
}

Вы можете выполнять любые операции в теле функции. Например, эта функция использует реляционную операцию. Он проверяет, является ли число положительным или нет:

fun isPositive(number: Int): Boolean {
    return number > 0
}

Функция isPositive принимает целое число и возвращает Boolean значение, поскольку результат выражения number > 0 равен либо true, либо false.

Взгляните еще на один пример. Строка после оператора return не будет выполнена (так называемый недостижимый код). Эти строки загромождают вашу программу:

/**
 * Возвращает "Hello"
 */
fun getGreeting(): String {
    return "hello"   // Завершение функции
    println("hello") // Не выполнится
}

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

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

fun sum(a: Int, b: Int): Int = a + b

fun sayHello(): Unit = println("Hello")

fun isPositive(number: Int): Boolean = number > 0

Указание возвращаемого типа необязательно, так как оно может быть определено автоматически:

fun sum(a: Int, b: Int) = a + b // Int

fun sayHello() = println("Hello") // Unit

fun isPositive(number: Int) = number > 0 // Boolean

Идиомы

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

fun theAnswer() = 42   // коротко и ясно

fun theAnswer(): Int { // эквивалентно обычной функции
    return 42
}

Заключение

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