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` computation. Identity ને control કરીને, state ને scope કરીને, અને `body` ને સસ્તું રાખીને તેને ઠીક કરો.

## 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 ને ફરી render કરે છે. મોટા model ને વિભાજિત કરો, અથવા **Observation framework** (`@Observable`, iOS 17+) તરફ જાઓ, જે *per-property* read track કરે છે જેથી view ને માત્ર ત્યારે ફરી 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
```

- Subview ને extract કરો જેથી state ફેરફાર આખા screen ને નહીં પણ એક **નાના** view ને ફરી render કરે.
- મોટા collection માટે `LazyVStack`/`List` વાપરો જેથી off-screen row ન બને.
- સ્થિર subtree પર diffing ને short-circuit કરવા `.equatable()` અથવા `EquatableView` ઉમેરો.

## મુશ્કેલીઓ

- `AnyView` type identity ને erase કરે છે અને structural diffing ને હરાવે છે — hot path માં તેને ટાળો.
- દરેક render પર નવો closure/array literal પસાર કરવાથી child view બિનજરૂરી રીતે invalidate થઈ શકે છે.

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

120Hz ProMotion display પર તમારી પાસે frame દીઠ ~8ms છે; મોટા array ને sort કરતું અથવા આખા list ને ફરી render કરતું `body` frame drop કરે છે અને scroll માં jank લાવે છે. Senior interview view identity અને observation scope ને ચકાસે છે કારણ કે ત્યાં જ વાસ્તવિક SwiftUI app ધીમા પડે છે — અને ત્યાં જ થોડા ચોક્કસ fix સ્મૂધનેસ પાછી લાવે છે.

diffing અને identity કેવી રીતે કામ કરે છે

observation ને scope કરવું

body ને સસ્તું રાખવું

મુશ્કેલીઓ

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

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