SwiftUI — मुख्य अवधारणाएँ: View, State और Data Flow

SwiftUI क्या है?

SwiftUI — Apple का डिक्लेरेटिव UI फ्रेमवर्क, जो UIKit से मौलिक रूप से भिन्न है। कंट्रोलर, व्यू बनाने और उनके जीवनचक्र को मैन्युअल रूप से प्रबंधित करने के बजाय, डेवलपर इंटरफ़ेस को घोषणाओं के रूप में वर्णित करता है: स्क्रीन पर क्या होना चाहिए, न कि इसे कैसे बनाना है। SwiftUI प्रतिक्रियाशीलता के सिद्धांत पर आधारित है: इंटरफ़ेस स्थिति का एक फ़ंक्शन है। जब स्थिति बदलती है, SwiftUI स्वचालित रूप से सभी आश्रित Views के body की पुनर्गणना करता है और स्क्रीन के केवल बदले हुए भागों को अपडेट करता है। SwiftUI iOS 13+, iPadOS 13+, macOS 10.15+, watchOS 6+, tvOS 13+ और visionOS 1+ पर उपलब्ध है। SwiftUI कोड क्रॉस-प्लेटफ़ॉर्म है: एक फ़ाइल iPhone, iPad, Mac और Apple Watch पर न्यूनतम प्लेटफ़ॉर्म अनुकूलन के साथ काम करती है। Apple WWDC Session 101 (2024) के अनुसार, SwiftUI App Store के 90% से अधिक मानक UI पैटर्न को कवर करता है।

SwiftUI बनाम UIKit

UIKit — इम्पेरेटिव फ्रेमवर्क (2008): डेवलपर UIViewController बनाता है, viewDidLoad में subviews कॉन्फ़िगर करता है, UITableView के लिए delegate/datasource लागू करता है और reloadData या setNeedsLayout के माध्यम से स्क्रीन अपडेट करता है। SwiftUI कंट्रोलर को सरल View संरचनाओं, डेलीगेट को bindings और onChange, Auto Layout को HStack/VStack/ZStack और मॉडिफ़ायर (padding, frame, offset) से बदलता है। UIKit को ARC के माध्यम से मैन्युअल मेमोरी प्रबंधन की आवश्यकता होती है; SwiftUI संरचनाओं का उपयोग करता है जिन्हें संदर्भ गणना की आवश्यकता नहीं होती। SwiftUI का प्रदर्शन UIKit के बराबर है: फ्रेमवर्क न्यूनतम परिवर्तन सेट के लिए diffing एल्गोरिदम का उपयोग करता है। IT Sectr में, SwiftUI का उपयोग iOS 17+ लक्ष्य वाले नए प्रोजेक्ट्स के लिए किया जाता है; iOS 14–15 समर्थन वाले प्रोजेक्ट्स को सीमित SwiftUI संगतता के कारण UIKit की आवश्यकता होती है।

SwiftUI डिक्लेरेटिव सिंटैक्स

SwiftUI में, इंटरफ़ेस ViewBuilder — एक result builder के माध्यम से वर्णित किया जाता है जो Views के सेट को tuple या Group में बदलता है। मॉडिफ़ायर (.padding(), .font(), .foregroundColor()) मूल ऑब्जेक्ट को बदलने के बजाय संशोधित सेटिंग्स के साथ नई Views बनाते हैं। प्रत्येक मॉडिफ़ायर एक नई View लौटाता है, जिससे चेनिंग संभव होती है। ViewBuilder if/else, switch, ForEach का समर्थन करता है — बिना अलग कंट्रोलर के सशर्त और चक्रीय रेंडरिंग। SwiftUI में View एक value type (struct) है, जो पूर्वानुमेय व्यवहार सुनिश्चित करता है और race conditions को समाप्त करता है।

View प्रोटोकॉल और computed property body

