.modifier(): यह क्या है, SwiftUI में मॉडिफ़ायर लागू करने की विधि

SwiftUI में .modifier() क्या है?

.modifier() View प्रोटोकॉल में घोषित एक विधि है: func modifier<M: ViewModifier>(_ modifier: M) -> ModifiedContent<Self, M>। यह ViewModifier को लागू करने वाले प्रकार का एक इंस्टेंस लेती है और ModifiedContent प्रकार में लिपटी एक संशोधित View लौटाती है।

यह विधि iOS 13 में प्रकट हुई और SwiftUI में कस्टम मॉडिफ़ायर लागू करने का प्राथमिक तरीका है। बिल्ट-इन मॉडिफ़ायर (font, foregroundColor, frame) के विपरीत जो सीधे View पर कॉल किए जाते हैं, .modifier() के लिए पहले से एक मॉडिफ़ायर प्रकार बनाना आवश्यक है। यह अमूर्तता का एक स्तर जोड़ता है लेकिन पुन: उपयोग और पैरामीटरकरण के अवसर खोलता है।

Hacking with Swift (2024) के अनुसार, .modifier() का उपयोग हर SwiftUI प्रोजेक्ट में किया जाता है जहाँ दोहराए जाने वाले UI तत्वों के लिए एक समान शैली की आवश्यकता होती है। यह विधि बिल्ट-इन मॉडिफ़ायर की श्रृंखला की तुलना में कोई ओवरहेड नहीं जोड़ती — कंपाइलर कॉल को अनुकूलित करता है।

हस्ताक्षर और प्रकार

modifier विधि एक जेनेरिक पैरामीटर M लेती है जो ViewModifier प्रोटोकॉल द्वारा सीमित है। जेनेरिक के कारण, कंपाइलर ठोस मॉडिफ़ायर प्रकार जानता है और टाइप इरेज़र के बिना परिणामी View प्रकार को अनुकूलित कर सकता है।

modifier(_:) विधि कैसे काम करती है

modifier(_:) विधि एक ModifiedContent इंस्टेंस बनाती है जो मूल View (Self) को पारित मॉडिफ़ायर (M) से बाँधती है। रेंडरिंग के दौरान, SwiftUI M.body(content: self) को कॉल करता है, मूल View को content पैरामीटर के रूप में पास करता है।

struct RoundedBorder: ViewModifier {
    let color: Color
    let width: CGFloat

    func body(content: Content) -> some View {
        content
            .padding(8)
            .overlay(
                RoundedRectangle(cornerRadius: 8)
                    .stroke(color, lineWidth: width)
            )
    }
}

// .modifier() के माध्यम से लागू करें:
Text("नमस्ते")
    .modifier(RoundedBorder(color: .blue, width: 2))

// समतुल्य प्रत्यक्ष श्रृंखला:
Text("नमस्ते")
    .padding(8)
    .overlay(
        RoundedRectangle(cornerRadius: 8)
            .stroke(Color.blue, lineWidth: 2)
    )

अनुप्रयोग क्रम: मॉडिफ़ायर बाहर से अंदर की ओर लागू होते हैं। पहली .modifier() कॉल View को बाहर से लपेटती है, दूसरी — पहले के ऊपर, और इसी तरह। संरचना करते समय यह महत्वपूर्ण है — क्रम दृश्य परिणाम को प्रभावित करता है।

Apple WWDC 2022 के अनुसार, SwiftUI ModifiedContent पदानुक्रम में परिवर्तनों का पता लगाने के लिए आइडेंटिटी-आधारित डिफिंग का उपयोग करता है। मॉडिफ़ायर प्रकार (M) View की आइडेंटिटी बनाने में भाग लेता है, इसलिए विभिन्न मॉडिफ़ायर प्रकार हमेशा नई आइडेंटिटी बनाते हैं, भले ही दृश्य परिणाम समान हो।

.modifier() बनाम बिल्ट-इन मॉडिफ़ायर: तुलना

बिल्ट-इन मॉडिफ़ायर SwiftUI में View प्रोटोकॉल में घोषित एक्सटेंशन विधियाँ हैं। प्रत्येक बिल्ट-इन मॉडिफ़ायर (font, foregroundColor, padding) का अपना आंतरिक कार्यान्वयन है जो Apple द्वारा अनुकूलित है। वे ViewModifier प्रोटोकॉल का उपयोग नहीं करते और .modifier() के माध्यम से नहीं बुलाए जाते।

