Funkcje

Kotlin

  |   14 min czytania

Deklaracja

Funkcje w Kotlin deklaruje się za pomocą słowa kluczowego fun oraz wymaganego zwracanego typu i opcjonalnych argumentów. Jeśli funkcja przyjmuje postać wyrażania wówczas zwracany typ może być definiowany w sposób niejawny. W przypadku, gdy funkcja nie zwraca instancji żadnego konkretnego typu tylko wykonuje pewne działania wówczas tak na prawdę zwracanym typem jest Unit (odpowiednik void w Java). Funkcje zwracające typ Unit nie muszą definiować zwracanego typu w sposób jawny.

//declaration in standard way
fun tripple(): Int {
    return 3*10
}

//return Unit type
fun printText() {
    print("Hello world")
}

//declaration as expression
fun tripple() = 3*10 //note that return type declaration is not needed here

//usage
var result = tripple()
SomeClass().tripple() //if function is a member class

Przy użyciu słowa kluczowego infix możliwe jest deklarowanie funkcji której wywołanie następuje w notacji infiksowej (z pominięciem kropki oraz nawiasów). Funkcje zdeklarowana jako infiksowa musi być jednak funkcją właściwości klasy lub funkcją rozszerzającą oraz posiadać jeden parametr bez wartości domyślnej.

//some A class body
infix fun function(arg: Int) {} //declared as member function

//usage
var object = A()
A function 5 //infix function
A.function(5) //the same result as infix function above

Zakres deklaracji

Poza standardowym sposobem deklaracji funkcji jako właściwości klasy (member function) deklaracja może przyjąć postać funkcji lokalnej (funkcja w funkcji) lub odbyć się na najwyższym poziomie struktury pliku (top-level) - tzn. nie musi być w ciele klasy.

//top-level declaration
//some class declaration { ... }
fun function() {
    //do something
}

//local function declaration
fun calculate(): Int {
    fun local1(): Int {
        return 3*10
    }
    fun local2(): Int {
        return 2*10
    }
    return local1() * local2()
}

Parametry

Argumenty funkcji oddziela się przecinkiem i zapisuje się w notacji Pascala - tzn. nazwa: typ. Ponadto parametry mogą przyjmować wartość domyślną i w przypadku braku podania ich jako argumenty funkcji przyjmą zadeklarowaną wartość. Dzięki temu redukuje się liczbę przeciążonych funkcji.

fun functionWithArgs(arg1: Int, arg2: String) {
    //some body
    print(arg2 + " " + arg1)
}

fun functionWithDefaultArgs(arg1: Int = 5, arg2: String) {
    //some body
    print(arg2 + " " + arg1)
}

//execution
functionWithArgs(10, "text") //text 10
functionWithDefaultArgs(10, "text") //text 10
functionWithDefaultArgs("text") //text 5

Jeśli funkcja z argumentami o wartościach domyślnych jest nadpisywana w klasie pochodnej wówczas wartość domyślna jest zawsze brana z funkcji klasy bazowej i niemożliwe jest jej nadpisanie.

//some A class
fun function(arg1: Int = 5, arg2: String) {}

//other B class extending A class
override fun function(arg1: Int = 10, arg2: String) {} //compiler error
override fun function(arg1: Int, arg2: String) {} //correct overriding

Funkcje mogą przyjmować typy generyczne poprzez zastosowanie wyrażenia <Type> przed nazwą funkcji.

//declaration
fun <T> functionGenericType(item: T): List<T> { 
    var list: List<T> = listOf(item, item, item)
    return list
}

//execution
var someList = functionGenericType<Int>(10)
someList = functionGenericType(10) //type can be missing if known from context

Parametry nazwane

Argument nazwany (named argument) pozwala na wywołanie funkcji wraz z nazwami argumentów co umożliwia wywołanie funkcji z parametrami domyślnymi (gdy te w deklaracji poprzedzają argumenty bez wartości domyślnej) oraz zwiększa czytelność wywołania funkcji o wielu argumentach.

fun function(arg1: Int = 10, arg2: String) {}
function("text") //compile error
function(arg2 = "text") //correct executing using named arg

