ਤੁਸੀਂ view identity ਅਤੇ diffing ਦੇ ਆਲੇ-ਦੁਆਲੇ SwiftUI performance ਨੂੰ ਕਿਵੇਂ optimize ਕਰਦੇ ਹੋ?

Question

IT Interview Practice · Accepted Answer

ਜਦੋਂ ਵੀ observed state ਬਦਲਦੀ ਹੈ ਤਾਂ SwiftUI `body` ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਉਂਦੀ ਹੈ, ਫਿਰ ਨਵੇਂ view tree ਨੂੰ ਪੁਰਾਣੇ ਨਾਲ **diff** ਕਰਦੀ ਹੈ ਅਤੇ ਸਿਰਫ਼ ਉਹੀ update ਕਰਦੀ ਹੈ ਜੋ ਵੱਖਰਾ ਹੈ। Performance ਸਮੱਸਿਆਵਾਂ ਉਸ diff ਤੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕੰਮ ਕਰਵਾਉਣ ਤੋਂ ਆਉਂਦੀਆਂ ਹਨ: ਅਸਥਿਰ **identity**, ਬਹੁਤ-ਵਿਆਪਕ **observation**, ਅਤੇ ਮਹਿੰਗੀਆਂ `body` computations। ਇਸਨੂੰ identity ਨੂੰ control ਕਰਕੇ, 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` ਜਦੋਂ ਵੀ **ਕੋਈ ਵੀ** `@Published` property ਬਦਲਦੀ ਹੈ ਤਾਂ ਇਸਨੂੰ observe ਕਰਨ ਵਾਲੀ **ਹਰ** view ਨੂੰ re-render ਕਰਦਾ ਹੈ। ਵੱਡੇ models ਨੂੰ ਵੰਡੋ, ਜਾਂ **Observation framework** (`@Observable`, iOS 17+) ਵੱਲ ਜਾਓ, ਜੋ *per-property* reads track ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਕੋਈ 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 ਨੂੰ extract ਕਰੋ ਤਾਂ ਜੋ ਇੱਕ state ਤਬਦੀਲੀ ਇੱਕ **ਛੋਟੀ** view ਨੂੰ re-render ਕਰੇ, ਨਾ ਕਿ ਪੂਰੀ screen ਨੂੰ।
- ਵੱਡੇ collections ਲਈ `LazyVStack`/`List` ਵਰਤੋ ਤਾਂ ਜੋ off-screen rows ਨਾ ਬਣਨ।
- ਸਥਿਰ subtrees 'ਤੇ diffing ਨੂੰ short-circuit ਕਰਨ ਲਈ `.equatable()` ਜਾਂ `EquatableView` ਜੋੜੋ।

## ਧਿਆਨ ਰੱਖਣ ਯੋਗ ਗੱਲਾਂ

- `AnyView` type identity ਮਿਟਾ ਦਿੰਦਾ ਹੈ ਅਤੇ structural diffing ਨੂੰ ਹਰਾ ਦਿੰਦਾ ਹੈ — hot paths ਵਿੱਚ ਇਸ ਤੋਂ ਬਚੋ।
- ਹਰ render 'ਤੇ ਨਵਾਂ closure/array literal pass ਕਰਨਾ child views ਨੂੰ ਬੇਲੋੜਾ invalidate ਕਰ ਸਕਦਾ ਹੈ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

120Hz ProMotion display 'ਤੇ ਤੁਹਾਡੇ ਕੋਲ ਪ੍ਰਤੀ frame ~8ms ਹੁੰਦੇ ਹਨ; ਇੱਕ `body` ਜੋ ਵੱਡੀ array sort ਕਰਦਾ ਹੈ ਜਾਂ ਪੂਰੀ list ਨੂੰ re-render ਕਰਦਾ ਹੈ, frames drop ਕਰਦਾ ਹੈ ਅਤੇ scrolling ਨੂੰ jank ਕਰਦਾ ਹੈ। Senior interviews view identity ਅਤੇ observation scope ਦੀ ਪੜਤਾਲ ਕਰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਉੱਥੇ ਹੀ ਅਸਲ SwiftUI apps ਹੌਲੀ ਹੁੰਦੀਆਂ ਹਨ — ਅਤੇ ਜਿੱਥੇ ਕੁਝ ਸਟੀਕ fixes smoothness ਵਾਪਸ ਲੈ ਆਉਂਦੇ ਹਨ।

diffing ਅਤੇ identity ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

Observation ਨੂੰ scope ਕਰਨਾ

body ਨੂੰ ਸਸਤਾ ਰੱਖਣਾ

ਧਿਆਨ ਰੱਖਣ ਯੋਗ ਗੱਲਾਂ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