Kotlin
funktioner

Syntax

• roligt Namn ( Params ) = ...
• roligt namn ( Params ) {...}
• roligt namn ( Params ): Skriv {...}
• fun < Type Argument > Name ( Params ): Type {...}
• inline fun Namn ( Params ): Skriv {...}
• { ArgName : ArgType -> ...}
• { ArgName -> ...}
• { ArgNames -> ...}
• {( ArgName : ArgType ): Type -> ...}

parametrar

Funktioner Med andra funktioner

Som det ses i "Lambda-funktioner", kan funktioner ta andra funktioner som en parameter. "Funktionstyp" som du behöver för att deklara funktioner som tar andra funktioner är som följer:

# Takes no parameters and returns anything
() -> Any?

# Takes a string and an integer and returns ReturnType
(arg1: String, arg2: Int) -> ReturnType

Till exempel kan du använda den vagaste typen, () -> Any? , för att förklara en funktion som kör en lambda-funktion två gånger:

fun twice(x: () -> Any?) {
    x(); x();
}

fun main() {
    twice {
        println("Foo")
    } # => Foo
      # => Foo
}

Lambda-funktioner

Lambdafunktioner är anonyma funktioner som vanligtvis skapas under ett funktionssamtal för att fungera som en funktionsparameter. De deklareras av omgivande uttryck med {hängslen} - om argument behövs läggs dessa framför en pil -> .

{ name: String ->
    "Your name is $name" //This is returned
}

Det sista påståendet i en lambda-funktion är automatiskt returvärdet.

Typerna är valfria om du sätter lambda på en plats där kompilatorn kan dra slutsatsen.

Flera argument:

{ argumentOne:String, argumentTwo:String ->
    "$argumentOne - $argumentTwo"
}

Om lambda-funktionen bara behöver ett argument, kan argumentlistan utelämnas och det enda argumentet hänvisas till med it istället.

{ "Your name is $it" }

Om det enda argumentet för en funktion är en lambda-funktion kan parenteser helt utelämnas från funktionssamtalet.

# These are identical
listOf(1, 2, 3, 4).map { it + 2 }
listOf(1, 2, 3, 4).map({ it + 2 })

Funktionsreferenser

Vi kan referera till en funktion utan att faktiskt kalla den genom att förfixa funktionens namn med :: . Detta kan sedan överföras till en funktion som accepterar någon annan funktion som en parameter.

fun addTwo(x: Int) = x + 2
listOf(1, 2, 3, 4).map(::addTwo) # => [3, 4, 5, 6]

Funktioner utan mottagare konverteras till (ParamTypeA, ParamTypeB, ...) -> ReturnType där ParamTypeA , ParamTypeB ... är typen av funktionsparametrar och `ReturnType1 är typen av funktionsreturvärde.

fun foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
println(::foo::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function3<Foo0, Foo1, Foo2, Bar>
// Human readable type: (Foo0, Foo1, Foo2) -> Bar

Funktioner med en mottagare (vare sig det är en förlängningsfunktion eller en medlemsfunktion) har en annan syntax. Du måste lägga till typnamnet på mottagaren före den dubbla kolon:

class Foo
fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
val ref = Foo::foo
println(ref::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function4<Foo, Foo0, Foo1, Foo2, Bar>
// Human readable type: (Foo, Foo0, Foo1, Foo2) -> Bar
// takes 4 parameters, with receiver as first and actual parameters following, in their order

// this function can't be called like an extension function, though
val ref = Foo::foo
Foo().ref(Foo0(), Foo1(), Foo2()) // compile error

class Bar {
    fun bar()
}
print(Bar::bar) // works on member functions, too.

Men när en funktionsmottagare är ett objekt, utelämnas mottagaren från parameterlistan, eftersom dessa är och endast är ett exempel av en sådan typ.

object Foo
fun Foo.foo(p0: Foo0, p1: Foo1, p2: Foo2): Bar {
    //...
}
val ref = Foo::foo
println(ref::class.java.genericInterfaces[0]) 
// kotlin.jvm.functions.Function3<Foo0, Foo1, Foo2, Bar>
// Human readable type: (Foo0, Foo1, Foo2) -> Bar
// takes 3 parameters, receiver not needed

object Bar {
    fun bar()
}
print(Bar::bar) // works on member functions, too.

Sedan kotlin 1.1 kan funktionsreferenser också begränsas till en variabel, som sedan kallas en begränsad funktionsreferens .

fun makeList(last: String?): List<String> {
    val list = mutableListOf("a", "b", "c")
    last?.let(list::add)
    return list
}

_{Observera att detta exempel endast ges för att visa hur begränsad funktionsreferens fungerar. Det är dålig övning i alla andra sinnen.}

Det finns dock ett speciellt fall. En tilläggsfunktion som förklaras som medlem kan inte refereras till.

class Foo
class Bar {
    fun Foo.foo() {}
    val ref = Foo::foo // compile error
}

Grundläggande funktioner

Funktioner deklareras med hjälp av det fun nyckelordet, följt av ett funktionsnamn och eventuella parametrar. Du kan också ange returtypen för en funktion, som är standard som Unit . Funktionens kropp är innesluten i hängslen {} . Om returtypen är annan än Unit , måste kroppen utfärda ett returrätt för varje avslutande gren i kroppen.

fun sayMyName(name: String): String {
    return "Your name is $name" 
} 

En kort version av samma:

fun sayMyName(name: String): String = "Your name is $name" 

Och typen kan utelämnas eftersom man kan dra slutsatsen:

fun sayMyName(name: String) = "Your name is $name" 

Kortvariga funktioner

Om en funktion bara innehåller ett uttryck kan vi utelämna parenteserna och använda en lika i stället, som en variabel tilldelning. Resultatet av uttrycket returneras automatiskt.

fun sayMyName(name: String): String = "Your name is $name" 

Inlinefunktioner

Funktioner kan förklaras inline med hjälp av inline prefixet, och i det här fallet fungerar de som makron i C - snarare än att de kallas, ersätts de av funktionens kroppskod vid sammanställningstiden. Detta kan leda till prestandafördelar under vissa omständigheter, främst där lambdas används som funktionsparametrar.

inline fun sayMyName(name: String) = "Your name is $name" 

En skillnad från C-makron är att inlinefunktioner inte har åtkomst till omfattningen från vilken de heter:

inline fun sayMyName() = "Your name is $name"

fun main() {
    val name = "Foo"
    sayMyName() # => Unresolved reference: name
}

Operatörsfunktioner

Kotlin tillåter oss att tillhandahålla implementeringar för en fördefinierad uppsättning operatörer med fast symbolisk representation (som + eller * ) och fast företräde. För att implementera en operatör tillhandahåller vi en medlemsfunktion eller en förlängningsfunktion med ett fast namn, för motsvarande typ. Funktioner som överbelastar operatörer måste markeras med operator :

data class IntListWrapper (val wrapped: List<Int>) {
    operator fun get(position: Int): Int = wrapped[position]
}

val a = IntListWrapper(listOf(1, 2, 3))
a[1] // == 2

Fler operatörsfunktioner finns här