Property Wrapper: मुख्य अवधारणाएँ, सिंटैक्स और SwiftUI में उदाहरण

Property Wrapper क्या है?

Property Wrapper — Swift भाषा की एक संरचना है, जो संस्करण 5.1 में शुरू हुई, जो प्रॉपर्टी एक्सेस तर्क को एक अलग प्रकार में एनकैप्सुलेट करने की अनुमति देती है। हर क्लास में बार-बार गेटर और सेटर लिखने के बजाय, डेवलपर एक बार रैपर घोषित करता है और इसे प्रकार से पहले @ एनोटेशन के माध्यम से लागू करता है। Swift स्वचालित रूप से प्रॉपर्टी को निर्दिष्ट प्रकार में लपेटता है, पढ़ने और लिखने पर इसके wrappedValue और projectedValue विधियों को कॉल करता है। Apple (WWDC 2019) के अनुसार, Property Wrappers SwiftUI के लिए एक मुख्य अमूर्तता बन गए।

प्रॉपर्टी रैपर @propertyWrapper विशेषता वाली एक संरचना या क्लास है। अंदर, ऐसे प्रकार को wrappedValue प्रॉपर्टी लागू करनी चाहिए, जो वास्तविक मान लौटाती और सेट करती है। Swift कंपाइलर मूल प्रॉपर्टी तक पहुँच को wrappedValue कॉल से बदल देता है, कॉल करने वाले कोड से पूरी तरह से कार्यान्वयन छिपाता है। अतिरिक्त रूप से, projectedValue को परिभाषित किया जा सकता है — $ प्रतीक के माध्यम से सुलभ एक प्रोजेक्शन।

Property Wrappers का लाभ तर्क के पुन: उपयोग में निहित है। उदाहरण के लिए, आप ईमेल सत्यापन, मान कैशिंग या स्टोरेज सिंक्रनाइज़ेशन के लिए रैपर बना सकते हैं — और इसे प्रोजेक्ट की किसी भी प्रॉपर्टी पर लागू कर सकते हैं। SwiftUI में, यह अवधारणा हर जगह उपयोग की जाती है: स्थिति प्रबंधन का प्रत्येक तंत्र एक अलग Property Wrapper के रूप में लागू किया गया है।

Swift में Property Wrapper कैसे काम करता है?

@WrapperType var value: T एनोटेशन के साथ प्रॉपर्टी घोषित करते समय, Swift कंपाइलर कोड को रूपांतरित करता है। यह WrapperType का एक इंस्टेंस बनाता है और wrappedValue के माध्यम से प्रॉपर्टी तक पहुँच उत्पन्न करता है। स्रोत कोड let x = value, let x = _value.wrappedValue में बदल जाता है, और value = newValue, _value.wrappedValue = newValue में। यह परिवर्तन कंपाइल समय पर होता है, बिना रनटाइम ओवरहेड के।

@propertyWrapper
struct Capitalized {
    private var text: String

    var wrappedValue: String {
        get { text }
        set { text = newValue.capitalized }
    }

    init(initialValue: String) {
        text = initialValue.capitalized
    }
}

लिस्टिंग में Capitalized रैपर दिखाया गया है, जो स्ट्रिंग को स्वचालित रूप से कैपिटलाइज़्ड फॉर्मेट में बदलता है। मान निर्दिष्ट करते समय, सेटर सेव करने से पहले capitalized को कॉल करता है। अब @Capitalized एनोटेशन वाली कोई भी प्रॉपर्टी केवल सही ढंग से फॉर्मेट किया गया टेक्स्ट संग्रहीत करेगी। यह दृष्टिकोण सत्यापन और फ़ॉर्मेटिंग कोड के दोहराव को पूरी तरह से समाप्त करता है।

प्रोजेक्शन (projectedValue) — $ उपसर्ग के माध्यम से सुलभ एक अतिरिक्त संचार चैनल है। SwiftUI में, इस सुविधा का हर जगह उपयोग किया जाता है: $state, Binding देता है, और $observedObject, Published.Publisher लौटाता है। प्रोजेक्शन रैपर को मान तक मूल पहुँच को बदले बिना विस्तारित इंटरफ़ेस प्रदान करने की अनुमति देता है।

