Kotlin Academy · Lektion

Operatorn !!: när och varför den bör undvikas

Förstå operatorn för att hävda icke-null, dess risker och bättre alternativ.

Lektion 4 av 413 steg

Operatorn !!: när och varför den bör undvikas är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 4 av 4. 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 Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Vad är !!?

Operatorn non-null assertion !! omvandlar en nullbar typ till en icke-nullbar typ. Om värdet är null vid körning kastas NullPointerException.

Grundläggande användning av !!

x!! returnerar x om det inte är null, och kastar annars NPE.

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

!! kastar ett undantag vid null

Om värdet faktiskt är null får du precis det undantag som Kotlin försöker förhindra.

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

Bättre: safe call

Föredra ?. framför !! – det ger smidig hantering utan krascher.

fun main() {
    val name: String? = null
    val len = name?.length
    println(len) // null — no crash
}

Bättre: Elvis-operatorn

Kombinera ?. med ?: för att ange ett rimligt standardvärde.

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

Bättre: smart cast

En kontroll med if (x != null) aktiverar en smart cast – inget !! behövs.

fun main() {
    val name: String? = "Alice"
    if (name != null) {
        println(name.length) // smart-cast to String
    }
}

Bättre: requireNotNull

Om värdet måste finnas kastar requireNotNull(x) { "..." } ett meningsfullt IllegalArgumentException.

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
}

Bättre: checkNotNull

checkNotNull(x) fungerar på samma sätt men kastar IllegalStateException – använd det för invariants.

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())
}

Legitima användningsområden för !!

Sällsynt men giltigt: när frånvaron av null är en verklig invariant som inte kan bevisas vid kompilering (till exempel efter ett reflektionsanrop). Kommentera varför.

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)
}

Kedjade !! – det ultimata antimönstret

Flera !! i en kedja är en kodlukt. Refaktorera med safe calls och guard clauses.

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)
}

Refaktorera bort !!

Ersätt !! med ett ärligare API: nullbara returvärden, requireNotNull vid inmatningen eller en tidig retur.

fun firstUpper(s: String?): String? = s?.firstOrNull()?.uppercase()
fun main() {
    println(firstUpper("alice")) // A
    println(firstUpper(""))      // null
    println(firstUpper(null))    // null
}

Snabbkontroll

Vad händer om du använder !! på ett värde som faktiskt är null vid körning?

Sammanfattning

!! är nödlösningen som kringgår Kotlin nullsäkerhet. Föredra ?., ?:, smarta typomvandlingar, requireNotNull eller checkNotNull. Använd !! endast för dokumenterade invariants som kompilatorn inte kan bevisa.

Gratis att börja

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
51
Lektioner
203

Vanliga frågor

Är lektionen ”Operatorn !!: när och varför den bör undvikas” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Operatorn !!: när och varför den bör undvikas”, 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 Kotlin Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Operatorn !!: när och varför den bör undvikas”?

Förstå operatorn för att hävda icke-null, dess risker och bättre alternativ. Ni övar på Kotlin 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 Kotlin Academy?

Du behöver inga förkunskaper. Utbildningen i Kotlin 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 4 av 4.

Hur lång tid tar lektionen ”Operatorn !!: när och varför den bör undvikas”?

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

Ja. Varje Kotlin 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

  1. Nullable typer och modifieraren ?
  2. Säkra anrop ?. och Elvis ?: i riktig kod
  3. let, also och run med nullable receivers
  4. Operatorn !!: när och varför den bör undvikas
← Tillbaka till Kotlin Academy