body: यह क्या है, SwiftUI में View की कम्प्यूटेड प्रॉपर्टी

SwiftUI में body क्या है?

body एक कम्प्यूटेड प्रॉपर्टी है जो View प्रोटोकॉल की एकमात्र अनिवार्य आवश्यकता है। View के अनुरूप प्रत्येक संरचना को body लागू करना चाहिए। यह प्रॉपर्टी वह कंटेंट लौटाती है जिसे SwiftUI स्क्रीन पर प्रदर्शित करता है — यह टेक्स्ट, इमेज, बटन, नेस्टेड तत्वों वाला कंटेनर या View प्रोटोकॉल के अनुरूप कोई अन्य प्रकार हो सकता है।

body का सिग्नेचर हमेशा निश्चित होता है: var body: some View { get }. रिटर्न प्रकार some View (अपारदर्शी प्रकार) है, कोई ठोस प्रकार नहीं। इसका मतलब है कि अलग-अलग Views body में अलग-अलग ठोस प्रकार लौटा सकते हैं, लेकिन Swift कंपाइलर प्रत्येक कार्यान्वयन के लिए कंपाइल समय पर ठोस प्रकार निर्धारित करता है।

WWDC 2022 के अनुसार, body घोषणात्मक इंटरफ़ेस विवरण का प्रवेश बिंदु है। UIKit के विपरीत, जहाँ आप UIView को अनिवार्य रूप से बनाते और कॉन्फ़िगर करते हैं, SwiftUI में आप घोषणात्मक रूप से वर्णन करते हैं कि क्या प्रदर्शित किया जाना चाहिए, और SwiftUI स्वयं गणना करता है कि इसे कैसे लागू किया जाए।

body एक शुद्ध फ़ंक्शन के रूप में

body को शुद्ध फ़ंक्शन की तरह व्यवहार करना चाहिए — समान इनपुट (संरचना गुण और स्थिति) के साथ इसे समान View पेड़ लौटाना चाहिए। यदि body बाहरी परिवर्तनीय स्थिति (ग्लोबल वेरिएबल, @AppStorage रैपर के बिना UserDefaults) पर निर्भर करती है, तो व्यवहार अप्रत्याशित हो जाता है और SwiftUI स्क्रीन को गलत तरीके से पुनः चित्रित कर सकता है।

कम्प्यूटेड प्रॉपर्टी body कैसे काम करती है

कम्प्यूटेड प्रॉपर्टी body कोई मान संग्रहीत नहीं करती — यह हर बार एक्सेस किए जाने पर गणना की जाती है। जब SwiftUI यह निर्धारित करता है कि स्थिति बदल गई है, तो वह View संरचना को पुनः बनाता है और प्रदर्शन के लिए वर्तमान तत्व पेड़ प्राप्त करने हेतु body का नया मान पढ़ता है।

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

    var body: some View {
        VStack {
            Text("काउंटर: \(count)")
                .font(.largeTitle)
            Button("बढ़ाएँ") {
                count += 1
            }
            .padding()
            .background(.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
        }
    }
}

इस उदाहरण में, body एक VStack लौटाती है जिसमें टेक्स्ट और मॉडिफ़ायर वाला एक बटन है। जब बटन दबाया जाता है, @State प्रॉपर्टी count बढ़ जाती है, SwiftUI CounterView संरचना को पुनः बनाता है और नए टेक्स्ट मान के साथ अद्यतन पेड़ प्राप्त करने के लिए body को फिर से कॉल करता है।

मॉडिफ़ायर (.font, .padding, .background, .foregroundColor, .cornerRadius) मूल View को संशोधित नहीं करते बल्कि इसे ModifiedContent में लपेटते हैं — एक नया प्रकार जो संशोधन जोड़ता है। प्रत्येक मॉडिफ़ायर नेस्टिंग का एक और स्तर बनाता है, जो प्रदर्शन के लिए विचार करना महत्वपूर्ण है।

body और अपारदर्शी प्रकार some View

some View body के रिटर्न प्रकार में केवल एक सम्मेलन नहीं है बल्कि कंपाइलर की आवश्यकता है। Swift आवश्यकता करता है कि body में सभी रिटर्न पथों का समान ठोस प्रकार हो। @ViewBuilder के बिना आप एक शाखा में Text और दूसरी में Button नहीं लौटा सकते — कंपाइलर त्रुटि देगा।

struct ConditionalView: View {
    var isReady: Bool

    @ViewBuilder
    var body: some View {
        if isReady {
            Text("तैयार")
                .foregroundColor(.green)
        } else {
            ProgressView()
        }
    }
}

body पर @ViewBuilder कंपाइलर त्रुटियों के बिना सशर्त तर्क (if/else, switch) का उपयोग करने देता है। ViewBuilder स्वचालित रूप से विभिन्न शाखाओं को ConditionalContent में लपेटता है — एक विशेष प्रकार जो ठोस प्रकार के अंतरों को छुपाता है। गतिशील इंटरफ़ेस बनाने के लिए यह एक महत्वपूर्ण क्षमता है।

