Extension function e higher-order function
Aggiungere comportamenti ai tipi esistenti con le extension function e usare higher-order function e scope function (let, apply, also, run, with) per scrivere codice Kotlin espressivo.
Extension function e higher-order function è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 4 lezioni in totale.
Extension function
Una extension function consente di aggiungere nuove funzioni a classi esistenti senza modificarle né usare l'ereditarietà. Può estendere String, Int, le proprie classi o persino la View di Android.
Sintassi: fun TypeName.functionName() { }
Scrivere extension function
All'interno di una extension function, this fa riferimento all'oggetto ricevitore:
fun String.isPalindrome(): Boolean {
val cleaned = this.lowercase().filter { it.isLetter() }
return cleaned == cleaned.reversed()
}
fun Int.isEven() = this % 2 == 0
fun main() {
println("racecar".isPalindrome()) // true
println("hello".isPalindrome()) // false
println(4.isEven()) // true
println(7.isEven()) // false
}Extension function sulle View di Android
Un pattern comune di Android consiste nel nascondere o mostrare le view con un'estensione, invece di ripetere codice ripetitivo:
import android.view.View
fun View.show() { visibility = View.VISIBLE }
fun View.hide() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }
// Usage in Activity:
// binding.progressBar.show()
// binding.recyclerView.hide()Funzioni di ordine superiore
Una funzione di ordine superiore accetta una funzione come parametro oppure ne restituisce una. Le ha già utilizzate: filter, map e forEach sono tutte funzioni di ordine superiore.
Sintassi del tipo funzione: (ParamType) -> ReturnType
Passare funzioni come parametri
Definisca una funzione che accetta un'altra funzione:
fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
return op(a, b)
}
fun main() {
val sum = operate(3, 4) { x, y -> x + y }
val prod = operate(3, 4) { x, y -> x * y }
val max = operate(3, 4, ::maxOf) // method reference
println(sum) // 7
println(prod) // 12
println(max) // 4
}Restituire funzioni
Le funzioni possono anche restituire altre funzioni, una possibilità utile per creare comportamenti configurabili:
fun makeMultiplier(factor: Int): (Int) -> Int {
return { number -> number * factor }
}
fun main() {
val double = makeMultiplier(2)
val triple = makeMultiplier(3)
println(double(5)) // 10
println(triple(5)) // 15
val numbers = listOf(1, 2, 3, 4)
println(numbers.map(double)) // [2, 4, 6, 8]
}Funzioni di ambito: let
Le funzioni di ambito di Kotlin eseguono un blocco su un oggetto e restituiscono un risultato. let viene usata per i controlli sui valori null e per le trasformazioni:
fun main() {
val name: String? = "Alice"
// Only runs if name is not null
name?.let {
println("Name length: ${it.length}")
println("Upper: ${it.uppercase()}")
}
// Transform a value
val length = name?.let { it.length } ?: 0
println("Length: $length") // 5
}Funzioni di ambito: apply e also
apply configura un oggetto e restituisce l'oggetto. also esegue un effetto collaterale e restituisce l'oggetto:
data class Config(var host: String = "", var port: Int = 0, var timeout: Int = 0)
fun main() {
// apply: configure an object (this = receiver)
val config = Config().apply {
host = "api.example.com"
port = 443
timeout = 30
}
println(config) // Config(host=api.example.com, port=443, timeout=30)
// also: log or debug (it = receiver)
val result = listOf(1, 2, 3)
.also { println("Original: $it") }
.map { it * 2 }
.also { println("Doubled: $it") }
}Funzioni di ambito: run e with
run esegue un blocco su un oggetto e restituisce il risultato del blocco. with è simile, ma non è un'estensione:
data class User(val name: String, val age: Int)
fun main() {
val user = User("Bob", 30)
// run: compute something using the object
val greeting = user.run {
if (age >= 18) "Hello, $name!" else "Hi, $name!"
}
println(greeting) // Hello, Bob!
// with: group operations on an object
val info = with(user) {
"Name: $name, Age: $age"
}
println(info) // Name: Bob, Age: 30
}Scheda rapida delle funzioni di ambito
Riferimento rapido per scegliere la funzione di ambito corretta:
let— blocco sicuro rispetto a null, trasforma l'oggetto e restituisce il risultato della lambdaapply— configura l'oggetto e restituisce l'oggetto (this)also— effetti collaterali (logging), restituisce l'oggetto (it)run— calcola un risultato dall'oggetto e restituisce il risultato della lambdawith— raggruppa le chiamate su un oggetto, non è un'estensione
Funzioni inline e reified
Contrassegni una funzione di ordine superiore come inline per evitare l'allocazione dell'oggetto lambda durante l'esecuzione. reified consente di usare il tipo generico T durante l'esecuzione (normalmente viene cancellato):
inline fun <reified T> Any.isOfType(): Boolean = this is T
fun main() {
println("hello".isOfType<String>()) // true
println(42.isOfType<String>()) // false
println(3.14.isOfType<Double>()) // true
}Verifica rapida
Quale funzione di ambito è più adatta per configurare un oggetto appena creato e restituire quello stesso oggetto?
Riepilogo: estensioni e funzioni di ordine superiore
Ora ha a disposizione il toolkit funzionale di Kotlin:
- Extension function — aggiungono comportamento a qualsiasi tipo senza ereditarietà
- Funzioni di ordine superiore — consentono di passare e restituire funzioni per creare API flessibili
- Funzioni di ambito:
let(controllo null),apply(configurazione),also(effetto collaterale),run/with(calcolo) inline+reified— lambda senza costi aggiuntivi con informazioni sul tipo durante l'esecuzione
Prossimo argomento: creare app con più schermate usando i Fragment.
Impara Kotlin con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 36
- Lezioni
- 152
Domande Frequenti
La lezione «Extension function e higher-order function» è gratuita?
Sì — il testo completo di «Extension function e higher-order function» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.
Cosa imparerò in «Extension function e higher-order function»?
Aggiungere comportamenti ai tipi esistenti con le extension function e usare higher-order function e scope function (let, apply, also, run, with) per scrivere codice Kotlin espressivo. Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Android Academy?
Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Extension function e higher-order function»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Android Academy?
Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Sicurezza rispetto ai valori null
- Classi e oggetti
- Data class e sealed class
- Extension function e higher-order function