SwiftUI में मुख्य Property Wrappers

SwiftUI में स्थिति प्रबंधन के लिए पाँच अंतर्निहित Property Wrappers शामिल हैं: @State, @Binding, @ObservedObject, @StateObject और @Environment। प्रत्येक एक विशिष्ट कार्य हल करता है और विभिन्न परिदृश्यों में उपयोग किया जाता है। @State सरल स्थानीय डेटा के लिए है, @Binding — चाइल्ड व्यू में डेटा का संदर्भ पास करने के लिए, @ObservedObject और @StateObject — जटिल ऑब्जेक्ट के लिए, @Environment — पदानुक्रम से सिस्टम मानों के लिए।

विशिष्ट Property Wrapper का चुनाव डेटा स्रोत और उसके जीवनचक्र पर निर्भर करता है। यदि डेटा एक व्यू से संबंधित है और चाइल्ड घटकों को इसकी आवश्यकता नहीं है — @State का उपयोग करें। यदि चाइल्ड व्यू को पैरेंट के डेटा को संशोधित करने की आवश्यकता है — @Binding का उपयोग करें। कई व्यू में उपयोग किए जाने वाले ऑब्जेक्ट के लिए, @ObservedObject और @StateObject उपयुक्त हैं।

@State: व्यू की स्थानीय स्थिति

@State — एक व्यू के अंदर स्थानीय स्थिति संग्रहीत करने के लिए Property Wrapper है। Swift स्वचालित रूप से @State प्रॉपर्टी के लिए मेमोरी प्रबंधित करता है और प्रत्येक परिवर्तन पर व्यू को पुनः रेंडर करता है। @State सरल प्रकार (String, Int, Bool, enum) और संरचनाओं के लिए उपयुक्त है जो विशेष रूप से वर्तमान व्यू से संबंधित हैं। जब मान बदलता है, SwiftUI body प्रॉपर्टी को पुनः चलाता है।

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

    var body: some View {
        VStack {
            Text("गणना: \(count)")
            Button("वृद्धि") {
                count += 1
            }
        }
    }
}

उदाहरण में, @State प्रॉपर्टी count काउंटर का वर्तमान मान संग्रहीत करती है। SwiftUI इस प्रॉपर्टी के लिए हीप पर एक स्टोरेज क्षेत्र बनाता है और इसे CounterView के जीवनचक्र से जोड़ता है। बटन दबाने पर, count 1 बढ़ जाता है, SwiftUI परिवर्तन का पता लगाता है और body को पुनः चलाकर नया मान प्रदर्शित करता है। महत्वपूर्ण: @State का उपयोग जटिल संदर्भ प्रकारों के लिए नहीं किया जाना चाहिए — इसके लिए @StateObject और @ObservedObject हैं।

@Binding: व्यू के बीच द्विदिश संबंध

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

struct ToggleSwitch: View {
    @Binding var isOn: Bool

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

लिस्टिंग में, ToggleSwitch पैरेंट व्यू से @BindingBool प्राप्त करता है। पैरेंट @State var isToggleOn = false बनाता है और $isToggleOn को ToggleSwitch के इनिशियलाइज़र में पास करता है। जब उपयोगकर्ता चाइल्ड व्यू के अंदर टॉगल स्विच करता है, तो परिवर्तन तुरंत पैरेंट के @State में प्रतिबिंबित होता है। Binding तंत्र पदानुक्रम में ऊपर की ओर परिवर्तन पास करने के लिए डेलिगेट या क्लोज़र की आवश्यकता को पूरी तरह से समाप्त करता है।

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

@ObservedObject — बाहर से पास किए गए ObservableObject इंस्टेंस का अवलोकन करने के लिए Property Wrapper है। व्यू इस ऑब्जेक्ट का स्वामी नहीं है — यह पैरेंट घटक में बनाया जाता है या Environment के माध्यम से इंजेक्ट किया जाता है। जब ObservableObject के अंदर कोई @Published प्रॉपर्टी बदलती है, SwiftUI @ObservedObject के माध्यम से सब्सक्राइब किए गए सभी व्यू को पुनः रेंडर करता है।

@StateObject — सीधे व्यू में ObservableObject बनाने और उसका स्वामित्व लेने के लिए रैपर है। @ObservedObject के विपरीत, @StateObject पूरे व्यू जीवनचक्र के लिए ऑब्जेक्ट का एकल इंस्टेंस सुनिश्चित करता है। भले ही SwiftUI व्यू संरचना को पुनः बनाए (जो अक्सर होता है), @StateObject मौजूदा ऑब्जेक्ट को संरक्षित करता है और इनिशियलाइज़र को फिर से कॉल नहीं करता।

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

struct ProfileView: View {
    @StateObject var settings = UserSettings()

