view identity మరియు diffing చుట్టూ SwiftUI performance ను ఎలా optimize చేస్తారు?

Question

IT Interview Practice · Accepted Answer

Observed state మారినప్పుడు SwiftUI `body` ను తిరిగి run చేస్తుంది, తర్వాత కొత్త view tree ను పాతదానితో **diff** చేసి తేడా ఉన్నదాన్ని మాత్రమే update చేస్తుంది. Performance సమస్యలు ఆ diff ను ఎక్కువ పని చేయించడం నుండి వస్తాయి: అస్థిర **identity**, అతి-విస్తృత **observation**, మరియు ఖరీదైన `body` computation లు. Identity ని నియంత్రించడం, state ను scope చేయడం, మరియు `body` ను చవకగా ఉంచడం ద్వారా దాన్ని fix చేయండి.

## Diffing మరియు identity ఎలా పనిచేస్తాయి

SwiftUI render ల మధ్య view లను **identity** ద్వారా match చేస్తుంది. List ల కోసం ఇది `id`; id అస్థిరమైతే, SwiftUI view ను update చేయడానికి బదులుగా దాన్ని విసిరివేసి తిరిగి నిర్మిస్తుంది (state మరియు animation లను కోల్పోతుంది).

```swift
// BAD: array index as id — reorders/inserts break identity, full rebuild
ForEach(items.indices, id: \.self) { i in Row(items[i]) }

// GOOD: stable identity tied to the data
ForEach(items) { item in Row(item) }      // items: Identifiable, stable id
```

## Observation ను scope చేయడం

ఒక `ObservableObject` ఏదైనా `@Published` property మారినప్పుడు దాన్ని observe చేసే **ప్రతి** view ను re-render చేస్తుంది. పెద్ద model లను విభజించండి, లేదా **Observation framework** (`@Observable`, iOS 17+) కు మారండి, ఇది *per-property* read లను ట్రాక్ చేస్తుంది కాబట్టి ఒక view అది నిజంగా వాడిన property మారినప్పుడు మాత్రమే re-render అవుతుంది.

```swift
@Observable final class Feed {     // iOS 17: fine-grained dependency tracking
    var unreadCount = 0            // a view reading only .posts won't re-render on this
    var posts: [Post] = []
}
```

## body ను చవకగా ఉంచడం

`body` తరచుగా run అవుతుంది, కాబట్టి ఎప్పుడూ భారీ పనిని inline గా చేయవద్దు:

```swift
var body: some View {
    List(sortedItems) { ... }      // BAD if sortedItems sorts on every render
}
// GOOD: compute derived data in the model, not in body
```

- ఒక state మార్పు మొత్తం screen కాదు, **చిన్న** view ను re-render చేసేలా subview లను extract చేయండి.
- పెద్ద collection ల కోసం `LazyVStack`/`List` వాడండి కాబట్టి off-screen row లు నిర్మించబడవు.
- స్థిరమైన subtree లపై diffing ను short-circuit చేయడానికి `.equatable()` లేదా `EquatableView` ను జోడించండి.

## లోపాలు

- `AnyView` type identity ను erase చేసి structural diffing ను ఓడిస్తుంది — hot path లలో దాన్ని మానుకోండి.
- ప్రతి render లో కొత్త closure/array literal ను pass చేయడం child view లను అనవసరంగా invalidate చేయగలదు.

## ఇది ఎందుకు ముఖ్యం

120Hz ProMotion display పై మీకు frame కు ~8ms ఉంటుంది; ఒక పెద్ద array ను sort చేసే లేదా మొత్తం list ను re-render చేసే `body` frame లను drop చేసి scrolling ను jank చేస్తుంది. నిజమైన SwiftUI app లు నెమ్మదిగా అయ్యే చోటు అది — మరియు కొన్ని ఖచ్చితమైన fix లు మృదుత్వాన్ని పునరుద్ధరించే చోటు — కాబట్టి senior interview లు view identity మరియు observation scope ను probe చేస్తాయి.

Diffing మరియు identity ఎలా పనిచేస్తాయి

Observation ను scope చేయడం

body ను చవకగా ఉంచడం

లోపాలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు