0Pricing
Kotlin Academy · Leçon

combine et zip : fusionner plusieurs Flows

Combinez plusieurs Flows et synchronisez leurs émissions avec zip.

combine et zip : fusionner plusieurs Flows est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Pourquoi fusionner des flux ?

Les applications réelles doivent souvent combiner plusieurs flux de données : préférences utilisateur et données réseau, champs de formulaire et état de validation. Kotlin Flow fournit zip, combine et merge pour cela.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val names = flowOf("Alice", "Bob", "Carol")
    val ages  = flowOf(30, 25, 35)
    names.zip(ages) { name, age -> "$name is $age" }
         .collect { println(it) }
}

zip : émissions par paires

zip associe les émissions deux à deux, dans l’ordre. Il s’arrête lorsque le flux le plus court se termine.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val a = flowOf(1, 2, 3, 4)   // 4 elements
    val b = flowOf("a", "b", "c")  // 3 elements — zip stops here
    a.zip(b) { n, s -> "$n-$s" }
     .collect { println(it) } // 1-a, 2-b, 3-c
}

Combinaison : valeurs les plus récentes

combine émet une nouvelle valeur chaque fois qu’un des flux émet, en utilisant la valeur la plus récente de chacun. Les deux flux doivent avoir émis au moins une fois.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow1 = MutableStateFlow(1)
    val flow2 = MutableStateFlow("a")
    combine(flow1, flow2) { n, s -> "$n-$s" }
        .take(1)
        .collect { println(it) } // 1-a
}

Différence entre la combinaison et zip

zip : attend une paire correspondante. combine : se déclenche à chaque mise à jour en utilisant les valeurs les plus récentes. Utilisez la combinaison pour une interface réactive (par exemple, deux champs de formulaire) et zip pour associer des éléments séquentiellement.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    // zip: 1-a, 2-b
    val nums = flowOf(1, 2).zip(flowOf("a", "b")) { n, s -> "$n-$s" }
    nums.collect { println("zip: $it") }

    // combine fires more:
    combine(flowOf(1, 2), flowOf("a")) { n, s -> "$n-$s" }
        .collect { println("combine: $it") }
}

Fusion : flux entrelacés

merge émet les valeurs de plusieurs flux dès leur arrivée, sans les associer : l’ordre de sortie dépend du moment des émissions.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val a = flow { emit("A1"); delay(50); emit("A2") }
    val b = flow { delay(25); emit("B1") }
    merge(a, b).collect { println(it) } // A1, B1, A2
}

Combinaison de 3 flux ou plus

combine prend en charge plusieurs flux. Transmettez-les comme arguments variadiques et la lambda reçoit toutes les valeurs les plus récentes.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val a = MutableStateFlow("hello")
    val b = MutableStateFlow(42)
    val c = MutableStateFlow(true)
    combine(a, b, c) { s, n, flag -> "$s-$n-$flag" }
        .take(1)
        .collect { println(it) } // hello-42-true
}

flatMapMerge : flux internes concurrents

flatMapMerge transforme chaque élément en flux et collecte tous les flux internes simultanément, en fusionnant leurs sorties.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..3).asFlow()
        .flatMapMerge { n ->
            flow { delay(100L - n * 10); emit("result-$n") }
        }
        .collect { println(it) }
}

flatMapLatest : annulation à chaque nouvelle émission

flatMapLatest annule le flux interne actuel lorsqu’un nouvel élément arrive en amont : c’est idéal pour la recherche au fil de la saisie.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flowOf("k", "ko", "kot", "kotl", "kotli", "kotlin")
        .flatMapLatest { query ->
            flow {
                delay(50)  // simulate debounced search
                emit("Result for: $query")
            }
        }
        .collect { println(it) } // only "Result for: kotlin"
}

zip pour associer des transactions

Utilisez zip pour associer les événements de deux flux : par exemple, les actions de l’utilisateur et les confirmations du serveur, afin de garantir une correspondance un-à-un.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val orders = flowOf("Order1", "Order2", "Order3")
    val confirmations = flowOf("Confirmed", "Confirmed", "Rejected")
    orders.zip(confirmations) { order, status -> "$order: $status" }
          .collect { println(it) }
}

Combinaison pour la validation d’un formulaire

Combinez les flux du nom d’utilisateur et du mot de passe pour calculer réactivement la validité du formulaire : celle-ci est mise à jour chaque fois que l’un des champs change.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val username = MutableStateFlow("")
    val password = MutableStateFlow("")
    val isValid = combine(username, password) { u, p ->
        u.length >= 3 && p.length >= 8
    }
    username.value = "alice"
    password.value = "secure123"
    println(isValid.first()) // true
}

onEach + combinaison pour un chargement multi-source

Combinez un indicateur de chargement avec un flux de données pour produire un objet d’état d’interface unique à partir de plusieurs sources indépendantes.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
data class UI(val loading: Boolean, val data: String)
fun main() = runBlocking {
    val loading = MutableStateFlow(true)
    val data    = MutableStateFlow("")
    combine(loading, data) { l, d -> UI(l, d) }
        .take(2)
        .collect { println(it) }
    data.value = "result"
    loading.value = false
}

Vérification rapide

Quelle est la principale différence entre zip et combine ?

Récapitulatif

zip associe les émissions séquentiellement ; la combinaison se déclenche à chaque mise à jour en utilisant les valeurs les plus récentes ; la fusion entrelace les flux indépendants ; flatMapLatest annule les flux internes obsolètes. Faites votre choix selon que vous avez besoin d’associer des éléments ou de réactivité.

Questions Fréquemment Posées

La leçon « combine et zip : fusionner plusieurs Flows » est-elle gratuite ?

Oui — le texte complet de « combine et zip : fusionner plusieurs Flows » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « combine et zip : fusionner plusieurs Flows » ?

Combinez plusieurs Flows et synchronisez leurs émissions avec zip. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « combine et zip : fusionner plusieurs Flows » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Opérateurs de Flow : map, filter, transform et take
  2. catch et onCompletion : gestion des erreurs dans Flow
  3. combine et zip : fusionner plusieurs Flows
  4. flowOn et buffer : contexte et contre-pression
← Retour à Kotlin Academy