Quelle est la différence fondamentale entre les plier et de les réduire en Kotlin? Quand à utiliser?

Je vais par le biais de bases de Kotlin et je suis assez confus avec cette fois des fonctions de fois() et reduce() dans Kotlin, quelqu'un peut-il me donner un exemple concret qui distingue les deux?

  • fois et réduction.
  • Jetez un oeil à this pour une profonde discussion fondamentale de cette rubrique
  • J'ai vu ces documents, mais ne pas l'obtenir, c'est y question posée, u peut donner l'exemple?
  • Ce n'est pas un double de foldLeft/fold. Kotlin reduce a un comportement différent, c'est pourquoi Kotlin a deux opérations. S'il vous plaît voter pour le rouvrir.
  • Pouvez-vous vous démarquer de ce que les doublons?
  • fait

InformationsquelleAutor TapanHP | 2017-06-08
  1. 213

    fois prend une valeur initiale, et la première invocation de la lambda de passer, il va recevoir la valeur initiale et le premier élément de la collection en tant que paramètres.

    Prenez, par exemple, le code suivant qui calcule la somme d'une liste d'entiers:

    listOf(1, 2, 3).fold(0) { sum, element -> sum + element }

    Le premier appel à la lambda sera avec les paramètres 0 et 1.

    Avoir la capacité de transmettre en une valeur initiale est utile si vous avez à fournir une sorte de valeur par défaut ou d'un paramètre de votre opération. Par exemple, si vous avez été la recherche de la valeur maximale à l'intérieur d'une liste, mais pour une raison quelconque veux retourner au moins de 10, vous pouvez effectuer les opérations suivantes:

    listOf(1, 6, 4).fold(10) { max, element ->
    if (element > max) element else max
}

    réduction ne pas prendre une valeur initiale, mais au lieu de cela commence avec le premier élément de la collection que l'accumulateur (appelé sum dans l'exemple suivant).

    Par exemple, prenons-en une somme d'entiers de nouveau:

    listOf(1, 2, 3).reduce { sum, element -> sum + element }

    Le premier appel à la lambda ici seront, avec les paramètres 1 et 2.

    Vous pouvez utiliser reduce lors de votre opération ne dépend pas des valeurs autres que ceux de la collection, vous l'appliquez à.

    • Bonne explication! Je dirais aussi, que le vide de la collection ne peut être réduite, mais peut être à la fois.
    • voir, m à très débutant dans Kotlin, le premier exemple que vous avez donné, pouvez-vous expliquer plus avec quelques étapes, et la réponse finale? serait une grande aide
    • comment exactement? @Miha_x64
    • acc, s -> acc + s } va produire une exception, mais emptyList<Int>().fold(0) { acc, s -> acc + s } est OK.
    • réduire les oblige aussi le retour de la lambda à être le même type que les membres de la liste, ce qui n'est pas vrai avec pli. C'est une conséquence importante de faire le premier élément de la liste, la valeur initiale de l'accumulateur.
    • juste une remarque pour l'exhaustivité: il ne doit pas être le même type. Les membres de la liste peut aussi être un sous-type de l'accumulateur: ceci fonctionne listOf<Int>(1, 2).reduce { acc: Number, i: Int -> acc.toLong() + i } (la liste-type est de type Int alors que l'accumulateur de type est déclaré que le Nombre et le fait est Long)

    InformationsquelleAutor zsmb13
  2. 5

    La différence fonctionnelle majeure, je l'appellerais " (ce qui est mentionné dans les commentaires sur l'autre réponse, mais peut être difficile à comprendre), c'est que reduce lèvera une exception si elle est effectuée sur une zone vide de la collection.

    listOf<Int>().reduce { x, y -> x + y }
//java.lang.UnsupportedOperationException: Empty collection can't be reduced.

    C'est parce que .reduce ne connais pas la valeur de retour en cas de "pas de données".

    Cela contraste avec .fold, qui vous oblige à fournir une "valeur de départ", qui sera la valeur par défaut dans le cas d'un regroupement vide:

    val result = listOf<Int>().fold(0) { x, y -> x + y }
assertEquals(0, result)

    Donc, même si vous ne voulez pas à s'agréger votre collection sur un seul élément d'un autre (non-relié) type (qui ne .fold vous permettra de le faire), si votre départ de la collection peut être vide, alors vous devez vérifier votre taille de la collection en premier et ensuite .reduce, ou tout simplement utiliser .fold

    val collection: List<Int> = //collection of unknown size

val result1 = if (collection.isEmpty()) 0
              else collection.reduce { x, y -> x + y }

val result2 = collection.fold(0) { x, y -> x + y }

assertEquals(result1, result2)
    InformationsquelleAutor Matt Klein