il modo migliore per il controllo nullo in kotlin?

Question

Devo usare il doppio = o il triplo =?

if(a === null) { 
//do something 
} 

o

if(a == null) { 
//do something 
} 

Allo stesso modo per i 'non è uguale a':

if(a !== null) { 
//do something 
} 

o

if(a != null) { 
//do something 
} 

Answer 1

Entrambi gli approcci generare lo stesso bytecode modo da poter scegliere quello che preferite .

Answer 2

A parità strutturale a == b viene tradotto

a?.equals(b) ?: (b === null) 

Pertanto quando si confrontano al null, l'uguaglianza strutturale a == null è tradotto in un'uguaglianza referenziale a === null.

Secondo il docs, non v'è alcun punto in ottimizzazione del codice, in modo da poter usare a == null e a != null


Nota che se la variabile è una proprietà mutevole, non sarà in grado di intelligente trasmetterlo al suo tipo non annullabile all'interno dell'istruzione if (poiché il valore potrebbe essere stato modificato da un altro thread) e dovresti invece utilizzare l'operatore di chiamata sicura con let.

operatore di call sicuro?.

a?.let { 
    // not null do something 
    println(it) 
    println("not null") 
} 

Si può usare in combinazione con l'operatore di Elvis.

Elvis operatore ?:(sto cercando di indovinare perché il punto interrogativo si presenta come capelli di Elvis')

a ?: println("null") 

E se si desidera eseguire un blocco di codice

a ?: run { 
    println("null") 
    println("The King has left the building") 
} 

Combinazione dei due

a?.let { 
    println("not null") 
    println("Wop-bop-a-loom-a-boom-bam-boom") 
} ?: run { 
    println("null") 
    println("When things go null, don't go with them") 
} 

Answer 3

Controlla i metodi utili fuori, potrebbe essere utile:

/** 
* Performs [R] when [T] is not null. Block [R] will have context of [T] 
*/ 
inline fun <T : Any, R> ifNotNull(input: T?, callback: (T) -> R): R? { 
    return input?.let(callback) 
} 

/** 
* Checking if [T] is not `null` and if its function completes or satisfies to some condition. 
*/ 
inline fun <T: Any> T?.isNotNullAndSatisfies(check: T.() -> Boolean?): Boolean{ 
    return ifNotNull(this) { it.run(check) } ?: false 
} 

Qui di seguito è possibile esempio come utilizzare queste funzioni:

var s: String? = null 

// ... 

if (s.isNotNullAndSatisfies{ isEmpty() }{ 
    // do something 
}