Kotlin
Null Veiligheid

Nullable en niet-nullable types

Normale typen, zoals String , kunnen niet op nul worden gezet. Om ervoor te zorgen dat ze nulwaarden kunnen bevatten, moet je dat expliciet aangeven door een ? achter hen: String?

var string        : String = "Hello World!"
var nullableString: String? = null

string = nullableString    // Compiler error: Can't assign nullable to non-nullable type.
nullableString = string    // This will work however!

Veilige oproep operator

Om toegang te krijgen tot functies en eigenschappen van nulbare typen, moet u speciale operatoren gebruiken.

De eerste, ?. , geeft u de eigenschap of functie waartoe u toegang probeert te krijgen, of geeft u null als het object null is:

val string: String? = "Hello World!"
print(string.length)   // Compile error: Can't directly access property of nullable type.
print(string?.length)  // Will print the string's length, or "null" if the string is null.

Idioom: meerdere methoden aanroepen op hetzelfde, null-gecontroleerde object

Een elegante manier om meerdere methoden van een object zonder controle aan te roepen, is met behulp van Kotlin's apply als volgt:

obj?.apply { 
    foo()
    bar()
}

Dit roept foo en bar op obj (dit is this in het van apply obj blok) alleen als obj niet nul is, waarbij het hele blok anders wordt overgeslagen.

Om een nulbare variabele als niet-nulbare referentie in het bereik te brengen zonder dat dit de impliciete ontvanger van functie- en eigenschapsoproepen wordt, kunt u let plaats van apply :

nullable?.let { notnull ->
    notnull.foo()
    notnull.bar()
}

notnull kan alles worden genoemd, of zelfs worden weggelaten en worden gebruikt via de impliciete lambda-parameter it .

Slimme casts

Als de compiler kan concluderen dat een object op een bepaald punt niet leeg kan zijn, hoeft u de speciale operatoren niet meer te gebruiken:

var string: String? = "Hello!"
print(string.length)  // Compile error
if(string != null) {
    // The compiler now knows that string can't be null
    print(string.length)  // It works now!
}

Opmerking: Met de compiler kunt u geen slimme veranderlijke variabelen casten die mogelijk kunnen worden gewijzigd tussen de nulcontrole en het beoogde gebruik.

Als een variabele toegankelijk is van buiten het bereik van het huidige blok (omdat ze bijvoorbeeld lid zijn van een niet-lokaal object), moet u een nieuwe, lokale referentie maken die u vervolgens kunt casten en gebruiken.

Verwijder nulls uit een Iterable en array

Soms moeten we het type wijzigen van Collection<T?> In Collections<T> . In dat geval is filterNotNull onze oplossing.

val a: List<Int?> = listOf(1, 2, 3, null)
val b: List<Int> = a.filterNotNull()

Null Coalescing / Elvis-operator

Soms is het wenselijk om een nullable uitdrukking op een if-else-manier te evalueren. De Elvis-operator, ?: , Kan in Kotlin voor een dergelijke situatie worden gebruikt.

Bijvoorbeeld:

val value: String = data?.first() ?: "Nothing here."

De bovenstaande uitdrukking retourneert "Nothing here" als data?.first() of data zelf een null waarde opleveren anders het resultaat van data?.first() .

Het is ook mogelijk om uitzonderingen te maken met dezelfde syntaxis om de uitvoering van de code af te breken.

val value: String = data?.second() 
    ?: throw IllegalArgumentException("Value can't be null!")

Ter herinnering: NullPointerExceptions kan worden geworpen met de bewering operator (bijv data!!.second()!! )

Bewering

!! achtervoegsels negeren nullabiliteit en retourneert een niet-lege versie van dat type. KotlinNullPointerException wordt gegenereerd als het object null .

val message: String? = null
println(message!!) //KotlinNullPointerException thrown, app crashes

Elvis-operator (? :)

In Kotlin, kunnen we een variabele die plaats bieden verklaren null reference . Stel dat we een nullable referentie a , dan kunnen we zeggen "als a niet nul is, gebruik het, gebruik anders een niet-nulwaarde x "

var a: String? = "Nullable String Value"

Nu kan a nul zijn. Dus als we toegang moeten hebben tot de waarde van a , moeten we een veiligheidscontrole uitvoeren, of deze waarde bevat of niet. We kunnen deze veiligheidscontrole uitvoeren met conventionele if...else verklaring.

val b: Int = if (a != null) a.length else -1

Maar hier komt vooraf operator Elvis (Operator Elvis ?: :). Hierboven if...else kan worden uitgedrukt met de Elvis-operator zoals hieronder:

val b = a?.length ?: -1

Als de uitdrukking links van ?: (Hier: a?.length ) niet nul is, retourneert de elvis-operator deze, anders retourneert hij de uitdrukking naar rechts (hier: -1 ). De expressie aan de rechterkant wordt alleen geëvalueerd als de linkerkant null is.