data stream માટે તમે ક્યારે Combine vs async/await વાપરશો?

Question

IT Interview Practice · Accepted Answer

એક જ result વાળા one-shot asynchronous કામ માટે (network call, file read) **async/await** વાપરો; સમય જતાં આવતી **value ના stream** માટે **Combine** (અથવા `AsyncSequence`) વાપરો — UI event, debounced search text, અથવા સતત update. તેઓ સમસ્યાના જુદા આકાર ઉકેલે છે, અને આધુનિક code ઘણી વાર બંનેને ભેળવે છે.

## તેઓ કેવી રીતે અલગ છે

- **async/await** *"મને એક value આપો, આખરે"* ને model કરે છે. તે imperative, linear છે, અને cancellation structured છે (`Task` cancel કરવાથી તેના child cancel થાય છે).
- **Combine** publisher અને operator (`map`, `debounce`, `combineLatest`) દ્વારા backpressure અને declarative composition સાથે *"ઘણી value આવે તેમ react કરો"* ને 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
}
```

## તેમની વચ્ચે bridge કરવું

તમને હવે ભાગ્યે જ Combine ની આખી machinery જોઈએ છે. `AsyncSequence` અને `for await` ઘણા streaming case ને natively આવરી લે છે, અને તમે 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, ક્રમિક પગલાં, અને એક જ result વાળી કોઈપણ વસ્તુ માટે **async/await ને પ્રાધાન્ય આપો** — તે સરળ, debuggable છે, અને compiler concurrency safety enforce કરે છે.
- multi-operator event pipeline (`debounce` + `combineLatest` + `switchToLatest`) માટે, અથવા `@Published` અને હાલના Combine code સાથે integrate કરતી વખતે **Combine તરફ વળો**.
- Combine ને શીખવાની ઢાળ વધુ છે, વાંચવામાં કઠિન stack trace, અને manual `AnyCancellable` lifetime management છે.

## આ શા માટે મહત્વનું છે

ખોટું tool પસંદ કરવાથી trivial one-shot call માટે Combine pipeline (overengineering) અથવા જ્યાં `debounce` operator પૂરતું હોય ત્યાં હાથે બનાવેલા state machine તરફ દોરી જાય છે. Senior interviewer જોવા માંગે છે કે તમે *data ના આકાર* ને — single value vs stream — યોગ્ય abstraction સાથે મેળવો છો, અને જાણો છો કે async/await હવે default છે.

તેઓ કેવી રીતે અલગ છે

તેમની વચ્ચે bridge કરવું

Trade-offs અને ક્યારે પસંદ કરવું

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો