SwiftUI: यह क्या है, प्रमुख अवधारणाएँ और View Protocol

SwiftUI क्या है?

SwiftUI एक घोषणात्मक फ्रेमवर्क है जिसे Apple ने 2019 में नए प्रोजेक्ट्स में UIKit को बदलने के लिए पेश किया था। मैन्युअल रूप से UIView इंस्टेंस बनाने और उन्हें पदानुक्रम में जोड़ने के बजाय, डेवलपर View प्रोटोकॉल का पालन करने वाली संरचनाओं के माध्यम से इंटरफ़ेस का वर्णन करता है। SwiftUI स्वचालित रूप से वर्तमान और नई स्थिति के बीच अंतर की गणना करता है और अपने स्वयं के रेंडरिंग इंजन का उपयोग करके केवल बदले हुए हिस्सों को पुनः रेंडर करता है।

फ्रेमवर्क Swift में वैल्यू सिमैंटिक्स (संरचनाएँ, क्लास नहीं) का उपयोग करके लिखा गया है, जो UI घटकों को हल्का और थ्रेड-सेफ बनाता है। UIKit के विपरीत, जहाँ Objective-C रनटाइम के कारण UIViewController 200+ बाइट का हो सकता है, SwiftUI View कुछ बाइट्स की एक साधारण संरचना है। यह विशेष रूप से watchOS के लिए इसकी सीमित मेमोरी के साथ महत्वपूर्ण है।

SwiftUI क्रॉस-प्लेटफ़ॉर्म

एक ही View विवरण iPhone, iPad, Mac, Apple Watch, Apple TV और Apple Vision Pro पर काम करता है। SwiftUI इंटरफ़ेस को प्लेटफ़ॉर्म के अनुसार अनुकूलित करता है: iOS पर टच जेस्चर, macOS पर कीबोर्ड कॉम्बिनेशन, watchOS पर Digital Crown स्क्रॉलिंग। यह कई Apple प्लेटफार्मों पर ऐप जारी करने वाली कंपनियों के लिए डेवलपमेंट समय कम करता है, लेकिन प्रत्येक प्लेटफ़ॉर्म के विशिष्ट तत्वों के लिए अतिरिक्त कॉन्फ़िगरेशन की आवश्यकता होती है।

View Protocol और व्यू का मुख्य भाग

SwiftUI में, प्रत्येक स्क्रीन एक संरचना है जो View प्रोटोकॉल को एक आवश्यकता के साथ लागू करती है: some View प्रकार की एक गणना की गई प्रॉपर्टी body। some कीवर्ड (अपारदर्शी प्रकार) व्यू के ठोस प्रकार को छिपाता है, जिससे SwiftUI रेंडरिंग को अनुकूलित कर सकता है। body के अंदर, डेवलपर ViewBuilder का उपयोग करके तैयार घटकों — Text, Image, Button, List — को जोड़ता है, जो कई व्यू को एक में इकट्ठा करता है।

struct GreetingView: View {
    let name: String

    var var body: some View {
        VStack {
            Text("नमस्ते, \(name)!")
                .font(.title)
                .foregroundColor(.blue)
            Image(systemName: "hand.wave")
                .imageScale(.large)
        }
        .padding()
    }
}

उदाहरण में, VStack (ऊर्ध्वाधर स्टैक) में Text और Image है। name मान संरचना के इनिशियलाइज़र के माध्यम से पास किया जाता है — इस प्रकार SwiftUI में बाहरी DI कंटेनरों के बिना DI (डिपेंडेंसी इंजेक्शन) काम करता है। प्रत्येक मॉडिफ़ायर मूल को बदले बिना, लागू परिवर्तन के साथ एक नया व्यू लौटाता है। यह वैल्यू टाइप्स की अपरिवर्तनीयता के कारण संभव है।

ViewBuilder और शर्तें

ViewBuilder एक रिज़ल्ट बिल्डर है जो @resultBuilder से एनोटेटेड है, जो 10 व्यू को एक में इकट्ठा करता है। body के अंदर बिना अतिरिक्त रैपर के if/else, switch और ForEach का उपयोग किया जा सकता है। ForEach Identifiable तत्वों के साथ काम करता है — सम्मिलन/हटाने पर सही एनिमेशन के लिए प्रत्येक व्यू को एक अद्वितीय id दी जाती है।

