Wiele zmiennych wpuszcza Kotlin

Czy istnieje sposób na połączenie wielu let dla wielu zmiennych dopuszczających wartość null w kotlin?

fun example(first: String?, second: String?) {
    first?.let {
        second?.let {
            // Do something just if both are != null
        }
    }
}

Mam na myśli coś takiego:

fun example(first: String?, second: String?) {
    first?.let && second?.let { 
        // Do something just if both are != null
    }
}

Jeśli jesteś zainteresowany, oto dwie z moich funkcji do rozwiązania tego problemu.

inline fun <T: Any> guardLet(vararg elements: T?, closure: () -> Nothing): List<T> {
    return if (elements.all { it != null }) {
        elements.filterNotNull()
    } else {
        closure()
    }
}

inline fun <T: Any> ifLet(vararg elements: T?, closure: (List<T>) -> Unit) {
    if (elements.all { it != null }) {
        closure(elements.filterNotNull())
    }
}

Stosowanie:

// Will print
val (first, second, third) = guardLet("Hello", 3, Thing("Hello")) { return }
println(first)
println(second)
println(third)

// Will return
val (first, second, third) = guardLet("Hello", null, Thing("Hello")) { return }
println(first)
println(second)
println(third)

// Will print
ifLet("Hello", "A", 9) {
 (first, second, third) ->
 println(first)
 println(second)
 println(third)
}

// Won't print
ifLet("Hello", 9, null) {
 (first, second, third) ->
 println(first)
 println(second)
 println(third)
}

Oto kilka odmian, w zależności od tego, jakiego stylu będziesz chciał użyć, jeśli masz wszystko tego samego lub różnych typów i jeśli lista nieznana liczba elementów ...

Typy mieszane, wszystkie nie mogą mieć wartości null, aby obliczyć nową wartość

W przypadku typów mieszanych można utworzyć serię funkcji dla każdej liczby parametrów, które mogą wyglądać głupio, ale działają dobrze dla typów mieszanych:

inline fun <T1: Any, T2: Any, R: Any> safeLet(p1: T1?, p2: T2?, block: (T1, T2)->R?): R? {
    return if (p1 != null && p2 != null) block(p1, p2) else null
}
inline fun <T1: Any, T2: Any, T3: Any, R: Any> safeLet(p1: T1?, p2: T2?, p3: T3?, block: (T1, T2, T3)->R?): R? {
    return if (p1 != null && p2 != null && p3 != null) block(p1, p2, p3) else null
}
inline fun <T1: Any, T2: Any, T3: Any, T4: Any, R: Any> safeLet(p1: T1?, p2: T2?, p3: T3?, p4: T4?, block: (T1, T2, T3, T4)->R?): R? {
    return if (p1 != null && p2 != null && p3 != null && p4 != null) block(p1, p2, p3, p4) else null
}
inline fun <T1: Any, T2: Any, T3: Any, T4: Any, T5: Any, R: Any> safeLet(p1: T1?, p2: T2?, p3: T3?, p4: T4?, p5: T5?, block: (T1, T2, T3, T4, T5)->R?): R? {
    return if (p1 != null && p2 != null && p3 != null && p4 != null && p5 != null) block(p1, p2, p3, p4, p5) else null
}
// ...keep going up to the parameter count you care about

Przykładowe użycie:

val risk = safeLet(person.name, person.age) { name, age ->
  // do something
}   

Wykonaj blok kodu, gdy lista nie zawiera elementów zerowych

Dwa warianty tutaj, po pierwsze, aby wykonać blok kodu, gdy lista zawiera wszystkie elementy niepuste, a po drugie, aby zrobić to samo, gdy lista zawiera co najmniej jeden element niezerowy. Oba przypadki przekazują listę elementów niezerowych do bloku kodu:

Funkcje:

fun <T: Any, R: Any> Collection<T?>.whenAllNotNull(block: (List<T>)->R) {
    if (this.all { it != null }) {
        block(this.filterNotNull()) // or do unsafe cast to non null collectino
    }
}

fun <T: Any, R: Any> Collection<T?>.whenAnyNotNull(block: (List<T>)->R) {
    if (this.any { it != null }) {
        block(this.filterNotNull())
    }
}

