Funktioner och lambdas
Definiera funktioner med parametrar och returtyper, använd standardargument och namngivna argument och skriv kortfattade lambda-uttryck.
Funktioner och lambdas är en gratis lektion i Android Academy på CoddyKit. Detta är lektion 2 av 3. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Android Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Android Academy innehåller totalt 3 lektioner.
Varför funktioner?
Med funktioner kan Ni skriva ett kodblock en gång och återanvända det var som helst.
- Minskar duplicering
- Gör koden enklare att läsa och testa
- Delar upp stora problem i mindre delar
I Kotlin är funktioner förstaklassobjekt — Ni kan lagra dem i variabler och skicka runt dem.
Grundläggande funktionssyntax
En Kotlin-funktion använder nyckelordet fun:
fun greet(name: String): String {
return "Hello, $name!"
}
fun main() {
val msg = greet("Alice")
println(msg) // Hello, Alice!
println(greet("Bob")) // Hello, Bob!
}Funktioner med ett enda uttryck
När en funktionskropp består av ett enda uttryck kan Ni använda = och utelämna klamrarna och return:
fun square(n: Int): Int = n * n
fun add(a: Int, b: Int) = a + b // type inferred
fun main() {
println(square(5)) // 25
println(add(3, 7)) // 10
}Standardargument och namngivna argument
Kotlin-funktioner stöder standardvärden för parametrar — överlagrade funktioner behövs inte:
- Standard:
fun greet(name: String = "World") - Namngivet: anropa med
greet(name = "Alice")för att slippa positionsordningen
Standardargument och namngivna argument i praktiken
Standardargument håller Ert API rent:
fun buildProfile(
name: String,
age: Int = 0,
role: String = "User"
): String {
return "$name | age=$age | $role"
}
fun main() {
println(buildProfile("Alice"))
println(buildProfile("Bob", age = 30))
println(buildProfile("Carol", 25, "Admin"))
}Vad är lambdauttryck?
Ett lambdauttryck är en anonym funktion — en funktion utan namn.
- Syntax:
{ params -> body } - Lagras i en variabel:
val double = { x: Int -> x * 2 } - Skickas till en annan funktion som argument
Lambdauttryck finns överallt i Android: klicklyssnare, listtransformeringar och coroutiner.
Exempel på lambdauttryck
Lagra och anropa lambdauttryck precis som vanliga funktioner:
fun main() {
val double = { x: Int -> x * 2 }
println(double(4)) // 8
val add = { a: Int, b: Int -> a + b }
println(add(3, 5)) // 8
// Lambda with no params
val sayHi = { println("Hi!") }
sayHi() // Hi!
}Högre ordningens funktioner
En funktion av högre ordningen tar en annan funktion som parameter eller returnerar en sådan.
Kotlins standardbibliotek är fullt av dem: filter, map, forEach.
Syntax för avslutande lambdauttryck: när det sista argumentet är ett lambdauttryck flyttar Ni det utanför parenteserna.
Syntax för avslutande lambdauttryck
Skicka ett lambdauttryck som det sista argumentet utanför parenteserna:
fun applyTwice(n: Int, operation: (Int) -> Int): Int {
return operation(operation(n))
}
fun main() {
val result = applyTwice(3) { x -> x * 2 }
println(result) // 12 (3 * 2 = 6, 6 * 2 = 12)
// 'it' is the implicit single parameter
val doubled = applyTwice(5) { it + it }
println(doubled) // 20
}Snabbkontroll
Titta på den här koden. Vad kommer den att skriva ut?
val triple = { x: Int -> x * 3 }
println(triple(4))
Sammanfattning: Funktioner och lambdauttryck
Ni har lärt Er:
fundefinierar en funktion med parametrar och returtyp- Funktioner med ett enda uttryck använder kortformen
= - Standardargument och namngivna argument ersätter överlagrade funktioner
- Lambdauttryck är anonyma funktioner:
{ params -> body } - Funktioner av högre ordningen tar funktioner som parametrar
Nästa steg: styra programmets flöde med villkor och loopar.
Lär dig Kotlin med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 36
- Lektioner
- 152
Vanliga frågor
Är lektionen ”Funktioner och lambdas” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Android Academy, inklusive ”Funktioner och lambdas”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Android Academy innehåller totalt 3 lektioner.
Vad lär jag mig i ”Funktioner och lambdas”?
Definiera funktioner med parametrar och returtyper, använd standardargument och namngivna argument och skriv kortfattade lambda-uttryck. Ni övar på Android Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Android Academy?
Du behöver inga förkunskaper. Utbildningen i Android Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 3.
Hur lång tid tar lektionen ”Funktioner och lambdas”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Android Academy-lektionen?
Ja. Varje Android Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Variabler och datatyper
- Funktioner och lambdas
- Styrflöde