fun functionWithManyArgs(id: Int, number: Int, name: String, citizen: Boolean, adult: Boolean)
functionWithManyArgs(100, 1, "Jack", true, false) //proper but not easy to understand
functionWithManyArgs(id=100, number=1, name="Jack", citizen=true, adult=false) //more cleaner way

Jednakże jeśli funkcja jest wywoływana z użyciem parametrów nazwanych oraz pozycyjnych wówczas wszystkie argumenty pozycyjne muszą być podane przed pierwszym wystąpieniem argumentu nazwanego.

fun function(arg1: Int, arg2: String) {} function(10, arg2=”text”) //correct function(arg2=”text”, 10) //compile error

Jeśli funkcja lambda jest ostatnim parametrem funkcji, a poprzedzają ją parametry z wartościami domyślnymi wówczas wywołanie funkcji z argumentami domyślnymi nie wymaga nazwania ostatniego argumentu.

fun function(arg1: Int = 10, arg2: Int = 5, lambda: () -> Unit) {}
function(3) { print("lambda action") } //arg1=3, arg2=5
function() { print("lambda action") } //arg1=10, arg2=5

Zmienna ilość argumentów

W Kotlin za pomocą słowa kluczowego vararg funkcje mogą przyjmować zmienną ilość argumentów w postaci listy argumentów. Taki argument (o zmiennej ilości elementów) może być tylko jeden i przeważnie jest ostatnim parametrem funkcji. Jeśli argument vararg nie jest ostatnim w deklaracji funkcji wówczas argumenty następujące po nim muszą być wywołane jako nazwane.

fun function(vararg args: Int, text: String) {} //vararg should be the last one arg
function(1,2,3, "text") //compile error
function(1,2,3, text="text") //correct execution with named arg

//vararg could be passed as list with * modifier
var array = arrayOf(1,2,3)
function(*array, text="text")

Funkcje wyższego rzędu

Funkcje w Kotlin mogą być przechowywane w zmiennych i strukturach danych oraz przekazywane jako argumenty do innych funkcji czy też zwracane jako wynik innej funkcji (first-class function). Przekazywanie funkcji jako argumentu może odbywać się poprzez wyrażenie lambda, referencje do funkcji (refleksja), zmienną czy funkcję anonimową.

//take function as argument
fun functionWithFunArg(arg: Int = 10, lambda: (a: Int) -> Int): Int {
    //do some work and use lambda function
    return lambda(arg)
}

//execute function with function as argument
fun reflectionFun(a: Int) = a*a //just function
functionWithFunArg(3, ::reflectionFun) //passing reference to function by :: operator

var lambdaArg = { a: Int -> a*a } //function stored as variable
functionWithFunArg(3, lambdaArg) //passing function stored in variable
functionWithFunArg(3) { a: Int -> a*a } //passing anonymous function

//return function from function
fun functionWithFunReturn(arg: Int) : (a: Int) -> String {
    return { a -> "value=" + (arg*a) }
}

//execute function with function type returned
var lambdaReturn = functionWithFunReturn(10)
lambdaReturn(2)

Funkcje wyższego rzędu są przechowywane w pamięci jako obiekty co może wiązać się z przepełnieniem pamięci (np. gdy funkcja jest wywoływana w pętli - za każdym razem tworzy się nowy obiekt). Aby temu zapobieć można zdeklarować funkcję jako inline, jednakże jej użycie spowoduje zwiększenie kodu wynikowego bytecode. Funkcje oznaczone jako inline w celu otrzymania dostępu do prywatnych pól i metod klasy wymagają na właściwościach klasy modyfikatora internal oraz adnotacji @PublishedApi. Co więcej funkcje inline pozwalają wyrażeniu lambda na wyjście z funkcji wywoławczej poprzez użycie return.

@PublishedApi
internal var internalMember = "internal"
private var privateMember = "private"

inline functionInline(arg: Int = 10, lambda: (a: Int) -> Unit) {
    privateMember.toString() //compile error - not allowed
    internalMember.toString() //it's okay
    lambda(arg)
    print("This is unreachable") //because of return statement in executing
}

