@State — यह क्या है, उद्देश्य और SwiftUI में उपयोग

SwiftUI में @State क्या है?

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

@State SwiftUI द्वारा प्रबंधित हीप में एक संग्रहण क्षेत्र बनाता है। यह क्षेत्र स्थायी है — यह व्यू स्ट्रक्ट के बार-बार आरंभीकरण से बचता है, जो प्रत्येक रेंडर पर होते हैं। SwiftUI @State प्रॉपर्टी को किसी विशिष्ट व्यू से बाँधने के लिए व्यू के पहचानकर्ता (पदानुक्रम में उसकी स्थिति से उत्पन्न) का उपयोग करता है। इसके कारण, पैरेंट व्यू अपडेट होने पर स्थिति रीसेट नहीं होती।

एक महत्वपूर्ण सीमा: @State केवल मान प्रकारों (structs, enums, प्रिमिटिव) के लिए है। संदर्भ प्रकारों (क्लासेस) के लिए, @StateObject या @ObservedObject का उपयोग करें। यदि आप @State प्रॉपर्टी को एक क्लास असाइन करते हैं, तो SwiftUI ऑब्जेक्ट के अंदर परिवर्तनों का पता लगाने में सक्षम नहीं होगा — केवल पूर्ण संदर्भ प्रतिस्थापन।

@State अंदरूनी रूप से कैसे काम करता है?

SwiftUI @State को आंतरिक Storage तंत्र के माध्यम से लागू करता है। प्रत्येक @State प्रॉपर्टी को व्यू के एक विशेष स्टोरेज कंटेनर में संग्रहीत एक समर्पित मेमोरी सेल मिलती है। जब wrappedValue में लेखन होता है, SwiftUI didSet के माध्यम से अपने निर्भरता ग्राफ़ को पुनः चित्रित करने की आवश्यकता के बारे में सूचित करता है।

struct ContentView: View {
    @State private var name: String = "User"
    @State private var isLoggedIn: Bool = false

    var body: some View {
        VStack {
            Text("नमस्ते, \(name)")
            Button(isLoggedIn ? "लॉग आउट" : "लॉग इन") {
                isLoggedIn.toggle()
            }
        }
    }
}

उदाहरण में, दो @State प्रॉपर्टीज़ हैं: name (String) और isLoggedIn (Bool)। जब isLoggedIn.toggle() कॉल किया जाता है, SwiftUI ContentView को अपडेट की आवश्यकता के रूप में चिह्नित करता है और अगले रेंडर चक्र में body को पुनः लागू करता है। मुख्य बिंदु: @State प्रॉपर्टीज़ हमेशा private मॉडिफ़ायर के साथ घोषित की जाती हैं — यह संकेत देता है कि स्थिति विशेष रूप से वर्तमान व्यू की है और इसे बाहर से सीधे नहीं बदला जाना चाहिए।

परिवर्तनों का निरीक्षण करने के लिए, SwiftUI Combine से CurrentValueSubject का उपयोग करता है। प्रत्येक @State प्रॉपर्टी एक छिपा हुआ प्रकाशक बनाती है जो प्रत्येक परिवर्तन पर सिस्टम को सूचित करता है। यह SwiftUI को न्यूनतम आवश्यक व्यू सेट को पुनः चित्रित करने की अनुमति देता है, पूर्ण पदानुक्रम अपडेट से बचाता है।

प्रोजेक्ट में @State का उपयोग कब करें

@State सरल स्थानीय स्थितियों के लिए इष्टतम है: खोज में टेक्स्ट फ़ील्ड, मॉडल विंडो के लिए बूलियन फ़्लैग, सेटिंग्स टॉगल, काउंटर, चयनित सूची आइटम। यदि कोई मान केवल एक व्यू और उसके चाइल्ड कंपोनेंट्स (@Binding के माध्यम से) में उपयोग किया जाता है, तो @State सही विकल्प है। उन स्थितियों के लिए जो व्यू बंद होने पर भी बनी रहनी चाहिए (जैसे फ़ॉर्म डेटा), @State तब तक काम करता है जब तक व्यू पदानुक्रम में बना रहता है।

• टेक्स्ट फ़ील्ड — TextField में दर्ज टेक्स्ट संग्रहीत करने के लिए @State
• बूलियन फ़्लैग — मॉडल विंडो और शीट दिखाने/छिपाने के लिए @State
• तत्व चयन — चयनित टैब या पंक्ति को ट्रैक करने के लिए @State
• काउंटर — वृद्धि/कमी के साथ संख्यात्मक मानों के लिए @State
• मध्यवर्ती गणना — व्यू के अंदर परिणामों को कैश करने के लिए @State

@State का उपयोग वैश्विक अनुप्रयोग स्थितियों, नेटवर्क डेटा कैशिंग, या कई स्क्रीन पर उपयोग की जाने वाली वस्तुओं के लिए न करें। @StateObject और @EnvironmentObject इन उद्देश्यों के लिए डिज़ाइन किए गए हैं। साथ ही, @State बड़ी मात्रा में डेटा संग्रहीत करने के लिए उपयुक्त नहीं है — प्रत्येक परिवर्तन पूरे व्यू को पुनः चित्रित करेगा।