Przykładowe użycie:

listOf("something", "else", "matters").whenAllNotNull {
    println(it.joinToString(" "))
} // output "something else matters"

listOf("something", null, "matters").whenAllNotNull {
    println(it.joinToString(" "))
} // no output

listOf("something", null, "matters").whenAnyNotNull {
    println(it.joinToString(" "))
} // output "something matters"

Niewielka zmiana, aby funkcja otrzymywała listę elementów i wykonywała te same operacje:

fun <T: Any, R: Any> whenAllNotNull(vararg options: T?, block: (List<T>)->R) {
    if (options.all { it != null }) {
        block(options.filterNotNull()) // or do unsafe cast to non null collection
    }
}

fun <T: Any, R: Any> whenAnyNotNull(vararg options: T?, block: (List<T>)->R) {
    if (options.any { it != null }) {
        block(options.filterNotNull())
    }
}

Przykładowe użycie:

whenAllNotNull("something", "else", "matters") {
    println(it.joinToString(" "))
} // output "something else matters"

Te odmiany można zmienić, aby zwracały wartości, takie jak let() .

Użyj pierwszego niezerowego przedmiotu (Coalesce)

Podobnie jak w przypadku funkcji SQL Coalesce, zwraca pierwszy element inny niż pusty. Dwa smaki funkcji:

fun <T: Any> coalesce(vararg options: T?): T? = options.firstOrNull { it != null }
fun <T: Any> Collection<T?>.coalesce(): T? = this.firstOrNull { it != null }

Przykładowe użycie:

coalesce(null, "something", null, "matters")?.let {
    it.length
} // result is 9, length of "something"

listOf(null, "something", null, "matters").coalesce()?.let {
    it.length
}  // result is 9, length of "something"

Inne odmiany

... Istnieją inne odmiany, ale przy większej specyfikacji można to zawęzić.

Możesz w tym celu napisać własną funkcję:

 fun <T, U, R> Pair<T?, U?>.biLet(body: (T, U) -> R): R? {
     val first = first
     val second = second
     if (first != null && second != null) {
         return body(first, second)
     }
     return null
 }

 (first to second).biLet { first, second -> 
      // body
 }

Możesz stworzyć arrayIfNoNullsfunkcję:

fun <T : Any> arrayIfNoNulls(vararg elements: T?): Array<T>? {
    if (null in elements) {
        return null
    }
    @Suppress("UNCHECKED_CAST")
    return elements as Array<T>
}

Możesz go następnie użyć dla zmiennej liczby wartości z let:

fun example(first: String?, second: String?) {
    arrayIfNoNulls(first, second)?.let { (first, second) ->
        // Do something if each element is not null
    }
}

Jeśli masz już tablicę, możesz utworzyć takeIfNoNullsfunkcję (inspirowaną takeIfi requireNoNulls):

fun <T : Any> Array<T?>.takeIfNoNulls(): Array<T>? {
    if (null in this) {
        return null
    }
    @Suppress("UNCHECKED_CAST")
    return this as Array<T>
}

Przykład:

array?.takeIfNoNulls()?.let { (first, second) ->
    // Do something if each element is not null
}

W przypadku, gdy sprawdzasz tylko dwie wartości i nie musisz pracować z listami:

fun <T1, T2> ifNotNull(value1: T1?, value2: T2?, bothNotNull: (T1, T2) -> (Unit)) {
    if (value1 != null && value2 != null) {
        bothNotNull(value1, value2)
    }
}

Przykład użycia:

var firstString: String?
var secondString: String?
ifNotNull(firstString, secondString) { first, second -> Log.d(TAG, "$first, $second") }

Właściwie możesz to po prostu zrobić, wiesz? ;)

if (first != null && second != null) {
    // your logic here...
}

Nie ma nic złego w korzystaniu z normalnej kontroli zerowej w Kotlinie.

Jest znacznie bardziej czytelny dla każdego, kto zajrzy do Twojego kodu.

Właściwie wolę rozwiązać ten problem za pomocą następujących funkcji pomocniczych:

