Kotlin Academy · Lezione

L'operatore !!

Forzi il tipo non-null e ne valuti i rischi

L'operatore !! è 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.

Forzare un valore non nullo

A volte sa con certezza che un valore nullable non è null, ma il compilatore continua a segnalare un errore.

L'operatore di asserzione di non nullità !! dice al compilatore di fidarsi di Lei e di trattare il valore come non nullo.

Uso di base

L'aggiunta di !! converte un tipo nullable nel corrispondente tipo non nullo.

Se il valore è effettivamente non nullo, il codice funziona esattamente come una chiamata normale.

fun main() {
    val name: String? = "Kotlin"
    println(name!!.length)
}

Il rischio

Se il valore è effettivamente null, !! genera un NullPointerException proprio in quel punto.

Questo è l'unico caso in cui Kotlin consente che si verifichi un NPE, e la responsabilità è interamente Sua.

fun main() {
    val name: String? = null
    try {
        println(name!!.length)
    } catch (e: NullPointerException) {
        println("Boom: NullPointerException")
    }
}

Perché esiste

L'operatore è volutamente sgradevole. Due punti esclamativi risaltano nella revisione del codice e segnalano un punto in cui ha aggirato la rete di sicurezza.

Esiste per i casi rari in cui sa davvero più del compilatore.

Di solito è meglio una chiamata sicura

Nella maggior parte dei casi, una chiamata sicura ?. insieme a Elvis ?: è più sicura e altrettanto breve.

Confronti qui sotto i due approcci per raggiungere lo stesso obiettivo.

fun main() {
    val name: String? = null
    val safeLength = name?.length ?: 0
    println(safeLength)
}

Eviti di concatenare !!

Non concateni mai più operatori !! come a!!.b!!.c. Se si verifica un errore, non potrà capire quale parte fosse null.

Scomponga l'espressione oppure usi le chiamate sicure.

fun main() {
    val text: String? = "hi"
    // bad style: text!!.uppercase()!! is hard to debug
    val good = text?.uppercase() ?: ""
    println(good)
}

Un caso d'uso legittimo

Un caso accettabile è un valore impostato in precedenza che sa essere inizializzato a questo punto.

Anche in questo caso, quando possibile, preferisca lateinit oppure ristrutturi il codice.

fun main() {
    var config: String? = null
    config = "loaded"
    // we just assigned it, so !! is safe here
    println(config!!.uppercase())
}

Leggere lo stack trace

Quando !! non riesce, l'eccezione indica la riga esatta. Questa precisione è l'unico vantaggio rispetto a un risultato errato e silenzioso.

Usi il messaggio per individuare e correggere l'ipotesi errata.

fun length(text: String?): Int {
    return text!!.length
}

fun main() {
    println(length("abc"))
    // length(null) would throw on the !! line
}

Eliminare !! con il refactoring

La maggior parte degli operatori !! può essere rimossa gestendo correttamente i valori null. Qui sotto, un valore alternativo fornito da Elvis rende la funzione totale e priva di arresti anomali.

fun length(text: String?): Int {
    return text?.length ?: 0
}

fun main() {
    println(length("abc"))
    println(length(null))
}

Regola pratica

Consideri ogni !! una domanda: è assolutamente certo che questo valore non sia mai null?

Se sì e in casi rari → accettabile
Se non è sicuro → usi ?. e ?:

Tutto insieme

L'operatore !! è uno strumento potente ma rischioso:

Forza un valore nullable a diventare di tipo non nullo
Genera un NullPointerException se il valore è null
Preferisca le chiamate sicure e Elvis in quasi tutti i casi

fun main() {
    val sure: String? = "definitely here"
    println(sure!!.length)
    val maybe: String? = null
    println(maybe?.length ?: -1)
}

Verifica rapida

Verifichi la comprensione dell'operatore di asserzione di non nullità.

Riepilogo

Ha imparato a conoscere l'operatore !!:

Afferma che un valore nullable non è null
Genera un NullPointerException quando l'ipotesi è errata
Dovrebbe essere l'ultima risorsa, non un'abitudine

Successivamente vedrà come la nullabilità arriva da Java attraverso i tipi di piattaforma.

Domande Frequenti

La lezione «L'operatore !!» è gratuita?

Sì — il testo completo di «L'operatore !!» è 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 «L'operatore !!»?

Forzi il tipo non-null e ne valuti i rischi 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 «L'operatore !!»?

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