View — एक प्रोटोकॉल जिसमें एकमात्र आवश्यकता है: some View प्रकार की computed property body। View का पालन करने वाली प्रत्येक संरचना body में स्क्रीन का अपना भाग वर्णित करती है। some View प्रकार एक अपारदर्शी रिटर्न प्रकार है जो लौटाई गई View के ठोस प्रकार को छुपाता है (VStack, HStack, ZStack, Text, Image आदि का स्टैकिंग)। Swift कंपाइलर कंपाइल समय पर ठोस प्रकार का अनुमान लगाता है, टाइप इरेज़र के बिना सीधी कॉल का प्रदर्शन बनाए रखता है।

import SwiftUI

struct GreetingView: View {
    var name: String
    
    var body: some View {
        VStack(spacing: 12) {
            Text("नमस्ते, \(name)!")
                .font(.largeTitle)
                .foregroundColor(.primary)
            
            Text("SwiftUI में आपका स्वागत है")
                .font(.body)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
                .fill(.ultraThinMaterial)
        )
    }
}

GreetingView संरचना एक name पैरामीटर लेती है और एक ऊर्ध्वाधर स्टैक में दो टेक्स्ट ब्लॉक प्रदर्शित करती है। मॉडिफ़ायर .font, .foregroundColor, .padding और .background स्वरूप कॉन्फ़िगर करते हैं। SwiftUI हर बार इनपुट पैरामीटर (name) बदलने पर body को कॉल करता है — पुनः चित्रण केवल बदले हुए भागों के लिए होता है। उदाहरण SwiftUI में निर्मित मूल blur पृष्ठभूमि RoundedRectangle का .ultraThinMaterial के साथ उपयोग करता है।

@State: SwiftUI में स्थानीय स्थिति

@State — एक property wrapper जो एकल View से संबंधित स्थानीय स्थिति घोषित करता है। SwiftUI State मेमोरी को स्वचालित रूप से प्रबंधित करता है: जब मान बदलता है, body पुनः चित्रित होता है, लेकिन केवल उन Views के लिए जो उस State का उपयोग करती हैं। State सरल प्रकारों (String, Int, Bool, enum) के लिए source of truth है। जटिल डेटा मॉडल के लिए @State का उपयोग न करें — इसके बजाय @StateObject और @ObservedObject का उपयोग करें। State प्राइवेट होना चाहिए और View के भीतर ही संग्रहीत होना चाहिए, घटकों के बीच पारित नहीं होना चाहिए।

import SwiftUI

struct CounterView: View {
    @State private var count = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("गणना: \(count)")
                .font(.system(size: 48, weight: .bold))
            
