Idiomatiques façon de gérer les valeurs null ou vide Liste dans Kotlin

Pour quelques actions simples, vous pouvez utiliser le coffre-fort d'appel de l'opérateur, en supposant que l'action respecte aussi ne fonctionne pas sur une liste vide (pour le traitement de votre dossier de les deux nulle et vide:

myList?.forEach { ...only iterates if not null and not empty }

Pour d'autres actions. vous pouvez écrire une fonction d'extension -- deux variantes, selon si vous souhaitez recevoir la liste this ou en tant que paramètre:

inline fun <E: Any, T: Collection<E>> T?.withNotNullNorEmpty(func: T.() -> Unit): Unit {
    if (this != null && this.isNotEmpty()) {
        with (this) { func() }
    }
}

inline fun  <E: Any, T: Collection<E>> T?.whenNotNullNorEmpty(func: (T) -> Unit): Unit {
    if (this != null && this.isNotEmpty()) {
        func(this)
    }
}

Que vous pouvez utiliser comme:

fun foo() {  
    val something: List<String>? = makeListOrNot()
    something.withNotNullNorEmpty { 
        //do anything I want, list is `this`
    }

    something.whenNotNullNorEmpty { myList ->
        //do anything I want, list is `myList`
    }
}

Vous pouvez aussi faire l'inverse de la fonction:

inline fun <E: Any, T: Collection<E>> T?.withNullOrEmpty(func: () -> Unit): Unit {
    if (this == null || this.isEmpty()) {
        func()
    }
}

Je voudrais éviter de le chaînage de ces, parce qu'alors vous remplacez un if ou when déclaration avec quelque chose de plus verbeux. Et vous obtenez de plus en plus dans le domaine que les solutions de rechange que je mentionne ci-dessous donnent, qui est plein de ramification de la réussite/l'échec des situations.

Remarque: ces extensions ont été généralisés à tous les descendants de Collections holding non les valeurs null. Et de travail pour plus que juste des Listes.

Alternatives:

La Résultat bibliothèque de Kotlin donne une belle façon de gérer votre affaire", ou que" fondée sur les valeurs de réponse. Pour les Promesses, vous pouvez trouver la même chose dans le Kovenant de la bibliothèque.

Ces deux bibliothèques de vous donner de manière pour le retour alternative résultats à partir d'une seule fonction, et aussi pour la ramification, le code sur la base des résultats. Ils exigent que vous êtes en contrôle le fournisseur de la "réponse" qui est pris en compte.

Ce sont de bonnes Kotlin alternatives à Optional et Maybe.

À explorer l'extension de Fonctions (et peut-être de trop)

Cette section est de montrer que lorsque vous appuyez sur une question comme la question soulevée ici, vous pouvez facilement trouver beaucoup de réponses dans Kotlin pour faire du codage de la façon dont vous voulez qu'il soit. Si le monde n'est pas sympathique, changer le monde. Il n'est pas conçu comme une bonne ou une mauvaise réponse, mais plutôt des informations supplémentaires.

Si vous aimez les fonctions d'extension et d'envisager de chaîne dans une expression, je serais probablement modifier comme suit...

La withXyz saveurs de retour this et la whenXyz doit retourner un nouveau type permettant à l'ensemble de la collection pour devenir une nouvelle (peut-être même sans rapport avec l'original). Résultant dans un code comme suit:

val BAD_PREFIX = "abc"
fun example(someList: List<String>?) {
    someList?.filterNot { it.startsWith(BAD_PREFIX) }
            ?.sorted()
            .withNotNullNorEmpty {
                //do something with `this` list and return itself automatically
            }
            .whenNotNullNorEmpty { list ->
                //do something to replace `list` with something new
                listOf("x","y","z")
            }
            .whenNullOrEmpty {
                //other code returning something new to replace the null or empty list
                setOf("was","null","but","not","now")
            }
}

Remarque: le code complet de cette version est à la fin du poste (1)

Mais vous pouvez aussi aller une direction complètement nouvelle avec un custom "ce que" mécanisme:

fun foo(someList: List<String>?) {
    someList.whenNullOrEmpty {
        //other code
    }
    .otherwise { list ->
        //do something with `list`
    }
}

Il n'y a pas de limites, d'être créatif et d'apprendre le pouvoir d'extensions, d'essayer de nouvelles idées, et comme vous pouvez le voir, il existe de nombreuses variantes à ce que les gens veulent de code de ce type de situations. Le stdlib ne peut pas supporter 8 variations de ce type de méthodes, sans être source de confusion. Mais chaque groupe de développement peuvent avoir des extensions qui correspondent à leur style de codage.

Remarque: le code complet de cette version est à la fin de la poste (2)

L'exemple de code 1: Voici le code complet pour le "enchaîné" version:

inline fun <E: Any, T: Collection<E>> T?.withNotNullNorEmpty(func: T.() -> Unit): T? {
    if (this != null && this.isNotEmpty()) {
        with (this) { func() }
    }
    return this
}

inline fun  <E: Any, T: Collection<E>, R: Any> T?.whenNotNullNorEmpty(func: (T) -> R?): R? {
    if (this != null && this.isNotEmpty()) {
        return func(this)
    }
    return null
}

inline fun <E: Any, T: Collection<E>> T?.withNullOrEmpty(func: () -> Unit): T? {
    if (this == null || this.isEmpty()) {
        func()
    }
    return this
}

inline fun <E: Any, T: Collection<E>, R: Any> T?.whenNullOrEmpty(func: () -> R?): R?  {
    if (this == null || this.isEmpty()) {
        return func()
    }
    return null
}

