Swift में willSet और didSet: यह क्या है, सिंटैक्स और ऑब्ज़र्वर का काम

Swift में willSet और didSet क्या हैं?

willSet और didSet Swift में प्रॉपर्टी ऑब्ज़र्वर (property observers) हैं, जो stored properties में परिवर्तनों को ट्रैक करने के लिए एक अंतर्निहित तंत्र है।

अन्य भाषाओं के विपरीत जहाँ मैन्युअल setter कार्यान्वयन या कॉलबैक सिस्टम की आवश्यकता होती है, Swift परिवर्तनों पर प्रतिक्रिया करने के लिए एक घोषणात्मक सिंटैक्स प्रदान करता है। ऑब्ज़र्वर प्रॉपर्टी घोषणा के तुरंत बाद जोड़े जाते हैं और उन्हें अलग से कॉल करने की आवश्यकता नहीं होती।

Apple डेवलपर दस्तावेज़ीकरण (2026) के अनुसार, property observers किसी भी class, struct या enum की stored properties के लिए समर्थित हैं। वे computed properties के साथ काम नहीं करते क्योंकि वे मान संग्रहीत नहीं करतीं — उनके लिए, परिवर्तन पर प्रतिक्रिया सीधे setter में लागू की जाती है।

willSet कब कॉल होता है

willSet प्रॉपर्टी को नया मान निर्दिष्ट करने से ठीक पहले कॉल किया जाता है। willSet के अंदर, अंतर्निहित पैरामीटर newValue उपलब्ध होता है जिसमें वह मान होता है जो सेट किया जाएगा। इस समय, प्रॉपर्टी का वर्तमान मान अभी तक नहीं बदला है — आप सीधे प्रॉपर्टी के माध्यम से पुराना मान पढ़ सकते हैं।

Swift Evolution प्रस्ताव SE-0001 (2024) के अनुसार, willSet वास्तविक परिवर्तन से पहले सत्यापन या लॉगिंग करने की क्षमता प्रदान करता है। यदि willSet में कोई अपवाद फेंका जाता है, तो नया मान लागू नहीं होगा, जो ऑब्ज़र्वर को डेटा सुरक्षा तंत्र बनाता है।

didSet कब कॉल होता है

didSet नया मान निर्दिष्ट करने के तुरंत बाद कॉल किया जाता है। didSet के अंदर, अंतर्निहित पैरामीटर oldValue उपलब्ध होता है जिसमें परिवर्तन से पहले का मान होता है। इस बिंदु पर, प्रॉपर्टी में पहले से ही नया मान है, और आप इसकी तुलना पुराने मान से कर सकते हैं।

Swift by Sundell (2025) के अनुसार, didSet सबसे लोकप्रिय ऑब्ज़र्वर है क्योंकि इसकी अक्सर पोस्ट-प्रोसेसिंग के लिए आवश्यकता होती है: UI अपडेट करना, आश्रित फ़ील्ड की पुनर्गणना करना, या परिवर्तन के बाद सर्वर पर डेटा भेजना।

प्रॉपर्टी ऑब्ज़र्वर का सिंटैक्स

Property observers प्रॉपर्टी के तुरंत बाद घुंघराले ब्रेसिज़ का उपयोग करके घोषित किए जाते हैं। न्यूनतम सिंटैक्स के लिए केवल एक ऑब्ज़र्वर की आवश्यकता होती है, लेकिन आप दोनों घोषित कर सकते हैं।

var score: Int = 0 {
    willSet {
        print("स्कोर बदलकर \(newValue) हो जाएगा")
    }
    didSet {
        print("स्कोर \(oldValue) से बदलकर \(score) हो गया")
    }
}

दोनों ऑब्ज़र्वर वैकल्पिक हैं — आप केवल willSet या केवल didSet निर्दिष्ट कर सकते हैं। willSet के लिए आप कोष्ठक में नाम निर्दिष्ट करके newValue का नाम बदल सकते हैं।

var username: String = "guest" {
    willSet(newName) {
        print("\(newName) सेट करने वाला हूँ")
    }
    didSet(oldName) {
        print("पहले \(oldName) था, अब \(username) है")
    }
}

Swift Language Guide (2026) के अनुसार, पैरामीटर का नाम बदलने से कोड पठनीयता में सुधार होता है, खासकर जब प्रॉपर्टी और ऑब्ज़र्वर लंबे नामों वाले बड़े प्रोजेक्ट में उपयोग किए जाते हैं।

willSet और didSet कैसे काम करते हैं

निष्पादन का क्रम सख्ती से परिभाषित है: पहले willSet (पुराना मान उपलब्ध है), फिर असाइनमेंट, फिर didSet (नया मान उपलब्ध है)।

class Temperature {
    var celsius: Double = 0.0 {
        willSet {
            print("तापमान \(celsius) से बदलकर \(newValue) हो जाएगा")
        }
        didSet {
            if celsius > 100.0 {
                print("उबलने का बिंदु पार हो गया!")
            }
        }
    }
}

एक महत्वपूर्ण सीमा: इंस्टेंस बनाते समय प्रॉपर्टी इनिशियलाइज़ेशन के दौरान ऑब्ज़र्वर कॉल नहीं होते हैं। init के अंदर, मान निर्दिष्ट करना willSet और didSet को ट्रिगर नहीं करता — यह निर्माण चरण में अवांछित दुष्प्रभावों को रोकता है।

Apple Swift Blog (2025) के अनुसार, यह व्यवहार कई अन्य भाषाओं से भिन्न है जहाँ setter कंस्ट्रक्टर में भी कॉल होते हैं। Swift सुरक्षा चुनता है: ऑब्ज़र्वर ऑब्जेक्ट इनिशियलाइज़ेशन पूरा होने के बाद ही काम करना शुरू करते हैं।

