data stream-களுக்கு Combine-ஐ எப்போது async/await-க்குப் பதிலாக பயன்படுத்துவீர்கள்?

Question

IT Interview Practice · Accepted Answer

ஒரே ஒரு முடிவைக் கொண்ட one-shot asynchronous வேலைக்கு (ஒரு network call, ஒரு file read) **async/await**-ஐ பயன்படுத்துங்கள்; **காலப்போக்கில் value-களின் stream-களுக்கு** — UI event-கள், debounce செய்யப்பட்ட search text, அல்லது தொடர்ச்சியான update-கள் — **Combine**-ஐ (அல்லது `AsyncSequence`) பயன்படுத்துங்கள். அவை வெவ்வேறு வடிவ problem-களைத் தீர்க்கின்றன, மேலும் நவீன code அடிக்கடி அவற்றைக் கலக்கிறது.

## அவை எப்படி வேறுபடுகின்றன

- **async/await** *"எனக்கு ஒரு value கொடு, இறுதியில்"* என்பதை model செய்கிறது. இது imperative, linear, மேலும் cancellation structured (ஒரு `Task`-ஐ cancel செய்தால் அதன் child-கள் cancel ஆகின்றன).
- **Combine** publisher-கள் மற்றும் operator-கள் (`map`, `debounce`, `combineLatest`) மூலம், backpressure மற்றும் declarative composition-உடன், *"பல value-கள் வரும்போது எதிர்வினையாற்று"* என்பதை model செய்கிறது.

```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-இன் முழு machinery இனி அரிதாகவே தேவைப்படுகிறது. `AsyncSequence` மற்றும் `for await` பல streaming case-களை 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, தொடர்ச்சியான படிகள், மற்றும் ஒரே ஒரு முடிவைக் கொண்ட எதற்கும் **async/await-ஐ விரும்புங்கள்** — அது எளிமையானது, debug செய்யக்கூடியது, மேலும் compiler concurrency பாதுகாப்பை நடைமுறைப்படுத்துகிறது.
- multi-operator event pipeline-களுக்கு (`debounce` + `combineLatest` + `switchToLatest`), அல்லது `@Published` மற்றும் இருக்கும் Combine code-உடன் ஒருங்கிணைக்கும்போது **Combine-ஐ நாடுங்கள்**.
- Combine-க்கு செங்குத்தான learning curve, படிக்க கடினமான stack trace-கள், மற்றும் கைமுறை `AnyCancellable` lifetime நிர்வாகம் உண்டு.

## இது ஏன் முக்கியம்

தவறான கருவியைத் தேர்ந்தெடுப்பது trivial one-shot call-களுக்கு Combine pipeline-களை (overengineering) அல்லது ஒரு `debounce` operator போதுமான இடங்களில் கைமுறையாக உருவாக்கப்பட்ட state machine-களை உருவாக்குகிறது. *data-வின் வடிவத்தை* — single value vs stream — சரியான abstraction-உடன் நீங்கள் பொருத்துகிறீர்களா, மேலும் async/await இப்போது default என்பதை அறிவீர்களா என்பதைப் பார்க்க senior interviewer-கள் விரும்புகிறார்கள்.

அவை எப்படி வேறுபடுகின்றன

அவற்றுக்கு இடையே bridging

Trade-offs மற்றும் எப்போது தேர்ந்தெடுப்பது

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்