SwiftUI என்றால் என்ன, declarative view-கள் எப்படி வேலை செய்கின்றன?

Question

IT Interview Practice · Accepted Answer

SwiftUI என்பது Apple-இன் **declarative** UI framework: கொடுக்கப்பட்ட ஒரு state-க்கு UI எப்படித் தோன்ற வேண்டும் என்பதை நீங்கள் விவரிக்கிறீர்கள், அதை எப்படி render மற்றும் update செய்வது என்பதை framework கண்டறிகிறது. UIKit-இல் போல் நீங்கள் இனி view-களை கைமுறையாக mutate செய்வதில்லை — நீங்கள் state-ஐ மாற்றுகிறீர்கள், UI தானாகவே மீண்டும் render ஆகிறது.

## இது எப்படி வேலை செய்கிறது

ஒரு view `View` protocol-ஐ conform செய்கிறது மற்றும் அதன் உள்ளடக்கத்தை ஒரு computed `body` property-லிருந்து return செய்கிறது. `body` என்பது view-இன் property-களின் ஒரு pure function.

```swift
struct Counter: View {
    @State private var count = 0          // source of truth

var body: some View {                 // opaque return type
        VStack(spacing: 12) {
            Text("Count: \(count)")       // re-reads count each render
            Button("Increment") {
                count += 1                 // mutating state triggers re-render
            }
        }
    }
}
```

## some View

`some View` என்பது ஒரு **opaque return type**: இது "compiler-ஆல் தீர்மானிக்கப்படும் ஏதோ ஒரு குறிப்பிட்ட concrete `View` type" என்று பொருள். சிக்கலான nested view type-களை அவற்றை முழுமையாக எழுதாமல் return செய்ய இது உங்களை அனுமதிக்கிறது, அதே நேரத்தில் performance-க்காக type-ஐ static-ஆக வைத்திருக்கிறது.

## Declarative vs imperative

- **UIKit (imperative):** `label.text = "Count: \(count)"` — ஒவ்வொரு மாற்றத்தையும் நீங்கள் push செய்கிறீர்கள்.
- **SwiftUI (declarative):** `Text("Count: \(count)")` — உறவை ஒருமுறை declare செய்கிறீர்கள்; `count` மாறும்போது framework `body`-ஐ மீண்டும் invoke செய்து முடிவை diff செய்கிறது.

View-கள் இலகுவான **struct**-கள், ஒவ்வொரு state மாற்றத்திலும் உருவாக்கவும் தூக்கியெறியவும் மலிவானவை. SwiftUI அடிப்படை render tree-ஐ வைத்திருந்து வேறுபாடுகளை மட்டுமே பயன்படுத்துகிறது.

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

declarative model, UI data-வுடன் sync ஆகாமல் விலகிச் செல்லும் UIKit bug-களின் ஒரு முழு வகையையும் அகற்றுகிறது. `body` ஒவ்வொரு state மாற்றத்திலும் மீண்டும் இயங்குகிறது என்பதைப் புரிந்துகொள்வது — மற்றும் அது ஒரு மலிவான pure function-ஆகவே இருக்க வேண்டும் — state முதல் performance வரை SwiftUI-இல் மற்ற அனைத்திற்கும் அடித்தளமாகும்.

இது எப்படி வேலை செய்கிறது

some View

Declarative vs imperative

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

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