डार्ट भाषा सुविधाएँ

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

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

कंस्ट्रक्टर्स

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

स्वचालित फ़ील्ड इनिशियलाइज़ेशन

आरंभ करने के लिए, उबाऊ दोहराव से छुटकारा पाएं। कंस्ट्रक्टर्स अक्सर तर्क लेते हैं और बस अपने मूल्यों को क्लास फील्ड में असाइन करते हैं:

class Point { num x, y; Point(num x, num y) { this.x = x; this.y = y; } } 

हमें फील्ड को इनिशियलाइज़ करने के लिए सिर्फ x चार बार टाइप करना था। यह बेकार है! ऐसा करने के लिए बेहतर है:

 class Point { num x, y; Point(this.x, this.y); } 

यदि कंस्ट्रक्टर तर्क सूची में, this. तर्क नाम से पहले है this. , इस नाम के साथ एक फ़ील्ड को तर्क मान के साथ स्वचालित रूप से प्रारंभ किया जाएगा। हमारे उदाहरण में, एक और छोटी चाल का उपयोग किया गया था - यदि कंस्ट्रक्टर बॉडी खाली है, तो आप इसका उपयोग कर सकते हैं ; इसके बजाय {} ।

जिसका नाम कंस्ट्रक्टर्स रखा गया है

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

 class Point { num x, y; Point(this.x, this.y); Point.zero() : x = 0, y = 0; Point.polar(num theta, num radius) { x = Math.cos(theta) * radius; y = Math.sin(theta) * radius; } } 

Point क्लास में तीन कंस्ट्रक्टर हैं - नियमित और दो नामित। यहां उनका उपयोग करने का तरीका बताया गया है:

 var a = new Point(1, 2); var b = new Point.zero(); var c = new Point.polar(Math.PI, 4.0); 

ध्यान दें कि हम new नामांकित कंस्ट्रक्टरों के साथ उपयोग करते हैं, ये साधारण स्थिर तरीके नहीं हैं।

कारखाने के निर्माता

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

डार्ट आपको ऑब्जेक्ट बनाए गए स्थान पर कोड को बदले बिना ऐसा करने की अनुमति देता है। आप एक फैक्ट्री कंस्ट्रक्टर बना सकते हैं जिसे रेगुलर कंस्ट्रक्टर की तरह ही कहा जाता है। उदाहरण के लिए:

 class Symbol { final String name; static Map<String, Symbol> _cache; factory Symbol(String name) { if (_cache == null) { _cache = {}; } if (_cache.containsKey(name)) { return _cache[name]; } else { final symbol = new Symbol._internal(name); _cache[name] = symbol; return symbol; } } Symbol._internal(this.name); } 

हमने Symbol वर्ग को परिभाषित किया है। एक चरित्र एक स्ट्रिंग के समान है, लेकिन हम यह गारंटी देना चाहते हैं कि किसी भी समय दिए गए नाम के साथ केवल एक ही चरित्र है। इससे पात्रों की समानता के लिए सुरक्षित रूप से जांच करना संभव हो जाता है, बस यह सुनिश्चित करना कि वे एक ही वस्तु की ओर इशारा करते हैं।

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

यह अच्छा है कि यह सब कॉलिंग कोड के लिए पारदर्शी है:

 var a = new Symbol('something'); var b = new Symbol('something'); 

दूसरा कॉल वास्तव में एक नया चरित्र नहीं बनाता है, लेकिन मौजूदा को वापस लौटाता है। यह सुविधाजनक है, क्योंकि अगर पहले हमें किसी फैक्ट्री कंस्ट्रक्टर की जरूरत नहीं थी, और फिर यह पता चला कि एक था, तो हमें स्टैटिक फैक्ट्री मेथड को कॉल करने के लिए कोड में कहीं new नहीं बदलना होगा।

कार्यों

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

डार्ट में फ़ंक्शन बनाने के तीन तरीके हैं। पहले का नाम कार्य है:

 void sayGreeting(String salutation, String name) { final greeting = '$salutation $name'; print(greeting); } 

यह सी या जावा या जावास्क्रिप्ट में एक विधि में एक नियमित फ़ंक्शन घोषणा की तरह दिखता है। C और C ++ के विपरीत, फ़ंक्शन घोषणाओं को नेस्टेड किया जा सकता है। दूसरा तरीका अनाम कार्य है:

 window.on.click.add((event) { print('You clicked the window.'); }) 

