data streams साठी तुम्ही Combine केव्हा वापराल विरुद्ध async/await?

Question

IT Interview Practice · Accepted Answer

एकाच निकालासह one-shot asynchronous कामासाठी (एक network call, एक file read) **async/await** वापरा; **वेळेनुसार मूल्यांच्या streams** साठी — UI events, debounced search text, किंवा सतत updates — **Combine** (किंवा `AsyncSequence`) वापरा. ते problem च्या वेगवेगळ्या आकारांचे निराकरण करतात, आणि आधुनिक code बहुधा त्यांना मिसळते.

## ते कसे भिन्न आहेत

- **async/await** *"मला एक मूल्य द्या, अखेरीस"* चे model करते. ते imperative, रेषीय आहे, आणि cancellation structured आहे (`Task` cancel केल्यास त्याची children cancel होतात).
- **Combine** publishers आणि operators (`map`, `debounce`, `combineLatest`) द्वारे *"येताच अनेक मूल्यांवर react करा"* चे model करते, backpressure आणि declarative composition सह.

```swift
// Combine: a live, transformed stream — perfect for search-as-you-type
searchText
    .debounce(for: .milliseconds(300), scheduler: RunLoop.main)  // wait for pause
    .removeDuplicates()
    .map { query in APIClient.search(query) }                    // -> Publisher
    .switchToLatest()                                            // cancel stale requests
    .receive(on: RunLoop.main)
    .assign(to: &$results)

// async/await: a single fetch — linear and readable
func loadDetail(id: Int) async throws -> Detail {
    try await api.fetchDetail(id)     // one value, then done
}
```

## त्यांच्यात bridging

तुम्हाला Combine ची संपूर्ण यंत्रणा आता क्वचितच लागते. `AsyncSequence` आणि `for await` अनेक streaming cases native रीत्या हाताळतात, आणि तुम्ही bridge करू शकता: `publisher.values` एका Combine publisher ला `AsyncSequence` म्हणून उघड करते.

```swift
for await value in publisher.values {   // consume Combine stream with async/await
    process(value)
}
```

## Trade-offs आणि केव्हा निवडावे

- request/response, अनुक्रमिक steps, आणि एकाच निकालासह कोणत्याही गोष्टीसाठी **async/await ला प्राधान्य द्या** — ते सोपे, debuggable आहे, आणि compiler concurrency safety लागू करतो.
- multi-operator event pipelines (`debounce` + `combineLatest` + `switchToLatest`) साठी, किंवा `@Published` आणि existing Combine code शी integrate करताना **Combine कडे वळा**.
- Combine ची learning curve जास्त तीव्र आहे, stack traces वाचायला कठीण आहेत, आणि `AnyCancellable` lifetime management manual आहे.

## हे का महत्त्वाचे आहे

चुकीचे tool निवडल्याने क्षुल्लक one-shot calls साठी Combine pipelines (overengineering) किंवा जिथे `debounce` operator पुरेसा असेल तिथे हाताने बनवलेली state machines होतात. Senior मुलाखतकारांना पहायचे असते की तुम्ही *data चा आकार* — single value वि. stream — योग्य abstraction शी जुळवता, आणि async/await आता default आहे हे जाणता.

ते कसे भिन्न आहेत

त्यांच्यात bridging

Trade-offs आणि केव्हा निवडावे

हे का महत्त्वाचे आहे

संबंधित प्रश्न