स्काला में कक्षाएं टाइप करें

हाल ही में, स्काला डेवलपर्स के समुदाय में, टाइप कक्षाओं के डिजाइन पैटर्न पर अधिक ध्यान दिया गया है। यह अनावश्यक निर्भरता से निपटने में मदद करता है और एक ही समय में कोड को क्लीनर बनाता है। नीचे मैं उदाहरणों के साथ दिखाऊंगा कि इसका उपयोग कैसे करना है और इस दृष्टिकोण के क्या फायदे हैं।

लेख केवल स्काला में लिखने वाले प्रोग्रामर के लिए नहीं, बल्कि जावा में भी बनाया गया है - शायद उन्हें खुद के लिए एक उत्तर मिलेगा, जैसा कि, कम से कम सिद्धांत रूप में, यह कई लागू समस्याओं के लिए एक समाधान की तरह दिखता है जिसमें घटक परस्पर जुड़े नहीं होते हैं और लिखने के बाद एक्स्टेंसिबल होते हैं । यह डेवलपर्स और डिजाइनरों के लिए किसी अन्य भाषा में भी दिलचस्प हो सकता है।

आवश्यक शर्तें

जब किसी वर्ग को इस वर्ग से जुड़े व्यवहार को जोड़ने की आवश्यकता होती है, तो हर किसी को समस्या का सामना करना पड़ता है: तुलना, क्रमबद्धता, क्रमबद्धता से पढ़ना, एक वर्ग को त्वरित करना, रेंडर करना, यह एक और व्यवहार हो सकता है जिसे आपके बहुत उपयोगी पुस्तकालय की आवश्यकता होती है।

जावा दुनिया में इन समस्याओं को हल करने के लिए कई तरीके हैं:

• एक इंटरफ़ेस लिखें और इसे कक्षा में ही लागू करें (उदाहरण के लिए, तुलनीय),
• एक अलग इंटरफ़ेस लिखें, जिसका एक विशिष्ट उदाहरण क्लास ऑब्जेक्ट प्राप्त करेगा और आवश्यक क्रियाओं को करेगा (उदाहरण के लिए, तुलनित्र);
• व्यक्तिगत कार्यों के लिए और भी खास तरीके हैं:
  • ऑब्जेक्ट बनाने के लिए - फ़ैक्टरी टेम्पलेट,
  • तृतीय-पक्ष लायब्रेरी एडाप्टर के साथ लिंक करने के लिए उपयोग किया जाता है,
  • क्रमांकन और पढ़ने के लिए कभी-कभी प्रतिबिंब का उपयोग करें। यह एक हालिया पोस्ट से एक शव परीक्षा की याद दिलाता है, लेकिन पेट की सर्जरी भी कभी-कभी आवश्यक होती है, मुझे तुरंत आरक्षण करना होगा, टाइप कक्षाएं इसे बदलने में सक्षम नहीं होंगी।

तो, संक्षेप में, हमारे पास अब दो विकल्प हैं: या तो किसी तृतीय-पक्ष के कार्यात्मक को एक वर्ग के साथ जोड़ दें या एक अलग ऑब्जेक्ट में कार्यात्मक को बाहर निकाल दें और फिर इसके हस्तांतरण का ध्यान रखें। एक उदाहरण के रूप में एप्लिकेशन उपयोगकर्ताओं को लेते हैं। यह हमारे उपयोगकर्ताओं की तुलना करने की क्षमता को जोड़ने जैसा लग सकता है:

//  ,    def sort[T <: Comparable[T]](elements: Seq[T]): Seq[T] //   class Person(val id: Id[Person], val name: String) extends Comparable[Person] { def compareTo(Person anotherPerson): Int = { return this.name.compareTo(anotherPerson.name) } } //  sort(persons) 

यहां यह अच्छा है कि छंटाई का विशिष्ट अनुप्रयोग बहुत स्पष्ट दिखता है। लेकिन तुलना तर्क कसकर वर्ग के साथ जुड़ा हुआ है (और शायद कोई भी पसंद नहीं करता है कि मॉडल ऑब्जेक्ट निर्भर करते हैं, उदाहरण के लिए, एक पुस्तकालय जो XML उत्पन्न करता है और डेटाबेस को लिखता है)। इसके अलावा, एक और समस्या उत्पन्न होती है: एक से अधिक तुलना पद्धति को परिभाषित करना असंभव है - अर्थात, यदि कल हम उपयोगकर्ताओं को प्रोग्राम में कहीं और आईडी द्वारा तुलना करना चाहते हैं, तो हम सफल नहीं हुए हैं, और हम निजी कक्षाओं के लिए तुलना विधि को फिर से लिखने में सक्षम नहीं हैं।

जावा में इस उद्देश्य के लिए एक तुलनित्र वर्ग है, यह आपको अधिक लचीलापन प्राप्त करने की अनुमति देता है:

 //  ,    def sort[T](elements: Seq[T], comparator: Comparator[T]): Seq[T] //   class Person(val id: Id[Person], val name: String) trait Comparator[T] { def compare(object1: T, object2 T): Int } class PersonNameComparator extends Comparator[Person] { def compare(onePerson: Person, anotherPerson: Person): Int = { return onePerson.name.compareTo(anotherPerson.name) } } //  val nameComparator = new PersonNameComparator() sort(persons, nameComparator) 