नेस्टेड कॉल और रिकर्सन

didSet के अंदर प्रॉपर्टी बदलने से बार-बार ऑब्ज़र्वर कॉल हो सकते हैं। Swift रिकर्सन को ब्लॉक नहीं करता — प्रोग्रामर को इसे मैन्युअल रूप से नियंत्रित करना होगा।

var counter: Int = 0 {
    didSet {
        if counter < 5 {
            counter += 1
        }
    }
}

ऐसा कोड यदि बाहर निकलने की शर्त प्रदान नहीं की गई तो स्टैक ओवरफ़्लो के साथ पूर्ण रिकर्सन बनाएगा। Stack Overflow Swift Community (2025) के अनुसार, property observers के साथ काम करते समय यह शुरुआती डेवलपर्स की सबसे आम गलतियों में से एक है।

स्ट्रक्चर के प्रॉपर्टी के लिए ऑब्ज़र्वर

स्ट्रक्चर बिना किसी प्रतिबंध के stored properties के लिए willSet और didSet का समर्थन करते हैं। यह याद रखना महत्वपूर्ण है कि स्ट्रक्चर value types हैं, और mutating मेथड के अंदर प्रॉपर्टी को संशोधित करना भी ऑब्ज़र्वर को ट्रिगर करता है।

struct Point {
    var x: Double = 0.0 {
        didSet {
            print("X बदलकर \(x) हो गया")
        }
    }
    var y: Double = 0.0 {
        didSet {
            print("Y बदलकर \(y) हो गया")
        }
    }
}

var point = Point()
point.x = 5.0

वास्तविक परियोजनाओं में ऑब्ज़र्वर का उपयोग

प्रॉपर्टी ऑब्ज़र्वर का उपयोग Swift प्रोजेक्ट्स में कई प्रकार के कार्यों के लिए किया जाता है: UI सिंक्रनाइज़ेशन से लेकर डेटा सत्यापन और लॉगिंग तक।

मानों का सत्यापन

didSet आपको सेट होने के तुरंत बाद अमान्य मान को वापस रोल या सही करने की अनुमति देता है। यह Objective-C में बोझिल setter को बदलता है और मॉडल स्तर पर डेटा अखंडता सुनिश्चित करता है।

var age: Int = 0 {
    didSet {
        if age < 0 || age > 150 {
            age = oldValue
        }
    }
}

UI सिंक्रनाइज़ेशन

जब कोई संबंधित प्रॉपर्टी बदलती है, तो आप बिना किसी अलग अपडेट मेथड कॉल के इंटरफ़ेस तत्वों को स्वचालित रूप से अपडेट कर सकते हैं।

var userName: String = "" {
    didSet {
        nameLabel.text = userName
    }
}

परिवर्तन लॉगिंग

willSet डिबगिंग या ऑडिट उद्देश्यों के लिए लॉगिंग के लिए सुविधाजनक है। आप लागू करने से पहले समय और नया मान रिकॉर्ड कर सकते हैं, यह सुनिश्चित करते हुए कि लॉग में विश्लेषण के लिए मूल डेटा शामिल है।

objc.io (2025) के अनुसार, property observers विशेष रूप से एकदिशीय डेटा प्रवाह वाली आर्किटेक्चर में उपयोगी होते हैं, जहाँ प्रत्येक प्रॉपर्टी परिवर्तन को बाद में स्थिति पुनरुत्पादन के लिए रिकॉर्ड किया जाता है।

computed properties से तुलना

Computed properties तुरंत मान की गणना करती हैं और उनमें कोई भंडारण नहीं होता, जबकि willSet और didSet वास्तविक मान वाली stored property पर काम करते हैं।

मुख्य अंतर: computed property प्रत्येक एक्सेस पर मान की गणना करती है, जबकि property observer मौजूदा मान में परिवर्तन पर प्रतिक्रिया करता है। उनके बीच चुनाव शब्दार्थ द्वारा निर्धारित होता है — यदि प्रॉपर्टी अन्य डेटा से व्युत्पन्न है, तो computed का उपयोग करें; यदि यह एक स्वतंत्र मान है जिसके परिवर्तनों की निगरानी की जानी चाहिए, तो willSet/didSet का उपयोग करें।

उपयोग में सामान्य गलतियाँ

सबसे आम गलती बिना बाहर निकलने की शर्त के didSet का पुनरावर्ती कॉल है। didSet के अंदर प्रॉपर्टी का प्रत्येक परिवर्तन ऑब्ज़र्वर को फिर से ट्रिगर करता है, जो अनंत लूप की ओर ले जाता है।

दूसरी सामान्य गलती let प्रॉपर्टी पर ऑब्ज़र्वर का उपयोग करने का प्रयास है। Swift कंपाइलर एक त्रुटि देगा क्योंकि let एक स्थिरांक है।

तीसरी गलती यह अनदेखा करना है कि इनिशियलाइज़ेशन के दौरान ऑब्ज़र्वर कॉल नहीं होता है। जो डेवलपर init के अंदर willSet के सक्रिय होने की उम्मीद करते हैं, उन्हें अप्रत्याशित व्यवहार मिलता है।

चौथी समस्या extension में प्रॉपर्टी पर ऑब्ज़र्वर लागू करना है। Swift extension में stored properties पर willSet/didSet जोड़ने पर प्रतिबंध लगाता है।

Ray Wenderlich (2025) के अनुसार, इन सीमाओं को समझने से शुरुआती चरणों में बग से बचने में मदद मिलती है और Swift कोड को अधिक पूर्वानुमानित बनाता है।