डार्ट में मिश्रण का उपयोग

कई बार सहकर्मियों से एक सवाल पूछा गया था कि यह स्पष्ट नहीं है कि डार्ट भाषा में मिक्सिन्स (अशुद्धियाँ) की आवश्यकता क्यों है। मैंने यह देखने का फैसला किया कि इस मुद्दे पर इंटरनेट पर क्या है। लेखों के अधिकांश भाग जो मिल सकते हैं, वे मुख्य रूप से अशुद्धियों का उपयोग करने के तरीके के बारे में बात करते हैं, लेकिन वे यह नहीं समझाते हैं कि उन्हें क्यों आवश्यक है, ऐसे मामलों में उनका उपयोग साधारण विरासत या इंटरफेस के कार्यान्वयन की तुलना में अधिक बेहतर है। यह लेख इस अंतर को भरने का एक प्रयास है।

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

class Animal {} class Dog {} class Cat {} 

और किसी कारण से हम एक जानवर प्राप्त करना चाहते थे जिसमें एक ही समय में बिल्लियों और कुत्तों के गुण हैं। इस मामले में, हम यह कर सकते हैं:

 class CatDog extends Animal with Cat, Dog {} 

इस उदाहरण में कम से कम दो प्रश्न हैं:

• हमें बिल्ली और कुत्ते के बीच एक क्रॉस की आवश्यकता क्यों है?
• बिल्ली और कुत्ते को Animal से विरासत में क्यों नहीं मिलता है? क्या वे जानवर नहीं हैं?

उसी समय, अशुद्धियों को फिर भी क्यों आवश्यक है? यह एक रहस्य बना हुआ है।

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

यदि हम विरासत को एक अलग दृष्टिकोण से देखते हैं, तो हम देखेंगे कि के गुणों को विरासत में देती है, और के गुणों को विरासत में देती है। यदि आप तर्क पर ध्यान नहीं देते हैं, तो, विशुद्ध रूप से तकनीकी रूप से, आप कई अलग-अलग संस्थाओं के गुणों को प्राप्त करना चाहते हैं। ऐसा करने के लिए, कुछ प्रोग्रामिंग भाषाएं कई विरासत का समर्थन करती हैं ।

कई कमियों के लिए एकाधिक वंशानुक्रम की आलोचना की जाती है ( विकिपीडिया देखें), इसलिए कई प्रोग्रामिंग भाषाएं कई विरासत का उपयोग नहीं करती हैं, लेकिन इंटरफेस और / या अशुद्धियों को लागू करने के लिए एक तंत्र का उपयोग करती हैं। और, तर्क की दृष्टि से, कई विरासत से उत्पन्न निर्माण को समझना आसान नहीं है।

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

एक श्रेणी पदानुक्रम का निर्माण आमतौर पर मूल वर्ग में किसी भी आवश्यक गुण जोड़ने पर आधारित होता है। उदाहरण के लिए

 abstract class Shape { void draw(); } class Rectangle extends Shape { @override void draw() { print('Draw rectangle'); } } class Circle extends Shape { @override void draw() { print('Draw circle'); } } 

इस पदानुक्रम का आधार आकृति के आकार की आवश्यक संपत्ति है।

एक और उदाहरण:

 abstract class Widget { void render(); } class Container extends Widget { @override void render() { print('Renders container'); } } class Text extends Widget { @override void render('Render text'); } 

यहाँ एक आवश्यक संपत्ति विजेट का उद्देश्य है।

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

ऐसा करने के लिए, आप, निश्चित रूप से, वंशानुक्रम का उपयोग कर सकते हैं और सबसे पहले PaintableShape और PaintableWidget लागू कर सकते PaintableWidget । लेकिन यह सुविधाजनक नहीं है, क्योंकि, सबसे पहले, हमें दोनों पदानुक्रमों में रंग की कार्यक्षमता के कार्यान्वयन की नकल करनी होगी, और, दूसरी बात, प्रत्येक आकृति और विजेट के लिए जिसे हम रंग देना चाहते हैं, हमें नई कक्षाओं को लागू करना होगा, उदाहरण के लिए, PaintableRect और PaintableContainer ।

आप इंटरफेस को लागू करने के लिए तंत्र का उपयोग कर सकते हैं। तब हमें कुछ ऐसा मिलता है:

 enum Color {red, yellow, green} abstract class Paintable { void paint(Color color); Color get color; } class PaintableRect extends Rectangle implements Paintable { Color _color; @override void paint(Color color) {_color = color;} @override Color get color => _color; } class PaintableContainer extends Container implements Paintable { Color _color; @override void paint(Color color) {_color = color;} @override Color get color => _color; } 

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

लेकिन इन सभी समस्याओं को हल किया जा सकता है यदि एक महत्वहीन संपत्ति से जुड़े कार्यात्मक को एक अलग मिश्रण (मिक्सचर) के रूप में हटा दिया जाए:

 enum Color {red, yellow, green} mixin PaintableMixin { Color _color; void paint(Color color) {_color = color;} Color get color => _color; } class PaintableRect extends Rectangle with PaintableMixin { @override void draw() { print('Draw rectangle with color $color'); } } class PaintableContainer extends Container with PaintableMixin { @override void render() { print('Render container with color $color'); } } 

अब आप इसका उपयोग कर सकते हैं:

 main() { PaintableRect() ..paint(Color.red) ..draw(); PaintableContainer() ..paint(Color.yellow) ..render(); } 

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

मान लें कि हमें उसी संपत्ति से संबंधित कार्यक्षमता को कुछ विजेट में जोड़ने की आवश्यकता है। स्पंदन में विजेट निम्नानुसार निर्मित होते हैं:

 class MyStatelessWidget extends StatelessWidget {} 

या

 class MyStatefulWidget extends StatefulWidget {} 

विरासत के माध्यम से एक संपत्ति जोड़ने के लिए, आपको कम से कम दो वर्गों को लागू करना होगा:

 class StatelessWidgetWithProperty extends StatelessWidget {} class StatefulWidgetWithPropery extends StatefulWidget {} 

उसी समय, जैसा कि आप फिर से देख सकते हैं, आपको अतिरिक्त संपत्ति के साथ जुड़े कार्यक्षमता की नकल करनी होगी।

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

 mixin Property {} class MyStatelessWidget extends StatelessWidget with Propery {} class MyStatefulWidget extends StatefulWidget with Property {} 

उन लोगों के लिए जो डिज़ाइन पैटर्न से परिचित हैं, कुछ मामलों में अशुद्धियों का उपयोग ब्रिज पैटर्न के उपयोग को बदल सकता है।

अंत में, यह ध्यान दिया जाना चाहिए कि इस तरह से एक बार में कई अलग-अलग गुणों के कार्यात्मक में मिश्रण कर सकते हैं मनमाना संयोजन।

यह लेख संपूर्ण रूप से अशुद्धियों के उपयोग को परिभाषित नहीं करता है। संभवतः डेवलपर का पूछताछ करने वाला दिमाग उनके लिए कई और सुंदर उपयोग खोजने में सक्षम होगा। मुझे खुशी होगी कि अगर अशुद्धियों का उपयोग करने के लिए ये विकल्प इस लेख में टिप्पणियों में दिखाई दें।