इस उदाहरण में, हम एक इवेंट हैंडलर के रूप में add() विधि में एक अनाम फ़ंक्शन पास करते add() । अंत में, एकल अभिव्यक्ति वाले छोटे कार्यों के लिए, एक हल्का वाक्यविन्यास है:

 var items = [1, 2, 3, 4, 5]; var odd = items.filter((i) => i % 2 == 1); print(odd); // [1, 3, 5] 

एक तीर ( => ) के बाद कोष्ठक में एक तर्क और एक फ़ंक्शन एक फ़ंक्शन बनाता है जो इस तर्क को लेता है और अभिव्यक्ति का मूल्यांकन करने का परिणाम देता है।

व्यवहार में, हम जहाँ भी संभव हो तीर संकेतन का उपयोग करना पसंद करते हैं, क्योंकि इसकी संक्षिप्तता (अभिव्यंजना के अवरोध के लिए नहीं)। हम अक्सर ईवेंट हैंडलर और कॉलबैक के लिए अनाम फ़ंक्शंस का उपयोग करते हैं। नामित कार्यों का उपयोग शायद ही कभी किया जाता है।

डार्ट में एक और चाल है (यह मेरी पसंदीदा भाषा सुविधाओं में से एक है) - आप वर्ग के सदस्यों को परिभाषित करने के लिए => का उपयोग कर सकते हैं। बेशक, आप इसे इस तरह से कर सकते हैं:

 class Rectangle { num width, height; bool contains(num x, num y) { return (x < width) && (y < height); } num area() { return width * height; } } 

लेकिन क्यों, यदि संभव हो तो, इस तरह:

 class Rectangle { num width, height; bool contains(num x, num y) => (x < width) && (y < height); num area() => width * height; } 

हमें साधारण गेटर्स / सेटर और अन्य सिंगल-लाइन फ़ंक्शंस को परिभाषित करने के लिए एरो नोटेशन बढ़िया लगता है।

फील्ड, गेटर्स और सेटर

गुणों के साथ काम करने के लिए, डार्ट फॉर्म object.someProperty मानक सिंटैक्स का उपयोग करता है। डार्ट में, आप उन तरीकों को परिभाषित कर सकते हैं जो एक क्लास फ़ील्ड को कॉल की तरह दिखेंगे, लेकिन एक ही समय में मनमाने कोड को निष्पादित करते हैं। अन्य भाषाओं की तरह, इस तरह के तरीकों को गेटर्स और सेटर कहा जाता है:

 class Rectangle { num left, top, width, height; num get right() => left + width; set right(num value) => left = value - width; num get bottom() => top + height; set bottom(num value) => top = value - height; Rectangle(this.left, this.top, this.width, this.height); } 

हमारे पास चार "वास्तविक" गुणों के साथ एक Rectangle वर्ग है - left , top , width और height और दो तार्किक गुण गेटर्स और सेटर के रूप में - right और bottom । कक्षा का उपयोग करते समय, प्राकृतिक क्षेत्रों और गेटर्स और सेटर के बीच कोई स्पष्ट अंतर नहीं होता है:

 var rect = new Rectangle(3, 4, 20, 15); print(rect.left); print(rect.bottom); rect.top = 6; rect.right = 12; 

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

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

बाद में, यदि सत्यापन या ऐसा कुछ करना आवश्यक हो जाता है, तो आप इस क्षेत्र को हमेशा एक गेट्टर और सेटर के साथ बदल सकते हैं। उदाहरण के लिए, हम चाहते हैं कि हमारा Rectangle वर्ग हमेशा एक गैर-ऋणात्मक आकार का हो:

 class Rectangle { num left, top; num _width, _height; num get width() => _width; set width(num value) { if (value < 0) throw 'Width cannot be negative.'; _width = value; } num get height() => _height; set height(num value) { if (value < 0) throw 'Height cannot be negative.'; _height = value; } num get right() => left + width; set right(num value) => left = value - width; num get bottom() => top + height; set bottom(num value) => top = value - height; Rectangle(this.left, this.top, this._width, this._height); } 

हमने कहीं और कोड बदलने की आवश्यकता के बिना वर्ग में सत्यापन जोड़ा।

शीर्ष स्तर की परिभाषाएँ

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

 num abs(num value) => value < 0 ? -value : value; final TWO_PI = Math.PI * 2.0; int get today() { final date = new DateTime.now(); return date.day; } 

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

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

हमारे पास शीर्ष-स्तरीय परिभाषाओं का उपयोग करने के कुछ उदाहरण हैं। सबसे पहले, यह main() । DOM के साथ काम करते समय, "वैरिएबल" document और window टॉप लेवल पर परिभाषित गेटर्स होते हैं।

पंक्तियों और अंतर्वेशन