//execution
functionInline {
    //do something
    return //it is possible because function is inline
}

Rekurencja ogonowa

Kotlin czerpiąc z programowanie funkcyjnego udostępnia mechanizm rekurencji ogonowej (tail recursion), dzięki któremu niektóre algorytmy, które mogłyby zostać napisane przy użyciu pętli są zastępowane funkcjami rekurencyjnymi bez ponoszenia ryzyka przepełnienia stosu. Aby zadeklarować funkcję rekurencji ogonowej należy użyć słowa kluczowego tailrec. Wywołana funkcja rekurencji ogonowej musi być jednak ostatnią czynnością w bloku kodu i nie może występować w bloku try-catch.

tailrec fun fibonacci(n: Int, a: Long, b: Long): Long {
    return if (n == 0) b else fibonacci(n-1, a+b, a)
}

//instead of loop
fun fibonacciLoop(n: Int, a: Long, b: Long): Long {
    var counter = 1
    while(counter <= n) {
        var sum=a+b
        a=b
        b=sum
        counter++
    }
}

Funkcje zakresu

Kotlin dostarcza zestaw gotowych funkcji zakresu (scope functions), które służą do wywołania bloku kodu w zadanym kontekście, są to m.in. run, let, with, apply, also. Usprawniają pracę z obiektami i instrukcjami warunkowymi oraz skracają kod. Różnice między nimi są niewielkie i polegają na sposobie dostępu do obiektu odbiorcy przez operator this lub własną nazwę (domyślnie it), a także ze względu na wynikową wartość funkcji jako obiekt odbiorcy lub dowolny inny. Najwięcej zalet płynie z używania funkcji zakresu w łańcuchu wywołań dzięki czemu mogą zwiększać czytelność z uwagi na podział kodu na mniejsze sekcje. Ponadto są często wykorzystywane w procesie inicjalizacji i konfiguracji obiektów, w celu eliminacji dodatkowych zmiennych lokalnych, pominięciu sprawdzania nullable oraz nazwy obiektu w odwołaniach do argumentu.

 applyalsoletrunwith
inputthisititthisthis
outputselfselfresultresultresult

W przypadku dostępu do obiektu odbiorcy za pomocą słowa kluczowego this (apply, run, with) w większości odwołań operator this może zostać pominięty, natomiast wywołania argumentu po nazwie it - domyślnie (let, also) pozwalają na przyjęcie odpowiedniej konwecji nazewnictwa oraz wyraźne odróżnienie zakresu użycia właściwości/funkcji.

var employee = Employee().apply {
    name = "Jack"
    salary = 3000
}

var employee = Employee().also { 
    newEmployee ->
    newEmployee.name = "Jack"
    newEmployee.salary = 3000
}

//instead of
var employee = Employee()
employee.name = "Jack"
employee.salary = 3000

Funkcje zakresu zwracające obiekt odbiorcy (apply, also) pomijają instrukcje zwracające inny typ i zawsze zwracają obiekt odbiorcy. Natomiast funkcje zwracające dowolny typ (let, run, with) mogą zwrócić dowolny obiekt.

var employee = Employee("Jack", 3000)
var tax = employee.let {
    print(it)
    it
}.let {
    it.salary
}.let {
    it * 0.2
}

var tax = employee.also {
    print(it)
    it //don't need to be here
}.also {
    it.salary //it skips, employee object is passed
}.also {
    it * 0.2 //compiler error - Employee instances is here, not Int
}

//instead of
print(employee)
var tax = employee.salary * 0.2

Funkcja with jest wywoływana jak normalna funkcja co w stosunku do funkcji rozszerzających (run, let, apply, also) może powodować problemy z nullable.

var employee: Employee? = Employee("Jack", 3000)
with(employee) {
    print(this?.name)
    this?.salary = salary + 1000
}

employee?.run {
    print(name)
    salary = salary + 1000
}

//instead of
if(employee != null) {
    print(employee.name)
    employee.salary = employee.salary + 1000
}