0Pricing
Kotlin Academy · Ders

combine ve zip: Birden Çok Flow'u Birleştirme

Birden çok Flow'u birleştirin ve emisyonlarını birlikte zip'leyin.

combine ve zip: Birden Çok Flow'u Birleştirme, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Kotlin Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Kotlin Academy kursu toplamda 4 dersten oluşur.

Akışlar Neden Birleştirilir?

Gerçek uygulamaların genellikle birden çok veri akışını birleştirmesi gerekir: kullanıcı tercihleri + ağ verileri, form alanları + doğrulama durumu. Kotlin akışı bunun için zip, combine ve merge sağlar.

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: Eşleştirilmiş Değer Üretimleri

zip, değer üretimlerini sırayla bire bir eşleştirir. Daha kısa akış sona erdiğinde durur.

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: En Güncel Değerler

combine, akışlardan herhangi biri değer ürettiğinde her birinin en güncel değerini kullanarak yeni bir değer üretir. Her iki akış da en az bir kez değer üretmiş olmalıdır.

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
}

combine ve zip Farkı

zip: eşleşen çifti bekler. combine: en güncel değerleri kullanarak her güncellemede çalışır. Tepkisel kullanıcı arayüzleri (örneğin iki form alanı) için combine, sıralı eşleştirme için zip kullanın.

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

birleştirme: İç İçe Geçen Akışlar

merge, birden çok akıştan gelen değerleri eşleştirme yapmadan ulaştıkları sırayla üretir; çıktı sırası, değerlerin üretilme zamanına bağlıdır.

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
}

3 veya Daha Fazla Akışla combine

combine, birden çok akışı destekler. Bunları değişken sayıda bağımsız değişken olarak aktarın; lambda tüm en güncel değerleri alır.

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: Eşzamanlı İç Akışlar

flatMapMerge, her öğeyi bir akışa dönüştürür ve tüm iç akışları eşzamanlı olarak toplar; çıktıları birleştirir.

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: Yeni Değer Üretiminde İptal

flatMapLatest, üst akıştan yeni bir öğe geldiğinde geçerli iç akışı iptal eder; yazdıkça arama için idealdir.

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

İşlemleri Eşleştirmek için zip

İki akıştan gelen olayları eşleştirmek için zip kullanın; örneğin bire bir karşılık sağlaması gereken kullanıcı eylemleriyle sunucu onaylarını eşleştirin.

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

Form Doğrulama için combine

Kullanıcı adı ve parola akışlarını birleştirerek formun geçerliliğini tepkisel biçimde hesaplayın; alanlardan biri değiştiğinde güncelleme yapılır.

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
}

Birden Çok Kaynaktan Yükleme için onEach + combine

Birden çok bağımsız kaynaktan tek bir kullanıcı arayüzü durumu nesnesi oluşturmak için bir yükleme bayrağını veri akışıyla birleştirin.

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
}

Hızlı Kontrol

zip ile combine arasındaki temel fark nedir?

Özet

zip, değer üretimlerini sırayla eşleştirir; combine, en güncel değerleri kullanarak her güncellemede çalışır; birleştirme, bağımsız akışları iç içe geçirir; flatMapLatest, geçerliliğini yitirmiş iç akışları iptal eder. Eşleştirme veya tepkisellik gereksinimlerinize göre seçim yapın.

Sıkça Sorulan Sorular

“combine ve zip: Birden Çok Flow'u Birleştirme” dersi ücretsiz mi?

Evet — “combine ve zip: Birden Çok Flow'u Birleştirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Kotlin Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Kotlin Academy kursu toplamda 4 dersten oluşur.

“combine ve zip: Birden Çok Flow'u Birleştirme” dersinde ne öğreneceğim?

Birden çok Flow'u birleştirin ve emisyonlarını birlikte zip'leyin. Kotlin Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Kotlin Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Kotlin Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“combine ve zip: Birden Çok Flow'u Birleştirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Kotlin Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Kotlin Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Flow İşleçleri: map, filter, transform ve take
  2. catch ve onCompletion: Flow'da Hata İşleme
  3. combine ve zip: Birden Çok Flow'u Birleştirme
  4. flowOn ve buffer: Bağlam ve Geri Basınç
← Kotlin Academy Sayfasına Dön