डार्ट में कई प्रकार के स्ट्रिंग शाब्दिक हैं। आप दोहरे और एकल उद्धरणों के साथ-साथ बहु-पंक्ति शाब्दिक के लिए ट्रिपल उद्धरण का उपयोग कर सकते हैं:

 'I am a "string"' "I'm one too" '''I'm on multiple lines ''' """ As am I """ 

एक में कई पंक्तियों को संयोजित करने के लिए, आप संघनन का उपयोग कर सकते हैं:

 var name = 'Fred'; var salutation = 'Hi'; var greeting = salutation + ', ' + name; 

लेकिन प्रक्षेप स्वच्छ और तेज होगा:

 var name = 'Fred'; var salutation = 'Hi'; var greeting = '$salutation, $name'; 

डॉलर चिह्न ( $ ) के स्थान पर, चर नाम के बाद, चर मान प्रतिस्थापित किया जाएगा (यदि यह एक स्ट्रिंग नहीं है, toString() विधि कहा जाएगा)। घुंघराले कोष्ठक के अंदर आप भाव डाल सकते हैं:

 var r = 2; print('The area of a circle with radius $r is ${Math.PI * r * r}'); 

ऑपरेटरों

डार्ट समान प्राथमिकताओं के साथ, सी, जावा और अन्य समान भाषाओं के साथ एक ही ऑपरेटर का उपयोग करता है। जैसा आप अपेक्षा करेंगे वैसा ही वे व्यवहार करेंगे। हालांकि, आंतरिक कार्यान्वयन की अपनी विशेषताएं हैं। डार्ट में, फॉर्म 1 + 2 एक ऑपरेटर के साथ एक अभिव्यक्ति एक विधि को कॉल करने के लिए सिर्फ वाक्यविन्यास चीनी है। भाषा के दृष्टिकोण से, यह उदाहरण 1.+(2) जैसा दिखता है।

इसका मतलब है कि आप अपने प्रकार का निर्माण करके अधिकांश ऑपरेटरों को अधिभारित कर सकते हैं। उदाहरण के लिए, Vector वर्ग:

 class Vector { num x, y; Vector(this.x, this.y); operator +(Vector other) => new Vector(x + other.x, y + other.y); } 

अब हम सामान्य वाक्यविन्यास का उपयोग करके वैक्टर जोड़ सकते हैं:

 var position = new Vector(3, 4); var velocity = new Vector(1, 2); var newPosition = position + velocity; 

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

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

यह ध्यान देने योग्य है कि, चूंकि ऑपरेटर विधि कॉल करते हैं, इसलिए वे शुरू में असममित हैं। एक विधि खोज हमेशा बाएं तर्क के लिए की जाती है। इसलिए जब आप a + b लिखते हैं, तो ऑपरेशन का अर्थ a के प्रकार पर निर्भर करता a ।

समानता

ऑपरेटरों के इस सेट पर विशेष ध्यान दिया जाना चाहिए। डार्ट में दो जोड़े समानता ऑपरेटर हैं: == और != और === और !== । जावास्क्रिप्ट प्रोग्रामर से परिचित हैं, लेकिन यहां वे थोड़ा अलग तरीके से काम करते हैं।

== और != तुल्यता के लिए जाँच करने के लिए काम करते हैं। 99% समय आप उनका उपयोग करेंगे। जावास्क्रिप्ट के विपरीत, वे कोई अंतर्निहित रूपांतरण नहीं करते हैं, इसलिए वे अधिक अनुमानित व्यवहार करेंगे। उनका उपयोग करने से डरो मत! जावा के विपरीत, वे किसी भी प्रकार के साथ काम करते हैं जिसके लिए एक समतुल्य संबंध परिभाषित किया गया है। कोई और नहीं कुछ someString.equals("something") ।

यदि आप समझ में आता है कि आप अपने प्रकार के लिए == अधिभार कर सकते हैं। ओवरलोड करने की कोई आवश्यकता नहीं है != , डार्ट स्वचालित रूप से इसे == से हटा देगा।

ऑपरेटरों की दूसरी जोड़ी, === और !== , पहचान के लिए जाँच करने का कार्य करती है। a === b तभी true लौटेगा जब a और b मेमोरी में समान ऑब्जेक्ट हों। आपको शायद ही कभी उन्हें अभ्यास में उपयोग करना पड़ता है। डिफ़ॉल्ट रूप से, == पर निर्भर करता है === यदि कोई समतुल्य संबंध प्रकार के लिए परिभाषित नहीं है, तो === केवल मामले में आवश्यक होगा - उपयोगकर्ता को ओवरराइड करने के लिए == ।