0Pricing
Kotlin Academy · Lección

combine y zip: combinar varios Flows

Combine varios Flows y agrupe sus emisiones mediante zip.

combine y zip: combinar varios Flows es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Por qué combinar flujos?

Las aplicaciones reales suelen necesitar combinar varios flujos de datos: preferencias del usuario + datos de red, campos de formulario + estado de validación. Kotlin Flow proporciona zip, combine y merge para hacerlo.

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: emisiones emparejadas

zip empareja las emisiones de una en una y en orden. Se detiene cuando termina el flujo más corto.

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
}

combine: valores más recientes

combine emite un valor nuevo cada vez que se produce una emisión en cualquiera de los flujos, utilizando el valor más reciente de cada uno. Ambos flujos deben haber emitido al menos una vez.

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
}

Diferencia entre combine y zip

zip: espera un par coincidente. combine: se activa con cada actualización utilizando los valores más recientes. Use combine para interfaces de usuario reactivas (por ejemplo, dos campos de formulario) y zip para emparejamientos secuenciales.

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") }
}

merge: intercalación de flujos

merge emite valores de varios flujos a medida que llegan, sin emparejarlos; el orden de salida depende del momento de cada emisión.

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
}

combine con 3 o más flujos

combine admite varios flujos. Páselos como vararg y la lambda recibirá todos los valores más recientes.

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: flujos internos simultáneos

flatMapMerge transforma cada elemento en un flujo y recopila todos los flujos internos simultáneamente, combinando sus salidas.

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: cancelar con una nueva emisión

flatMapLatest cancela el flujo interno actual cuando llega un elemento nuevo desde el flujo ascendente; es perfecto para las búsquedas mientras se escribe.

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 para emparejar transacciones

Use zip para emparejar eventos de dos flujos; por ejemplo, acciones del usuario con confirmaciones del servidor, garantizando una correspondencia de uno a uno.

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) }
}

combine para validar formularios

Combine los flujos del nombre de usuario y la contraseña para calcular de forma reactiva la validez del formulario; se actualizará cada vez que cambie cualquiera de los dos campos.

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 + combine para cargas de varias fuentes

Combine un indicador de carga con un flujo de datos para producir un único objeto de estado de la interfaz de usuario a partir de varias fuentes independientes.

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
}

Comprobación rápida

¿Cuál es la diferencia principal entre zip y combine?

Resumen

zip empareja las emisiones secuencialmente; combine se activa con cualquier actualización utilizando los valores más recientes; merge intercala flujos independientes; flatMapLatest cancela los flujos internos obsoletos. Elija según necesite emparejamiento o reactividad.

Preguntas frecuentes

¿La lección «combine y zip: combinar varios Flows» es gratis?

Sí — el texto completo de «combine y zip: combinar varios Flows» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «combine y zip: combinar varios Flows»?

Combine varios Flows y agrupe sus emisiones mediante zip. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «combine y zip: combinar varios Flows»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Operadores de Flow: map, filter, transform y take
  2. catch y onCompletion: gestión de errores en Flow
  3. combine y zip: combinar varios Flows
  4. flowOn y buffer: contexto y contrapresión
← Volver a Kotlin Academy