@State और @Binding: एक साथ काम करना

@Binding पैरेंट व्यू में @State और चाइल्ड व्यू के बीच एक पुल है जिसे उस स्थिति को संशोधित करने की आवश्यकता होती है। पैरेंट @State घोषित करता है, और चाइल्ड कंपोनेंट $ प्रोजेक्शन के माध्यम से Binding प्राप्त करता है। चाइल्ड व्यू में Binding बदलने से पैरेंट में @State स्वचालित रूप से अपडेट होता है — और इसके विपरीत। यह फीडबैक क्षमता के साथ एकदिशीय डेटा प्रवाह सुनिश्चित करता है।

struct ParentView: View {
    @State private var text: String = ""

    var body: some View {
        ChildView(text: $text)
    }
}

struct ChildView: View {
    @Binding var text: String

    var body: some View {
        TextField("Enter text", text: $text)
    }
}

लिस्टिंग में, ParentView के पास @State text है, और ChildView $text को Binding के रूप में प्राप्त करता है। ChildView के अंदर TextField text: $text के माध्यम से इस Binding से जुड़ता है। जब उपयोगकर्ता TextField में टाइप करता है, Binding के माध्यम से ChildView में मान बदलता है, जो ParentView में @State के अपडेट का कारण बनता है। दोनों व्यू नए मान के साथ पुनः चित्रित होते हैं।

@State के साथ काम करते समय सामान्य गलतियाँ

सबसे आम गलती @State प्रॉपर्टी को क्लास असाइन करना है। यदि आप @State var model = MyClass() लिखते हैं, तो SwiftUI क्लास के अंदर प्रॉपर्टीज़ में परिवर्तनों को ट्रैक नहीं कर पाएगा — केवल ऑब्जेक्ट प्रतिस्थापन। क्लासेस के लिए, हमेशा @StateObject का उपयोग करें। दूसरी सामान्य समस्या private मॉडिफ़ायर के बिना @State घोषित करना है, जो स्थिति एनकैप्सुलेशन के सिद्धांत का उल्लंघन करता है।

बिना $ के सीधे @State पास करना चाइल्ड व्यू में एक और सामान्य गलती है। यदि आप TextField(text: $text) के बजाय TextField(text: text) पास करते हैं, तो चाइल्ड कंपोनेंट को केवल एक स्ट्रिंग मिलती है, Binding नहीं। TextField में टेक्स्ट परिवर्तन पैरेंट के @State के साथ सिंक्रनाइज़ नहीं होंगे। Binding पास करने के लिए हमेशा $ प्रोजेक्शन का उपयोग करें।

तीसरी गलती संबंधित डेटा के लिए एकाधिक @State प्रॉपर्टीज़ है। यदि कई मान तार्किक रूप से एक पूर्ण बनाते हैं (जैसे फ़ॉर्म फ़ील्ड), तो उन्हें एक एकल @State के साथ एक स्ट्रक्ट में संयोजित करें। यह चाइल्ड व्यू में स्थिति पास करना सरल बनाता है और व्यक्तिगत अपडेट ट्रिगर्स की संख्या कम करता है।

SwiftUI में @State के उपयोग के उदाहरण

@State का उपयोग अधिकांश SwiftUI प्रोजेक्ट्स में बुनियादी इंटरैक्टिविटी के लिए किया जाता है। एक लॉगिन फ़ॉर्म उदाहरण पर विचार करें जहाँ @State टेक्स्ट फ़ील्ड और लोडिंग स्थिति का प्रबंधन करता है। यह पैटर्न हर एप्लिकेशन में दिखाई देता है — सरल नोट्स से लेकर जटिल एंटरप्राइज़ समाधानों तक।

struct LoginView: View {
    @State private var email: String = ""
    @State private var password: String = ""
    @State private var isLoading: Bool = false
    @State private var errorMessage: String?

    var body: some View {
        Form {
            TextField("Email", text: $email)
            SecureField("Password", text: $password)
            Button("लॉग इन") {
                login()
            }.disabled(isLoading)
        }
    }

    private func login() {
        isLoading = true
        // नेटवर्क अनुरोध करें
    }
}

उदाहरण में, चार @State प्रॉपर्टीज़ हैं: email और password फ़ॉर्म फ़ील्ड के लिए, isLoading लोडिंग संकेत के लिए, और errorMessage त्रुटियाँ प्रदर्शित करने के लिए। प्रत्येक प्रॉपर्टी स्वतंत्र रूप से अपने इंटरफ़ेस भाग का प्रबंधन करती है। जब isLoading बदलता है, बटन disabled(isLoading) के माध्यम से स्वचालित रूप से अक्षम हो जाता है — बिना मैनुअल UI अपडेट के।