Exemple de Code 2: Voici le code complet pour un "autrement que" de la bibliothèque (avec l'unité de test):

inline fun <E : Any, T : Collection<E>> T?.withNotNullNorEmpty(func: T.() -> Unit): Otherwise {
return if (this != null && this.isNotEmpty()) {
with (this) { func() }
OtherwiseIgnore
} else {
OtherwiseInvoke
}
}
inline fun  <E : Any, T : Collection<E>> T?.whenNotNullNorEmpty(func: (T) -> Unit): Otherwise {
return if (this != null && this.isNotEmpty()) {
func(this)
OtherwiseIgnore
} else {
OtherwiseInvoke
}
}
inline fun <E : Any, T : Collection<E>> T?.withNullOrEmpty(func: () -> Unit): OtherwiseWithValue<T> {
return if (this == null || this.isEmpty()) {
func()
OtherwiseWithValueIgnore<T>()
} else {
OtherwiseWithValueInvoke(this)
}
}
inline fun <E : Any, T : Collection<E>> T?.whenNullOrEmpty(func: () -> Unit): OtherwiseWhenValue<T> {
return if (this == null || this.isEmpty()) {
func()
OtherwiseWhenValueIgnore<T>()
} else {
OtherwiseWhenValueInvoke(this)
}
}
interface Otherwise {
fun otherwise(func: () -> Unit): Unit
}
object OtherwiseInvoke : Otherwise {
override fun otherwise(func: () -> Unit): Unit {
func()
}
}
object OtherwiseIgnore : Otherwise {
override fun otherwise(func: () -> Unit): Unit {
}
}
interface OtherwiseWithValue<T> {
fun otherwise(func: T.() -> Unit): Unit
}
class OtherwiseWithValueInvoke<T>(val value: T) : OtherwiseWithValue<T> {
override fun otherwise(func: T.() -> Unit): Unit {
with (value) { func() }
}
}
class OtherwiseWithValueIgnore<T> : OtherwiseWithValue<T> {
override fun otherwise(func: T.() -> Unit): Unit {
}
}
interface OtherwiseWhenValue<T> {
fun otherwise(func: (T) -> Unit): Unit
}
class OtherwiseWhenValueInvoke<T>(val value: T) : OtherwiseWhenValue<T> {
override fun otherwise(func: (T) -> Unit): Unit {
func(value)
}
}
class OtherwiseWhenValueIgnore<T> : OtherwiseWhenValue<T> {
override fun otherwise(func: (T) -> Unit): Unit {
}
}
class TestBrancher {
@Test fun testOne() {
//when NOT null or empty
emptyList<String>().whenNotNullNorEmpty { list ->
fail("should not branch here")
}.otherwise {
//sucess
}
nullList<String>().whenNotNullNorEmpty { list ->
fail("should not branch here")
}.otherwise {
//sucess
}
listOf("a", "b").whenNotNullNorEmpty { list ->
assertEquals(listOf("a", "b"), list)
}.otherwise {
fail("should not branch here")
}
//when YES null or empty
emptyList<String>().whenNullOrEmpty {
//sucess
}.otherwise { list ->
fail("should not branch here")
}
nullList<String>().whenNullOrEmpty {
//success
}.otherwise {
fail("should not branch here")
}
listOf("a", "b").whenNullOrEmpty {
fail("should not branch here")
}.otherwise { list ->
assertEquals(listOf("a", "b"), list)
}
//with NOT null or empty
emptyList<String>().withNotNullNorEmpty {
fail("should not branch here")
}.otherwise {
//sucess
}
nullList<String>().withNotNullNorEmpty {
fail("should not branch here")
}.otherwise {
//sucess
}
listOf("a", "b").withNotNullNorEmpty {
assertEquals(listOf("a", "b"), this)
}.otherwise {
fail("should not branch here")
}
//with YES null or empty
emptyList<String>().withNullOrEmpty {
//sucess
}.otherwise {
fail("should not branch here")
}
nullList<String>().withNullOrEmpty {
//success
}.otherwise {
fail("should not branch here")
}
listOf("a", "b").withNullOrEmpty {
fail("should not branch here")
}.otherwise {
assertEquals(listOf("a", "b"), this)
}
}
fun <T : Any> nullList(): List<T>? = null
}

En plus des autres réponses, vous pouvez également utiliser le coffre-opérateur d'appel en combinaison avec la méthode d'extension isNotEmpty(). En raison de la sécurité d'appel, la valeur de retour est en fait Boolean? qui peut être soit true, false ou null. Pour utiliser l'expression dans un if ou when clause, vous devez explicitement vérifier si il est true:

when {
activities?.isNotEmpty() == true -> doSomething
else -> doSomethingElse
}

Syntaxe Alternative à l'aide de l'elvis opérateur:

when {
activities?.isNotEmpty() ?: false -> doSomething
else -> doSomethingElse
}

Envisager d'utiliser ?.forEach le cas échéant

activities?.forEach {
doSmth(it)
}

Si vous voulez exactement le comportement que vous avez décrit, je pense que votre variante lit mieux puis autre chose de plus concis que je pense. (Et pourtant simple if devrait suffire)

La méthode à utiliser dans Kotlin 1.3 est isNullOrEmpty comme ce qui a été dit dans cette réponse: https://stackoverflow.com/a/48056456/2735286

Voici un exemple de son utilisation:

fun main(args: Array<String>) {
var array: MutableList<String>? = null
println(array.isNullOrEmpty()) //true
array = mutableListOf()
println(array.isNullOrEmpty()) //true
array = mutableListOf("a")
println(array.isNullOrEmpty()) //false
}

Cet exemple affiche:

true
true
false