view identity மற்றும் diffing-ஐ சுற்றி SwiftUI performance-ஐ எப்படி optimize செய்வீர்கள்?

Question

IT Interview Practice · Accepted Answer

observed state மாறும்போதெல்லாம் SwiftUI `body`-ஐ மீண்டும் இயக்குகிறது, பின்னர் புதிய view tree-ஐ பழையதுடன் **diff** செய்து வேறுபடுவதை மட்டுமே update செய்கிறது. Performance problem-கள் அந்த diff-ஐ அதிக வேலை செய்யவைப்பதிலிருந்து வருகின்றன: நிலையற்ற **identity**, மிக-பரந்த **observation**, மற்றும் விலையுயர்ந்த `body` கணக்கீடுகள். identity-ஐ கட்டுப்படுத்துவதன் மூலமும், state-ஐ scope செய்வதன் மூலமும், `body`-ஐ மலிவாக வைப்பதன் மூலமும் அதைச் சரிசெய்யுங்கள்.

## diffing மற்றும் identity எப்படி வேலை செய்கின்றன

SwiftUI render-கள் முழுவதும் view-களை **identity** மூலம் பொருத்துகிறது. 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-ஐயும் மீண்டும் render செய்கிறது. பெரிய model-களை பிரியுங்கள், அல்லது **Observation framework**-க்கு (`@Observable`, iOS 17+) நகருங்கள், இது *per-property* read-களைக் கண்காணிக்கிறது, எனவே ஒரு view உண்மையில் பயன்படுத்திய property மாறும்போது மட்டுமே மீண்டும் 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` அடிக்கடி இயங்குகிறது, எனவே கனமான வேலையை ஒருபோதும் 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-ஐ மீண்டும் render செய்யும்படி subview-களை extract செய்யுங்கள்.
- பெரிய collection-களுக்கு `LazyVStack`/`List`-ஐ பயன்படுத்துங்கள், எனவே off-screen row-கள் கட்டமைக்கப்படாது.
- நிலையான subtree-களில் diffing-ஐ short-circuit செய்ய `.equatable()` அல்லது `EquatableView`-ஐ சேர்க்கவும்.

## சிக்கல்கள்

- `AnyView` type identity-ஐ அழித்து structural diffing-ஐ தோற்கடிக்கிறது — hot path-களில் அதைத் தவிர்க்கவும்.
- ஒவ்வொரு render-இலும் ஒரு புதிய closure/array literal-ஐ pass செய்வது child view-களை தேவையின்றி invalidate செய்யலாம்.

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

ஒரு 120Hz ProMotion display-இல் உங்களுக்கு ஒரு frame-க்கு ~8ms உள்ளது; ஒரு பெரிய array-ஐ sort செய்யும் அல்லது ஒரு முழு list-ஐயும் மீண்டும் render செய்யும் ஒரு `body`, frame-களை drop செய்து scrolling-ஐ jank ஆக்குகிறது. உண்மையான SwiftUI app-கள் மெதுவாகும் இடம் அதுவே — மேலும் சில துல்லியமான fix-கள் smoothness-ஐ மீட்டெடுக்கும் இடம் அதுவே — என்பதால் senior interview-கள் view identity மற்றும் observation scope-ஐ ஆராய்கின்றன.

diffing மற்றும் identity எப்படி வேலை செய்கின்றன

observation-ஐ scope செய்தல்

body-ஐ மலிவாக வைத்தல்

சிக்கல்கள்

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

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