    var body: some View {
        ChildProfileView(settings: settings)
    }
}

struct ChildProfileView: View {
    @ObservedObject var settings: UserSettings

    var body: some View {
        Text("नमस्ते, \(settings.username)")
    }
}

उदाहरण में, ProfileView @StateObject के माध्यम से UserSettings बनाता है, ऑब्जेक्ट का स्वामी बन जाता है। ChildProfileView @ObservedObject के माध्यम से वही इंस्टेंस प्राप्त करता है — अवलोकन करता है लेकिन जीवनचक्र का प्रबंधन नहीं करता। जब username बदलता है, दोनों व्यू अपडेट होते हैं। यदि ChildProfileView @ObservedObject के बजाय @StateObject का उपयोग करता, तो प्रत्येक रेंडर पर प्रारंभिक मान के साथ एक नया इंस्टेंस बनाया जाता।

मुख्य नियम: @StateObject का उपयोग उस व्यू में किया जाता है जो ऑब्जेक्ट बनाता है (सत्य का स्रोत), जबकि @ObservedObject का उपयोग उस व्यू में किया जाता है जो पैरेंट से पहले से बनाया गया ऑब्जेक्ट प्राप्त करता है। इस नियम का उल्लंघन करने से स्थिति हानि या डेटा के अप्रत्याशित पुनर्निर्माण होता है।

कस्टम Property Wrapper बनाना

Swift किसी भी दोहराए जाने वाले प्रॉपर्टी एक्सेस तर्क के लिए कस्टम Property Wrappers बनाने की अनुमति देता है। बस @propertyWrapper विशेषता के साथ एक संरचना या क्लास घोषित करें और wrappedValue लागू करें। नीचे UserDefaultsWrapper रैपर दिखाया गया है, जो स्वचालित रूप से UserDefaults के साथ मान सिंक्रनाइज़ करता है।

@propertyWrapper
struct UserDefaultsWrapper<T> {
    let key: String
    let defaultValue: T

    var wrappedValue: T {
        get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue }
        set { UserDefaults.standard.set(newValue, forKey: key) }
    }
}

struct AppConfig {
    @UserDefaultsWrapper(key: "theme", defaultValue: "light")
    var theme: String
}

UserDefaultsWrapper रैपर UserDefaults द्वारा समर्थित किसी भी डेटा प्रकार के साथ काम करने के लिए जेनेरिक T का उपयोग करता है। गेटर कुंजी द्वारा मान पढ़ता है, सेटर लिखता है। theme प्रॉपर्टी पर @UserDefaultsWrapper(key:defaultValue:) लागू करना इसे स्वचालित रूप से स्टोरेज से जोड़ता है — सभी UserDefaults तर्क रैपर के अंदर छिपा हुआ है। यह Property Wrappers के साथ बॉयलरप्लेट कोड कम करने का एक विशिष्ट उदाहरण है।

कस्टम रैपर बनाते समय, प्रदर्शन पर विचार करना महत्वपूर्ण है। चूँकि गेटर और सेटर प्रत्येक प्रॉपर्टी एक्सेस पर कॉल किए जाते हैं, wrappedValue में भारी I/O ऑपरेशन नहीं रखने चाहिए। एसिंक्रोनस डेटा स्टोरेज के लिए, Property Wrappers को ObservableObject और @Published के साथ संयोजित करना बेहतर है।