            Button(action: { count += 1 }) {
                Label("बढ़ाएँ", systemImage: "plus.circle")
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

प्रारंभिक count मान = 0। प्रत्येक बटन दबाने पर count बढ़ता है; SwiftUI पूरे CounterView (सभी Views) को स्वचालित रूप से पुनः चित्रित करता है। UIKit में, समान परिदृश्य के लिए IBOutlet, IBAction और मैन्युअल label.text अपडेट की आवश्यकता होती। @State सुनिश्चित करता है कि View केवल विशिष्ट State बदलने पर पुनः चित्रित हो — SwiftUI का diffing एल्गोरिदम ट्री में न्यूनतम परिवर्तन ढूँढता है।

@Binding: Views के बीच दो-तरफ़ा संचार

@Binding — एक property wrapper जो View और उस डेटा के बीच दो-तरफ़ा संबंध बनाता है जिसका View स्वामी नहीं है। Binding, State (या अन्य source of truth) का एक संदर्भ है, जो चाइल्ड View को पैरेंट में संग्रहीत मान को पढ़ने और बदलने की अनुमति देता है। Binding को $ उपसर्ग से दर्शाया जाता है: $count चाइल्ड View को Binding<Int> पास करता है। Binding के बिना, चाइल्ड View पैरेंट के डेटा को बदल नहीं सकता — केवल पढ़ सकता है।

import SwiftUI

struct StepperControl: View {
    @Binding var value: Int
    let range: ClosedRange<Int>
    
    var body: some View {
        HStack {
            Button(action: { if value > range.lowerBound { value -= 1 } }) {
                Image(systemName: "minus.circle")
            }
            Text("\(value)")
                .frame(minWidth: 40)
            Button(action: { if value < range.upperBound { value += 1 } }) {
                Image(systemName: "plus.circle")
            }
        }
    }
}

struct ParentView: View {
    @State private var quantity = 5
    
    var body: some View {
        StepperControl(value: $quantity, range: 1...10)
    }
}

ParentView State quantity का स्वामी है और $quantity के माध्यम से Binding पास करता है। StepperControl मान बदल सकता है, और पैरेंट में quantity स्वचालित रूप से सिंक हो जाती है। Binding डेटा की प्रतिलिपि नहीं है, बल्कि source of truth का पुल है। कस्टम कंट्रोल, एडिटर और पुन: प्रयोज्य घटकों के लिए @Binding का उपयोग करें जिन्हें पैरेंट के डेटा को बदलने की आवश्यकता होती है।

@ObservedObject और @StateObject: बाहरी डेटा मॉडल

@StateObject — ObservableObject का पालन करने वाले क्लास के इंस्टेंस को बनाने और उसका स्वामित्व लेने के लिए property wrapper। View एक बार जीवनचक्र में ऑब्जेक्ट बनाती है और इसके @Published गुण बदलने पर पुनः चित्रित होती है। @ObservedObject — समान wrapper, लेकिन View ऑब्जेक्ट का स्वामी नहीं है — ऑब्जेक्ट View के बाहर बनाया और संग्रहीत किया जाता है (इनिशियलाइज़र के माध्यम से पास किया जाता है)। Apple View पदानुक्रम में source of truth के लिए @StateObject और निर्भरता इंजेक्शन के लिए @ObservedObject की अनुशंसा करता है।

import SwiftUI
import Combine

class UserSettings: ObservableObject {
    @Published var username: String = "Guest"
    @Published var isLoggedIn = false
}

struct ProfileView: View {
    @StateObject private var settings = UserSettings()
    
    var body: some View {
        VStack {
            TextField("Username", text: $settings.username)
                .textFieldStyle(.roundedBorder)
            
            Toggle("Logged In", isOn: $settings.isLoggedIn)
            
            if settings.isLoggedIn {
                Text("\(settings.username), आपका स्वागत है!")
                    .font(.headline)
            }
        }
        .padding()
    }
}

UserSettings — दो @Published गुणों वाला ObservableObject। ProfileView @StateObject के माध्यम से ऑब्जेक्ट का स्वामी है। username या isLoggedIn में परिवर्तन स्वचालित रूप से ProfileView को पुनः चित्रित करते हैं। @Published SwiftUI को परिवर्तनों के बारे में सूचित करने के लिए Combine Publisher का उपयोग करता है। चाइल्ड Views में settings पास करने के लिए @ObservedObject का उपयोग करें:

SwiftUI में Data Flow: पूरी तस्वीर

Apple SwiftUI में Data Flow के चार स्तर परिभाषित करता है: @State (स्थानीय, value type), @Binding (दो-तरफ़ा), @StateObject/@ObservedObject (ObservableObject के साथ reference type), @EnvironmentObject (वैश्विक, पर्यावरण के माध्यम से इंजेक्ट)। EnvironmentObject इनिशियलाइज़र में स्पष्ट पासिंग के बिना पूरे View पदानुक्रम में डेटा पास करने की अनुमति देता है। इसके अतिरिक्त, @AppStorage UserDefaults के साथ काम करता है, @SceneStorage सीन स्थिति के साथ, @FetchRequest Core Data के साथ। Data Flow स्तर का चुनाव एप्लिकेशन आर्किटेक्चर निर्धारित करता है: सरल स्क्रीन State/Binding का उपयोग करती हैं, मॉड्यूलर ObservedObject का, बड़े पैमाने पर EnvironmentObject + Redux-जैसे समाधान (TCA, Composable Architecture) का।