Operatore !!: quando e perché evitarlo
Comprenda l'operatore di asserzione non-null, i suoi rischi e le alternative migliori.
Operatore !!: quando e perché evitarlo è una lezione Kotlin 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 Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.
Che cos'è !!?
L'operatore di asserzione non-null !! converte un tipo nullable in non nullable. Se il valore è null durante l'esecuzione, genera una NullPointerException.
Utilizzo di base di !!
x!! restituisce x se non è null; altrimenti genera una NPE.
fun main() {
val name: String? = "Kotlin"
val len: Int = name!!.length // 6
println(len)
}!! genera un'eccezione in caso di null
Se il valore è effettivamente null, si verifica proprio l'eccezione che Kotlin cerca di prevenire.
fun main() {
val name: String? = null
try {
println(name!!.length)
} catch (e: NullPointerException) {
println("NPE caught!")
}
}Alternativa migliore: chiamata sicura
Al posto di !!, preferisca ?.: una gestione controllata senza arresti anomali.
fun main() {
val name: String? = null
val len = name?.length
println(len) // null — no crash
}Alternativa migliore: operatore Elvis
Abbini ?. a ?: per fornire un valore predefinito sensato.
fun main() {
val name: String? = null
val len = name?.length ?: 0
println(len) // 0
}Alternativa migliore: smart cast
Un controllo if (x != null) abilita uno smart cast: non è necessario usare !!.
fun main() {
val name: String? = "Alice"
if (name != null) {
println(name.length) // smart-cast to String
}
}Alternativa migliore: requireNotNull
Se il valore deve essere presente, requireNotNull(x) { "..." } genera una IllegalArgumentException significativa.
fun process(name: String?) {
val safe = requireNotNull(name) { "name is required" }
println("processing $safe")
}
fun main() {
process("Ada")
// process(null) // throws IllegalArgumentException: name is required
}Alternativa migliore: checkNotNull
checkNotNull(x) si comporta allo stesso modo, ma genera una IllegalStateException: lo usi per le invarianti.
class Service {
private var data: String? = null
fun load() { data = "loaded" }
fun read(): String = checkNotNull(data) { "load() must be called first" }
}
fun main() {
val s = Service()
s.load()
println(s.read())
}Usi legittimi di !!
Raro ma valido: quando l'assenza di null è un'invariante reale che non può essere dimostrata in fase di compilazione (ad esempio dopo una chiamata tramite reflection). Commenti il motivo.
fun main() {
val list = listOf(1, 2, 3)
val firstEven: Int = list.find { it % 2 == 0 }!! // safe: we know list has an even
println(firstEven)
}!! concatenati: il massimo degli anti-pattern
Più !! in una catena sono un campanello d'allarme. Rifattorizzi usando chiamate sicure e clausole di guardia.
class A(val b: B?)
class B(val c: C?)
class C(val name: String?)
fun main() {
val a: A? = A(B(C("ok")))
// BAD: val n = a!!.b!!.c!!.name!!
val n = a?.b?.c?.name ?: "unknown"
println(n)
}Eliminare !! con il refactoring
Sostituisca !! con un'API più trasparente: restituzioni nullable, requireNotNull all'ingresso oppure un ritorno anticipato.
fun firstUpper(s: String?): String? = s?.firstOrNull()?.uppercase()
fun main() {
println(firstUpper("alice")) // A
println(firstUpper("")) // null
println(firstUpper(null)) // null
}Verifica rapida
Che cosa accade se applica !! a un valore che durante l'esecuzione è effettivamente null?
Riepilogo
!! è la scappatoia che annulla la sicurezza di Kotlin rispetto a null. Preferisca ?., ?:, gli smart cast, requireNotNull o checkNotNull. Riservi !! alle invarianti documentate che il compilatore non può dimostrare.
Domande Frequenti
La lezione «Operatore !!: quando e perché evitarlo» è gratuita?
Sì — il testo completo di «Operatore !!: quando e perché evitarlo» è 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 «Operatore !!: quando e perché evitarlo»?
Comprenda l'operatore di asserzione non-null, i suoi rischi e le alternative migliori. 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 4 di 4.
Quanto tempo richiede la lezione «Operatore !!: quando e perché evitarlo»?
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
- Tipi nullable e modificatore ?
- Safe call ?. ed Elvis ?: nel codice reale
- let, also e run con receiver nullable
- Operatore !!: quando e perché evitarlo