fun <A, B> T(tuple: Pair<A?, B?>): Pair<A, B>? =
    if(tuple.first == null || tuple.second == null) null
    else Pair(tuple.first!!, tuple.second!!)

fun <A, B, C> T(tuple: Triple<A?, B?, C?>): Triple<A, B, C>? =
    if(tuple.first == null || tuple.second == null || tuple.third == null) null
    else Triple(tuple.first!!, tuple.second!!, tuple.third!!)


fun <A, B> T(first: A?, second: B?): Pair<A, B>? =
    if(first == null || second == null) null
    else Pair(first, second)

fun <A, B, C> T(first: A?, second: B?, third: C?): Triple<A, B, C>? =
        if(first == null || second == null || third == null) null
        else Triple(first, second, third)

A oto jak ich używać:

val a: A? = someValue
val b: B? = someOtherValue
T(a, b)?.let { (a, b) ->
  // Shadowed a and b are of type a: A and b: B
  val c: C? = anotherValue
  T(a, b, c)
}?.let { (a, b, c) ->
  // Shadowed a, b and c are of type a: A, b: B and c: C
  .
  .
  .
}

Rozwiązałem to, tworząc funkcje, które w mniejszym lub większym stopniu replikują zachowanie with, ale przyjmują wiele parametrów i tylko wywołują funkcję, dla której wszystkie parametry nie są zerowe.

fun <R, A, B> withNoNulls(p1: A?, p2: B?, function: (p1: A, p2: B) -> R): R? = p1?.let { p2?.let { function.invoke(p1, p2) } }
fun <R, A, B, C> withNoNulls(p1: A?, p2: B?, p3: C?, function: (p1: A, p2: B, p3: C) -> R): R? = p1?.let { p2?.let { p3?.let { function.invoke(p1, p2, p3) } } }
fun <R, A, B, C, D> withNoNulls(p1: A?, p2: B?, p3: C?, p4: D?, function: (p1: A, p2: B, p3: C, p4: D) -> R): R? = p1?.let { p2?.let { p3?.let { p4?.let { function.invoke(p1, p2, p3, p4) } } } }
fun <R, A, B, C, D, E> withNoNulls(p1: A?, p2: B?, p3: C?, p4: D?, p5: E?, function: (p1: A, p2: B, p3: C, p4: D, p5: E) -> R): R? = p1?.let { p2?.let { p3?.let { p4?.let { p5?.let { function.invoke(p1, p2, p3, p4, p5) } } } } }

Następnie używam tego w ten sposób:

withNoNulls("hello", "world", Throwable("error")) { p1, p2, p3 ->
    p3.printStackTrace()
    p1.plus(" ").plus(p2)
}?.let {
    Log.d("TAG", it)
} ?: throw Exception("One or more parameters was null")

Oczywistym problemem jest to, że muszę zdefiniować funkcję dla każdego przypadku (liczby zmiennych), których potrzebuję, ale przynajmniej myślę, że kod wygląda czysto, gdy ich używam.

Ty też możesz to zrobić

if (listOfNotNull(var1, var2, var3).size == 3) {
        // All variables are non-null
}

Zaktualizowałem nieco oczekiwaną odpowiedź:

inline fun <T: Any, R: Any> ifLet(vararg elements: T?, closure: (List<T>) -> R): R? {
    return if (elements.all { it != null }) {
        closure(elements.filterNotNull())
    } else null
}

to umożliwia:

iflet("first", "sconed") {
    // do somehing
} ?: run {
    // do this if one of the params are null
}

Dla dowolnej ilości wartości do sprawdzenia możesz użyć tego:

    fun checkNulls(vararg elements: Any?, block: (Array<*>) -> Unit) {
        elements.forEach { if (it == null) return }
        block(elements.requireNoNulls())
    }

I będzie używany w ten sposób:

    val dada: String? = null
    val dede = "1"

    checkNulls(dada, dede) { strings ->

    }

elementy wysłane do bloku używają symboli wieloznacznych, musisz sprawdzić typy, jeśli chcesz uzyskać dostęp do wartości, jeśli potrzebujesz tylko jednego typu, możesz zmienić to na ogólne