view identity आणि diffing च्या भोवती SwiftUI performance तुम्ही कसे optimize करता?

Question

IT Interview Practice · Accepted Answer

observed state बदलल्यावर SwiftUI `body` पुन्हा चालवते, नंतर नव्या view tree ची जुन्या tree शी **diff** काढते आणि फक्त जे वेगळे असते तेच update करते. Performance समस्या त्या diff ला जास्त काम करायला लावण्यातून येतात: अस्थिर **identity**, अति-व्यापक **observation**, आणि महागडी `body` computations. Identity नियंत्रित करून, state scope करून, आणि `body` स्वस्त ठेवून हे दुरुस्त करा.

## Diffing आणि identity कसे कार्य करतात

SwiftUI renders दरम्यान views ना **identity** ने जुळवते. lists साठी हे `id` असते; id अस्थिर असल्यास, SwiftUI view update करण्याऐवजी टाकून देते आणि पुन्हा बांधते (state आणि animations गमावते).

```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` त्याला observe करणाऱ्या **प्रत्येक** view ला जेव्हा **कोणतीही** `@Published` property बदलते तेव्हा re-render करते. मोठी models विभागा, किंवा **Observation framework** (`@Observable`, iOS 17+) कडे जा, जे *per-property* reads ट्रॅक करते त्यामुळे view फक्त तेव्हाच re-render होते जेव्हा त्याने प्रत्यक्ष वापरलेली property बदलते.

```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
```

- subviews काढा जेणेकरून एक state बदल संपूर्ण screen नव्हे तर एक **लहान** view re-render करेल.
- मोठ्या collections साठी `LazyVStack`/`List` वापरा जेणेकरून off-screen rows बांधल्या जाणार नाहीत.
- स्थिर subtrees वर diffing short-circuit करण्यासाठी `.equatable()` किंवा `EquatableView` जोडा.

## अडचणी

- `AnyView` type identity पुसते आणि structural diffing हरवते — hot paths मध्ये ते टाळा.
- प्रत्येक render वर नवीन closure/array literal पास केल्याने child views अनावश्यकपणे invalidate होऊ शकतात.

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

120Hz ProMotion display वर तुम्हाला प्रति frame ~8ms असतात; मोठी array sort करणारी किंवा संपूर्ण list re-render करणारी `body` frames टाकते आणि scrolling janky करते. Senior मुलाखती view identity आणि observation scope तपासतात कारण तिथेच real SwiftUI apps धीम्या होतात — आणि तिथेच काही अचूक दुरुस्त्या smoothness परत आणतात.

Diffing आणि identity कसे कार्य करतात

Observation scope करणे

body स्वस्त ठेवणे

अडचणी

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

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