Kotlin und idiomatische Art zu schreiben, “wenn nicht null, sonst …”, basierend auf veränderlichen Werten

Angenommen, wir haben diesen Code:

class QuickExample {

    fun function(argument: SomeOtherClass) {
        if (argument.mutableProperty != null ) {
            doSomething(argument.mutableProperty)
        } else {
            doOtherThing()
        }
    }

    fun doSomething(argument: Object) {}

    fun doOtherThing() {}
}

class SomeOtherClass {
    var mutableProperty: Object? = null
}

Anders als in Java, wo Sie sich zur Laufzeit um die Null-Dereferenzierung kümmern könnten, wird dies nicht kompiliert – völlig zu Recht. Na sicher, mutableProperty darf innerhalb des ‘if’ nicht mehr einmal null sein.

Meine Frage ist, wie geht man damit am besten um?

Ein paar Optionen sind offensichtlich. Ohne neue Kotlin-Sprachfunktionen zu verwenden, besteht der einfachste Weg offensichtlich darin, den Wert in einen Methodenbereich zu kopieren, der sich später nicht ändert.

Da ist das:

fun function(argument: SomeOtherClass) {
    argument.mutableProperty?.let {
        doSomething(it)
        return
    }
    doOtherThing()
}

Dies hat den offensichtlichen Nachteil, dass Sie früh zurückkehren oder anderweitig vermeiden müssen, den nachfolgenden Code auszuführen – OK in bestimmten, kleinen Kontexten, aber es riecht danach.

Dann gibt es diese Möglichkeit:

fun function(argument: SomeOtherClass) {
    argument.mutableProperty.let {
        when {
            it != null -> {
                doSomething(it)
            }
            else -> {
                doOtherThing()
            }
        }
    }
}

aber obwohl es einen klareren Zweck hat, ist es wohl unhandlicher und ausführlicher als die Java-artige Art, damit umzugehen.

Übersehe ich irgendetwas und gibt es eine bevorzugte Sprache, um dies zu erreichen?

Aktualisieren:

Wie von franta in den Kommentaren erwähnt, wenn die Methode doSomething() gibt null zurück, dann wird der Code auf der rechten Seite des elvis-Operators ausgeführt, was für die meisten nicht der gewünschte Fall ist. Aber gleichzeitig ist es in diesem Fall sehr wahrscheinlich, dass die doSomething() Methode wird nur etwas tun und nichts zurückgeben.

Und eine Alternative: Wie Protossor in den Kommentaren erwähnt hat, also kann eher verwendet werden als letWeil also kehrt zurück this Objekt anstelle des Ergebnisses des Funktionsbausteins.

mutableProperty?.also { doSomething(it) } ?: doOtherThing()

Ursprüngliche Antwort:

ich würde … benutzen let mit Elvis-Operator.

mutableProperty?.let { doSomething(it) } ?: doOtherThing()

Aus dem Dokument:

Wenn der Ausdruck links von ?: nicht null ist, gibt der Elvis-Operator ihn zurück, andernfalls gibt er den Ausdruck rechts davon zurück. Beachten Sie, dass der Ausdruck auf der rechten Seite nur ausgewertet wird, wenn die linke Seite null ist.

Für einen Codeblock nach dem Ausdruck auf der rechten Seite:

   mutableProperty?.let {
            doSomething(it)
        } ?: run {
            doOtherThing()
            doOtherThing()
        }

Ich glaube nicht, dass es einen wirklich “kurzen” Weg gibt, um dies zu erreichen, aber Sie können einfach eine Bedingung innerhalb verwenden with oder let:

with(mutableVar) { if (this != null) doSomething(this) else doOtherThing() }
mutableVar.let { if (it != null) doSomething(it) else doOtherThing() }

Tatsächlich ist das „Erfassen“ eines veränderlichen Werts einer der Hauptanwendungsfälle von let.

Dies entspricht Ihrer when Aussage.

Es gibt immer die von Ihnen beschriebene Möglichkeit, sie einer Variablen zuzuweisen:

val immutable = mutableVar

if (immutable != null) {
    doSomething(immutable)
} else {
    doOtherThing()
}

was immer ein netter Fallback ist, falls es zB zu ausführlich wird.

Es gibt wahrscheinlich nicht wirklich ein sehr Hübsch Weg, dies zu erreichen, weil nur die letzte Das Lambda-Argument darf außerhalb von platziert werden ()also würde die Angabe von zwei nicht wirklich zur Syntax aller anderen Standardfunktionen passen.

Du könnte schreiben Sie eine, wenn es Ihnen nichts ausmacht (oder wenn Sie stattdessen Methodenreferenzen übergeben):

inline fun <T : Any, R> T?.ifNotNullOrElse(ifNotNullPath: (T) -> R, elsePath: () -> R)
        = let { if(it == null) elsePath() else ifNotNullPath(it) }

...

val a: Int? = null
a.ifNotNullOrElse({ println("not null") }, { println("null") })

Beachten Sie, dass ich persönlich würde nicht Tun Sie dies, da keines dieser benutzerdefinierten Konstrukte sehr angenehm zu lesen ist. IMO: bleib dran let/run und zurückfallen if–else wenn nötig.

fügen Sie eine benutzerdefinierte Inline-Funktion wie folgt hinzu:

inline fun <T> T?.whenNull(block: T?.() -> Unit): T? {
    if (this == null) block()
    return this@whenNull
}

inline fun <T> T?.whenNonNull(block: T.() -> Unit): T? {
    this?.block()
    return this@whenNonNull
}

dann kannst du Code wie diesen schreiben:

var nullableVariable :Any? = null
nullableVariable.whenNonNull {
    doSomething(nullableVariable)
}.whenNull {
    doOtherThing()
}

Wie wäre es mit:

argument.mutableProperty
  ?.let { doSomething(it) } 
  ?: doOtherThing()

Normalerweise mache ich nur:

when(val it=argument.mutableProperty) {
    null -> doOtherThing()
    else -> doSomething(it)
}

ich schreibe es meistens so:

  takeIf{somecondition}?.also{put somecondition is met code}?:run{put your else code here}

Beachten Sie das Fragezeichen nach takeIf ist ein MUSS. Sie können das Schlüsselwort auch verwenden oder anwenden.

Dank @zyc zyc verwende ich jetzt diesen Code

inline fun <T> T?.ifNull(block: () -> Unit): T? {
    if (this == null) block()
    return this@ifNull
}

inline fun <T> T?.ifNonNull(block: (T) -> Unit): T? {
    this?.let(block)
    return this@ifNonNull
}

// use
xxxx.ifNull {
    // todo
}.ifNonNull {
    // todo
}