कुछ पैटर्न हैं जो घोंसले की एक परत का लाभ उठाते हैं।
Recursion, जहां यह कार्यान्वयन विवरण छिपाने के लिए किया है (और दो अलग-अलग शीर्ष स्तर की विधियों को अलग करने की तुलना में क्लीनर है) है:
def callsRecursive(p: Param): Result = {
def recursive(p: Param, o: OtherParam, pr: PartialResult = default): Result = {
...
}
}
स्कोप सुरक्षित नहींं-दोहराने खुद:
def doesGraphics(p: Point) {
def up(p: Point): Point = // ...
def dn(p: Point): Point = // ...
def lf(p: Point): Point = // ...
def rt(p: Point): Point = // ...
/* Lots of turtle-style drawing */
}
और स्थानीय ब्लॉक के लिए निहित रूपांतरणों की तरह अधिक गूढ़ चालें।
यदि आपको इनमें से दोनों की आवश्यकता है, तो मैं दो बार घोंसले की कल्पना कर सकता हूं। इससे अधिक संभावना अधिक है, अधिकतर क्योंकि आप शायद एक विधि बना रहे हैं। आपको इस बारे में सोचना चाहिए कि समस्या को अलग-अलग इंटरफेस के साथ समस्या को कैसे विभाजित करना है जो विधि के भीतर परिभाषित चर के सभी प्रकारों के आस-पास बंद होने का गन्दा हॉज-पॉज होने के बजाय अपने स्वयं के तरीकों बन सकता है। बड़ी विधियां वैश्विक चर की तरह हैं: सब कुछ कार्यान्वयन के विवरण पर बहुत निर्भर हो जाता है और ट्रैक रखने के लिए बहुत कठिन होता है। यदि आप किसी सभ्य इंटरफ़ेस को बनाने के लिए उचित मात्रा में सोचने के लिए तैयार हैं, भले ही आपको केवल इसकी आवश्यकता हो, फिर भी इसे शीर्ष स्तर पर ले जाने पर विचार करें। यदि आप मुश्किल से सोचने वाले नहीं हैं, तो मेरा झुकाव इंटरफ़ेस को प्रदूषित करने से बचने के लिए अंदर छोड़ना है।
किसी भी मामले में, कहीं भी आपको जिस विधि की आवश्यकता है उसे बनाने से डरो मत। उदाहरण के लिए, मान लीजिए कि आप दो विधियों के साथ कुछ विधि के भीतर खुद को गहरा पाते हैं जिनमें से प्रत्येक को तर्क में विशिष्ट बिंदुओं पर एक ही ऑपरेशन करना होता है। चिंता न करें अगर आप एक या दो या तीन विधियां गहरे हैं! बस जिस विधि की आवश्यकता है उसे बनाएं, और इसे दोहराने के बजाय इसे कॉल करें। (बस ध्यान रखें कि एक सूची बनाना और मैपिंग एक विकल्प है यदि आपको बस एक ही स्थान पर कई चीजों को संसाधित करने की आवश्यकता है।)
स्रोत
2012-07-08 23:43:46