0Pricing
Kotlin Academy · Pelajaran

combine dan zip: Menggabungkan Beberapa Flow

Gabungkan beberapa Flow dan satukan emisinya dengan zip.

combine dan zip: Menggabungkan Beberapa Flow adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Mengapa Menggabungkan Alur?

Aplikasi nyata sering perlu menggabungkan beberapa aliran data: preferensi pengguna + data jaringan, bidang formulir + status validasi. Kotlin Flow menyediakan zip, combine, dan merge untuk keperluan ini.

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: Emisi Berpasangan

zip memasangkan emisi satu per satu sesuai urutan. Operasi ini berhenti saat alur yang lebih pendek berakhir.

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: Nilai Terbaru

combine menghasilkan nilai baru setiap kali salah satu alur menghasilkan emisi, dengan menggunakan nilai terbaru dari masing-masing alur. Kedua alur harus sudah menghasilkan emisi setidaknya sekali.

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
}

Perbedaan combine dan zip

zip: menunggu pasangan yang cocok. combine: berjalan pada setiap pembaruan dengan menggunakan nilai terbaru. Gunakan combine untuk antarmuka pengguna reaktif, misalnya dua bidang formulir, dan zip untuk pemasangan berurutan.

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

Penggabungan: Alur Berselang-seling

merge menghasilkan emisi dari beberapa alur saat emisi tersebut tiba, tanpa memasangkannya — urutan keluaran bergantung pada waktu emisi.

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 dengan 3+ Alur

combine mendukung banyak alur. Berikan alur-alur tersebut sebagai vararg, dan lambda akan menerima semua nilai terbaru.

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: Alur Dalam yang Konkuren

flatMapMerge memetakan setiap elemen menjadi sebuah alur dan mengumpulkan semua alur dalam tersebut secara bersamaan, lalu menggabungkan keluarannya.

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: Membatalkan Emisi Baru

flatMapLatest membatalkan alur dalam saat ini ketika elemen baru tiba dari hulu — sangat cocok untuk pencarian saat mengetik.

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 untuk Memasangkan Transaksi

Gunakan zip untuk memasangkan peristiwa dari dua aliran, misalnya tindakan pengguna dengan konfirmasi server, sehingga korespondensi satu-ke-satu tetap terjamin.

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 untuk Validasi Formulir

Gabungkan alur nama pengguna dan kata sandi untuk menghitung validitas formulir secara reaktif — pembaruan terjadi setiap kali salah satu bidang berubah.

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 untuk Pemuatan dari Banyak Sumber

Gabungkan penanda pemuatan dengan alur data untuk menghasilkan satu objek status antarmuka pengguna dari beberapa sumber independen.

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
}

Pemeriksaan Singkat

Apa perbedaan utama antara zip dan combine?

Ringkasan

zip memasangkan emisi secara berurutan; combine berjalan pada setiap pembaruan dengan menggunakan nilai terbaru; merge menyelang-selingkan alur independen; flatMapLatest membatalkan alur dalam yang sudah usang. Pilih berdasarkan kebutuhan pemasangan atau reaktivitas.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “combine dan zip: Menggabungkan Beberapa Flow” gratis?

Ya — teks lengkap “combine dan zip: Menggabungkan Beberapa Flow” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “combine dan zip: Menggabungkan Beberapa Flow”?

Gabungkan beberapa Flow dan satukan emisinya dengan zip. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “combine dan zip: Menggabungkan Beberapa Flow” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Operator Flow: map, filter, transform, dan take
  2. catch dan onCompletion: Penanganan Error dalam Flow
  3. combine dan zip: Menggabungkan Beberapa Flow
  4. flowOn dan buffer: Context dan Backpressure
← Kembali ke Kotlin Academy