.modifier() कब उपयोग करें: जब मॉडिफ़ायर का एक ही संयोजन एप्लिकेशन में कई स्थानों पर लागू होता है। यह शैली के लिए एकल सत्य स्रोत प्रदान करता है और रीफैक्टरिंग को सरल बनाता है। प्रत्यक्ष मॉडिफ़ायर कब उपयोग करें: किसी विशिष्ट View के लिए एक बार के अनुप्रयोगों के लिए।

Objc.io (2023) के अनुसार, .modifier() और बिल्ट-इन मॉडिफ़ायर की श्रृंखला के बीच प्रदर्शन अंतर सांख्यिकीय रूप से नगण्य है (रेंडरिंग समय का 1% से कम)। चुनाव पठनीयता और पुन: उपयोग द्वारा निर्धारित किया जाना चाहिए, प्रदर्शन से नहीं।

.modifier() का सशर्त अनुप्रयोग

मॉडिफ़ायर का सशर्त अनुप्रयोग SwiftUI में एक सामान्य कार्य है। टर्नरी ऑपरेटर के माध्यम से मानक दृष्टिकोण .modifier() के साथ काम नहीं करता क्योंकि विभिन्न मॉडिफ़ायर प्रकार विभिन्न ModifiedContent प्रकारों में परिणत होते हैं।

// ❌ संकलित नहीं होता — भिन्न मॉडिफ़ायर प्रकार:
var body: some View {
    Text("सशर्त")
        .modifier(isActive ? HighlightStyle() : DefaultStyle())
}

// ✅ सही: @ViewBuilder के अंदर if/else:
@ViewBuilder
var body: some View {
    if isActive {
        Text("सशर्त").modifier(HighlightStyle())
    } else {
        Text("सशर्त").modifier(DefaultStyle())
    }
}

// ✅ या पैरामीटर वाला मॉडिफ़ायर:
struct ConditionalStyle: ViewModifier {
    let isActive: Bool

    func body(content: Content) -> some View {
        content
            .foregroundColor(isActive ? .blue : .gray)
            .opacity(isActive ? 1.0 : 0.5)
    }
}

Text("सशर्त").modifier(ConditionalStyle(isActive: isActive))

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

मॉडिफ़ायर की श्रृंखला और संरचना

मॉडिफ़ायर श्रृंखला एक ही View पर लागू .modifier() और बिल्ट-इन मॉडिफ़ायर कॉल का एक क्रम है। प्रत्येक कॉल एक नई रैपर परत बनाता है, और सभी परतें नेस्टेड जेनेरिक के माध्यम से एक ही View प्रकार में संयुक्त होती हैं।

SwiftUI मॉडिफ़ायर श्रृंखला का प्रतिनिधित्व करने के लिए एक प्रकार प्रणाली का उपयोग करता है। उदाहरण के लिए, Text().font(.title).padding() का प्रकार ModifiedContent<ModifiedContent<Text, _FontModifier>, _PaddingLayout> है। प्रत्येक बिल्ट-इन मॉडिफ़ायर की अपनी आंतरिक मॉडिफ़ायर संरचना होती है जो डेवलपर से छिपी होती है।

प्रकार समस्या: ModifiedContent प्रकारों का गहरा नेस्टिंग संकलन को धीमा करता है और त्रुटि संदेशों को जटिल बनाता है। कस्टम ViewModifier कई परतों को एक में «समेटने» की अनुमति देते हैं, परिणामी प्रकार को सरल बनाते हैं और संकलन गति में सुधार करते हैं। Swift Compiler Team (2024) के अनुसार, 5–7 अनुक्रमिक मॉडिफ़ायर को एक ViewModifier से बदलने से जटिल Views के लिए संकलन समय 10–20% कम हो जाता है।

व्यावहारिक नियम: यदि कोई View 8 से अधिक मॉडिफ़ायर का उपयोग करता है — तो उनमें से कुछ को कस्टम ViewModifier में निकालें। इससे संकलन में तेजी आएगी और पठनीयता में सुधार होगा।