स्थिति प्रबंधन: @State, @Binding, @ObservedObject

SwiftUI में, स्थिति यह निर्धारित करती है कि स्क्रीन पर कौन सी सामग्री प्रदर्शित होती है। जब स्थिति बदलती है, SwiftUI निर्भर व्यू के body को पुनः बनाता है और डिफ़ अल्गोरिथम का उपयोग करके परिणाम की तुलना पिछले से करता है। स्थिति को संग्रहीत करने के लिए प्रॉपर्टी रैपर का उपयोग किया जाता है — प्रत्येक अपने विशिष्ट कार्य को हल करता है: स्थानीय स्थिति, चाइल्ड व्यू के साथ कनेक्शन, या बाहरी डेटा मॉडल।

struct CounterView: View {
    @State private var count = 0

    var var body: some View {
        VStack {
            Text("काउंटर: \(count)")
            Button("बढ़ाएँ") {
                count += 1
            }
        }
    }
}

class UserViewModel: ObservableObject {
    @Published var name = ""
    @Published var age = 0
}

@State View संरचना के अंदर एक स्थानीय सरल मान (Int, String, Bool) संग्रहीत करता है। SwiftUI मेमोरी को संरचना से एक अलग स्टोरेज में ले जाता है — इसलिए @State वाली प्रॉपर्टी को बदला जा सकता है, भले ही View वैल्यू टाइप हो। @ObservableObject @Published प्रॉपर्टी वाली क्लास के लिए है, जिनके परिवर्तन SwiftUI को पुनः रेंडर करने की आवश्यकता के बारे में स्वचालित रूप से सूचित करते हैं।

@Binding और पैरेंट-चाइल्ड कनेक्शन

@Binding पैरेंट व्यू में स्थित डेटा स्रोत के साथ दो-तरफ़ा कनेक्शन बनाता है। पैरेंट $variable (प्रोजेक्टेड वैल्यू) पास करता है, और चाइल्ड बाइंडिंग के माध्यम से मान पढ़ता और लिखता है। यह पैरेंट में स्थिति रखते हुए टेक्स्ट इनपुट या टॉगल को एक अलग घटक में ले जाने की अनुमति देता है। @Binding के बिना, प्रत्येक परिवर्तन को नया मान ऊपर भेजने के लिए कॉलबैक क्लोज़र की आवश्यकता होगी।

SwiftUI में नेविगेशन: NavigationStack और NavigationLink

iOS 16 से पहले, SwiftUI में नेविगेशन NavigationView पर बनाया गया था — iPad पर जटिल व्यवहार (स्प्लिट व्यू, डबल कॉलम) वाला एक पुराना API। iOS 16 से शुरू करके, Apple NavigationStack की सिफारिश करता है — टाइप-सेफ रूट के साथ एक सरलीकृत विकल्प। डेवलपर संभावित रूट का एक एनम परिभाषित करता है, और NavigationStack डीप लिंक और रूट पर लौटने के समर्थन के साथ स्वचालित रूप से स्क्रीन स्टैक का प्रबंधन करता है।

enum Route: Hashable {
    case detail(id: Int)
    case settings
}

struct ContentView: View {
    var var body: some View {
        NavigationStack {
            List {
                NavigationLink("विवरण स्क्रीन",
                               value: Route.detail(id: 42))
                NavigationLink("सेटिंग्स",
                               value: Route.settings)
            }
            .navigationDestination(for: Route.self) { route in
                switch route {
                case .detail(let id): DetailView(id: id)
                case .settings: SettingsView()
                }
            }
        }
    }
}

Hashable के अनुरूप रूट पैरामीटर पास करने के लिए किसी भी डेटा प्रकार का उपयोग करने की अनुमति देते हैं। navigationDestination(for:destination:) रूट प्रकार को लक्ष्य व्यू से जोड़ता है। UIKit नेविगेशन पर लाभ यह है कि नया रूट जोड़ते समय पुनः रेंडरिंग की आवश्यकता नहीं होती है: बस एनम में एक केस और स्विच में एक हैंडलर जोड़ें। डीप लिंक NavigationStack पर processDeepLink के माध्यम से संभाले जाते हैं।

प्रोग्रामेटिक नेविगेशन

