Kotlin Academy · Lezione

it: il parametro implicito

Utilizzi il parametro implicito 'it' nelle lambda con un solo parametro.

it: il parametro implicito è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 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 Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

L'it implicito

Quando una lambda ha esattamente un parametro, può ometterne la dichiarazione e farvi riferimento come it. Questo riduce la quantità di codice nelle pipeline brevi.

it in forEach

L'esempio classico: forEach passa ogni elemento come it.

fun main() {
    listOf(1, 2, 3).forEach { println(it) }
}

it in map

Trasformi ogni elemento usando it come input.

fun main() {
    val doubled = listOf(1, 2, 3).map { it * 2 }
    println(doubled) // [2, 4, 6]
}

it in filter

filter mantiene gli elementi per i quali la lambda restituisce true. it rappresenta l'elemento corrente.

fun main() {
    val evens = listOf(1, 2, 3, 4, 5).filter { it % 2 == 0 }
    println(evens) // [2, 4]
}

Quando NON usare it

Se il corpo della lambda non è banale, assegni un nome esplicito al parametro. Dare un nome migliora la chiarezza rispetto all'abbreviazione it.

fun main() {
    val users = listOf("alice", "bob")
    // OK
    users.forEach { println(it) }
    // Clearer with a name when body is bigger
    users.forEach { name ->
        println("User: $name length=${name.length}")
    }
}

it nelle lambda annidate

Presti attenzione alle lambda annidate: ogni it è associato alla lambda più interna. Dare un nome ai parametri evita ambiguità.

fun main() {
    val nested = listOf(listOf(1, 2), listOf(3, 4))
    // Both lambdas use it — confusing!
    nested.forEach { outer ->
        outer.forEach { inner ->
            println("$outer -> $inner")
        }
    }
}

it con i metodi sulle stringhe

Un modello comune: filtrare o trasformare stringhe usando it.

fun main() {
    val names = listOf("Alice", "bob", "Charlie")
    val upper = names.map { it.uppercase() }
    println(upper)
}

it con le proprietà

it.property è un modo chiaro per accedere ai campi durante la concatenazione delle operazioni.

data class Person(val name: String, val age: Int)
fun main() {
    val people = listOf(Person("Ana", 20), Person("Ben", 35))
    val names = people.map { it.name }
    println(names) // [Ana, Ben]
}

Predicati con it

I predicati (lambda che restituiscono Boolean) risultano naturali con it.

fun main() {
    val nums = listOf(1, 4, 7, 9)
    println(nums.any { it > 5 }) // true
    println(nums.all { it > 0 }) // true
    println(nums.none { it < 0 }) // true
}

Funzioni personalizzate con it

Qualsiasi funzione di ordine superiore con una lambda a parametro singolo fornisce automaticamente it.

fun <T> List<T>.firstWhere(predicate: (T) -> Boolean): T? {
    for (item in this) if (predicate(item)) return item
    return null
}
fun main() {
    val n = listOf(3, 8, 4, 5).firstWhere { it > 5 }
    println(n) // 8
}

it nelle funzioni di ambito

Alcune funzioni di ambito (let, also) usano it come ricevitore; altre (apply, run) usano this. Scelga in base alla necessità di fare riferimento esplicitamente al ricevitore.

fun main() {
    val name: String? = "Kotlin"
    name?.let { println("hello $it") } // it = name
}

Verifica rapida

Quando può usare it invece di assegnare un nome al parametro di una lambda?

Riepilogo

it è il nome implicito dell'unico parametro di una lambda a un parametro. Lo usi per abbreviare le lambda brevi. Assegni nomi espliciti ai parametri quando i corpi diventano più lunghi o quando l'annidamento potrebbe creare confusione.

Domande Frequenti

La lezione «it: il parametro implicito» è gratuita?

Sì — il testo completo di «it: il parametro implicito» è 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 Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «it: il parametro implicito»?

Utilizzi il parametro implicito 'it' nelle lambda con un solo parametro. Eserciti Kotlin 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 Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin 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 3 di 4.

Quanto tempo richiede la lezione «it: il parametro implicito»?

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 Kotlin Academy?

Sì. Ogni lezione Kotlin 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

← Torna a Kotlin Academy