@ViewBuilder के बिना कंपाइलर सभी रिटर्न पथों के लिए एक ही प्रकार का अनुमान लगाने का प्रयास करता है। यदि प्रकार भिन्न हैं — त्रुटि उत्पन्न होती है। यही कारण है कि SwiftUI View घोषणाओं में body पर अंतर्निहित रूप से @ViewBuilder लागू करता है, हालाँकि उपयोगकर्ता कोड में आपको कस्टम विधियों और गुणों के लिए स्पष्ट रूप से एनोटेशन जोड़ना होता है जो कई Views लौटाते हैं।

some View का प्रदर्शन

ठोस प्रकार के बजाय some View का उपयोग करने से प्रदर्शन कम नहीं होता — कंपाइलर कंपाइल समय पर सटीक प्रकार जानता है और बिना गतिशील डिस्पैच के सीधा कोड उत्पन्न करता है। इसके विपरीत, AnyView अस्तित्वगत कंटेनर में लपेटने के ओवरहेड के साथ टाइप इरेज़र का उपयोग करता है।

body का जीवनचक्र: कब और कैसे कॉल की जाती है

body SwiftUI द्वारा तीन मुख्य परिदृश्यों में कॉल की जाती है: जब View पहली बार प्रदर्शित होता है, जब @State/@Binding/@ObservedObject/@StateObject बदलता है, और जब मूल View आरंभकर्ता के माध्यम से नए मान पास करता है। SwiftUI पर्यावरण मान (@Environment) बदलने पर भी body को कॉल कर सकता है।

body कॉल की आवृत्ति आपको चिंतित नहीं करनी चाहिए — SwiftUI पहचान तंत्र के माध्यम से पुनः चित्रण को अनुकूलित करता है। पदानुक्रम में प्रत्येक View का एक अद्वितीय पहचानकर्ता होता है। यदि पहचान और इनपुट डेटा नहीं बदला है — body कॉल नहीं की जाती भले ही मूल View पुनः चित्रित हो। यह Equatable तुलना और संरचनात्मक स्थिरता के माध्यम से प्राप्त होता है।

struct ParentView: View {
    var body: some View {
        ChildView(name: "Alice") // स्थिर पहचान
    }
}

struct ChildView: View {
    let name: String
    var body: some View {
        Text("नमस्ते, \(name)!")
    }
}

इस उदाहरण में, यदि ParentView पुनः चित्रित होता है लेकिन समान name मान पास करता है — ChildView.body कॉल नहीं होती। SwiftUI संरचना के इनपुट डेटा की तुलना करता है और, यदि अपरिवर्तित है, तो चाइल्ड कंपोनेंट के पुनः चित्रण को छोड़ देता है। यह दृश्य विभेदन तंत्र है।

जब body अप्रत्याशित रूप से कॉल होती है

कई समस्याएँ हैं जो body के अप्रत्याशित कॉल का कारण बनती हैं: ObservableObject के बिना क्लास का उपयोग, body के अंदर बनाए गए क्लोज़र पास करना (प्रत्येक क्लोज़र निर्माण एक नई पहचान देता है), और EquatableView का गलत उपयोग। यदि body बहुत बार कॉल होती है — सभी चाइल्ड कंपोनेंट्स की पहचान स्थिरता की जाँच करें।

body के साथ काम करने के सर्वोत्तम अभ्यास

पहला नियम: body न्यूनतम होनी चाहिए। जटिल तर्क को अलग-अलग कम्प्यूटेड प्रॉपर्टीज़ या विधियों में ले जाएँ जो View लौटाती हैं। इससे पठनीयता में सुधार होता है और SwiftUI को अधिक सटीक रूप से यह निर्धारित करने देता है कि पदानुक्रम के कौन से भाग बदले हैं। बड़े bodies को स्पष्ट जिम्मेदारी सीमाओं वाले उप-घटकों में विभाजित करें।

दूसरा नियम: कार्य करने के लिए body का उपयोग न करें। डेटा लोडिंग, नेटवर्क संचालन, डेटाबेस लेखन — यह सब body के बाहर, कार्यों (tasks), onChange मॉडिफ़ायर या ObservableObject के माध्यम से होना चाहिए। body केवल इंटरफ़ेस घोषणा के लिए अभिप्रेत है।

तीसरा नियम: यदि मानक संरचनात्मक तुलना अपर्याप्त है तो Views के लिए EquatableView प्रॉपर्टी या कस्टम Equatable प्रोटोकॉल का उपयोग करें। यह आपको SwiftUI को स्पष्ट रूप से बताने देता है कि चाइल्ड View को कब पुनः चित्रण की आवश्यकता है और अनावश्यक body कॉल से बचता है।

चौथा नियम: यदि body में जटिल गणनाएँ (फ़ॉर्मेटिंग, फ़िल्टरिंग, सॉर्टिंग) हैं — परिणाम को कैश करने के लिए @State का उपयोग करें या गणनाओं को onChange से कॉल की जाने वाली अलग विधि में ले जाएँ। प्रत्येक स्थिति अद्यतन के साथ body में बार-बार गणना एनिमेशन मंदी का एक सामान्य कारण है।

पाँचवाँ नियम: सूचियों (List, ForEach) के लिए id पैरामीटर के माध्यम से स्थिर पहचानकर्ता सुनिश्चित करें। स्थिर पहचान के बिना, ForEach किसी भी परिवर्तन पर सभी तत्वों को पुनः बनाता है, प्रत्येक के लिए body को कॉल करता है, भले ही केवल एक तत्व बदला हो।