अब आप कई तुलना विधियों को परिभाषित कर सकते हैं, तुलना तर्क अब मॉडल वर्ग से जुड़ा नहीं है। इसके अलावा, कुछ भी आपको अपने स्वयं के तुलनित्र को लिखने से रोकता है, भले ही छंटाई एल्गोरिथ्म की कक्षा और परिभाषा हमारे लिए बंद हो। यह ध्यान देने योग्य है कि सॉर्टिंग कॉल कुछ अधिक जटिल हो गया है।

कारखानों और एडेप्टर का उपयोग जीवन चक्र के समान प्रबंधन और उनके उदाहरणों के हस्तांतरण का अर्थ है। और फिर भी आम तौर पर एक मानक कार्य के लिए इन सभी शांत नामों को याद रखना आवश्यक है।

और फिर टाइप की क्लासेस दिखाई देती हैं

यह वह जगह है जहां स्काला की क्षमता स्पष्ट रूप से पास मापदंडों के बचाव में आती है। आइए हमारे पिछले उदाहरण को आधार के रूप में लें, लेकिन एल्गोरिथ्म को अलग तरह से परिभाषित करें, हम तुलनात्मक रूप से पास करेंगे:

 def sort[T](elements: Seq[T])(implicit comparator: Comparator[T]): Seq[T] 

इसका मतलब यह है कि यदि प्रकार पैरामीटर के वांछित मूल्य के साथ गुंजाइश में एक उपयुक्त तुलनित्र है, तो इसे प्रोग्रामर की ओर से अतिरिक्त प्रयास के बिना संकलक द्वारा विधि में प्रतिस्थापित किया जाएगा। इसलिए, उपयुक्त तुलनित्र को दायरे में रखें:

 implicit val personNameComparator = Comparator[Person] { def compare(onePerson: Person, anotherPerson: Person): Int = { return onePerson.name.compareTo(anotherPerson.name) } } 

अंतर्निहित कीवर्ड यह सुनिश्चित करता है कि प्रतिस्थापन में मूल्य का उपयोग किया जाएगा। यह ध्यान रखना महत्वपूर्ण है कि हमारे निहित कार्यान्वयन स्थिर होने चाहिए, क्योंकि कार्यक्रम की प्रक्रिया में प्रत्येक प्रकार का केवल एक उदाहरण बनाया जाता है।

अब छँटाई को उसी तरह से बुलाया जा सकता है जैसे कि यह मूल संस्करण में तुलनीय के कार्यान्वयन के साथ था:

 //   sort(persons) 

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

थोड़ा और दिलचस्प विकल्प तब पैदा होता है जब आप चाहते हैं कि टाइप पैरामीटर खुद टाइप हो जाए। अर्थात्, मैप [Id [व्यक्ति], सूची [अनुमति]] के लिए हम MapJsonSerializer , IdJsonSerializer , ListJsonSerializer और PermissionJsonSerializer चाहते हैं , जिनका किसी भी क्रम में पुन: उपयोग किया जा सकता है, न कि PersonPimsMapJsonSerializer , एनालॉग्स जिनमें से हम हर बार लिखेंगे। इस मामले में, निहित वस्तु का निर्धारण करने का तरीका थोड़ा अलग है, अब हमारे पास कोई वस्तु नहीं है, लेकिन एक फ़ंक्शन है:

 implicit def ListComparator[V](implicit comparator: Comparator[V]) = new Comparator[List[V]] { def compare(oneList: List[V], anotherList: List[V]): Int = { for((one, another) <- oneList.zip(anotherList)) { val elementsCompared = comparator,compare(one, another) if(elementsCompared > 0) return 1 else if(elementsCompared < 0) return -1 } return 0 } } 

वह पूरी विधि है। सबसे अच्छी बात यह है कि आप सभी प्रकार के JSONParsers, XMLSerializers को एक साथ PersonFactory के साथ प्राप्त कर सकते हैं, बिना वर्गों और वस्तुओं के पत्राचार को संग्रहीत किए बिना - स्काला कंपाइलर हमारे लिए सब कुछ करेगा।

टीसीएस में, हम इस पद्धति का उपयोग करते हैं, उदाहरण के लिए, हमारे मॉडल की कक्षाओं में अपवादों को लपेटने के लिए। टाइप कक्षाएं आपको उस प्रकार के अपवाद उदाहरण बनाने की अनुमति देती हैं जिसमें आप फेंके गए ब्लॉक को लपेटना चाहते हैं। यदि यह पारंपरिक विधि द्वारा किया जाता है, तो अपवाद कारखाने को बनाना और स्थानांतरित करना आवश्यक होगा, इसलिए पुराने तरीके से अपवादों को हाथ से फेंकना आसान होगा। अब सब कुछ सुंदर है।

आगे क्या है?

वास्तव में, टाइप कक्षाओं का विषय यहां समाप्त नहीं होता है, और एक निरंतरता के रूप में मैं स्कैला में वीडियो टाइपकालेज़ की सिफारिश करता हूं।

इस लेख में मुद्दा और भी मौलिक रूप से प्रस्तुत किया गया है।