प्रोग्रामेटिक नेविगेशन (लॉगिन, टाइमर या सर्वर रिस्पॉन्स के बाद) के लिए, NavigationLink इनिशियलाइज़र के साथ @State का उपयोग किया जाता है: NavigationLink(isActive: $isActive)। जब isActive = true होता है, तो उपयोगकर्ता के स्पर्श के बिना ट्रांज़िशन होता है। एक विकल्प NavigationStack में $path ऐरे को बाइंड करना है: $path.append(Route.detail(id: 1))।

View Modifier — उपस्थिति अनुकूलन

Modifier एक विधि है जो व्यू की एक संशोधित प्रति लौटाती है। UIKit के विपरीत, जहाँ प्रॉपर्टी कॉन्फ़िगरेशन मौजूदा व्यू को बदलकर किया जाता है, SwiftUI लागू परिवर्तन के साथ एक नया मान बनाता है। मॉडिफ़ायर चेनिंग अनुक्रमिक परिवर्तनों से अंतिम इंटरफ़ेस बनाती है: फ़ॉन्ट → पैडिंग → रंग → छाया → जेस्चर।

Apple 200 से अधिक बिल्ट-इन मॉडिफ़ायर प्रदान करता है। सबसे आम: .font(), .foregroundColor(), .padding(), .background(), .cornerRadius(), .shadow(), .opacity(), .offset()। मॉडिफ़ायर का क्रम मायने रखता है: .padding() से पहले .background() पैडिंग वाले क्षेत्र को भरता है, बाद में — केवल आंतरिक क्षेत्र। कस्टम मॉडिफ़ायर ViewModifier प्रोटोकॉल के माध्यम से बनाए जाते हैं।

सशर्त मॉडिफ़ायर और एनिमेशन

मॉडिफ़ायर को टर्नरी ऑपरेटर के माध्यम से सशर्त रूप से लागू किया जा सकता है: .foregroundColor(isError ? .red : .primary)। एनिमेशन के लिए .animation(.easeInOut, value: state) का उपयोग किया जाता है — एनिमेशन मॉडिफ़ायर एक विशिष्ट स्थिति प्रॉपर्टी से बंधा होता है। जब यह प्रॉपर्टी बदलती है, SwiftIO पुराने और नए मान के बीच संक्रमण को एनिमेट करता है। एनिमेशन opacity, offset, scale, rotation, आकार और रंग के साथ काम करता है — प्रत्येक प्रॉपर्टी का एक संबंधित AnimatableParameter है।

कस्टम एनिमेशन के लिए, .transition (प्रकट/गायब होना) और .matchedGeometryEffect (दो कंटेनरों के बीच एक तत्व का सहज संक्रमण) उपलब्ध हैं। बाद वाला सूचियों में हीरो एनिमेशन के लिए उपयोग किया जाता है: सूची सेल में एक आइकन आसानी से विस्तृत स्क्रीन पर एक बड़ी छवि में बदल जाता है।

SwiftUI बनाम UIKit: दृष्टिकोणों की तुलना

SwiftUI और UIKit के बीच चुनाव iOS डेवलपर की पहली दुविधाओं में से एक है। दोनों फ्रेमवर्क Apple द्वारा समर्थित हैं लेकिन इंटरफ़ेस निर्माण की समस्या को मौलिक रूप से अलग तरीकों से हल करते हैं: SwiftUI घोषणात्मक रूप से, UIKit अनिवार्य रूप से। अंतर स्थिति प्रबंधन, नेविगेशन, प्रदर्शन और संगतता में प्रकट होता है।

न्यूनतम iOS 17 संस्करण वाले नए प्रोजेक्ट्स के लिए, Apple SwiftUI को प्राथमिक फ्रेमवर्क के रूप में अनुशंसित करता है। UIKit रेंडरिंग पर सूक्ष्म नियंत्रण (कस्टम UICollectionViewLayout, जटिल CAAnimation दृश्य) या iOS 12–14 के समर्थन की आवश्यकता वाले इंटरफ़ेस के लिए आवश्यक बना हुआ है। कई प्रोजेक्ट एक हाइब्रिड दृष्टिकोण का उपयोग करते हैं: UIHostingController के माध्यम से SwiftUI को UIKit ऐप में एम्बेड किया जाता है, और UIViewRepresentable SwiftUI पदानुक्रम के अंदर UIKit घटकों का उपयोग करने की अनुमति देता है।