रस्ट का उपयोग करने के 10 अप्रकाशित लाभ

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

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

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

1. भाषा की सार्वभौमिकता

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

आइए, रस्ट का उपयोग करने के कुछ सरल उदाहरण देखें।

तत्वों के जोड़े पर दो पुनरावृत्तियों को एक पुनरावृत्ति में संयोजित करने का एक उदाहरण:

let zipper: Vec<_> = (1..).zip("foo".chars()).collect(); assert_eq!((1, 'f'), zipper[0]); assert_eq!((2, 'o'), zipper[1]); assert_eq!((3, 'o'), zipper[2]); 

प्रारंभ

नोट: प्रारूप name!(...) लिए एक कॉल name!(...) एक कार्यात्मक मैक्रो के लिए एक कॉल है। रस्ट में ऐसे मैक्रोज़ के नाम हमेशा एक प्रतीक के साथ समाप्त होते हैं ! ताकि वे फ़ंक्शन नाम और अन्य पहचानकर्ताओं से अलग हो सकें। मैक्रोज़ के उपयोग के लाभों पर नीचे चर्चा की जाएगी।

नियमित अभिव्यक्ति के साथ काम करने के लिए बाहरी regex लाइब्रेरी का उपयोग करने का एक उदाहरण:

 extern crate regex; use regex::Regex; let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap(); assert!(re.is_match("2018-12-06")); 

प्रारंभ

अतिरिक्त ऑपरेटर को ओवरलोड करने के लिए स्वयं Point संरचना के लिए Add के कार्यान्वयन का एक उदाहरण:

 use std::ops::Add; struct Point { x: i32, y: i32, } impl Add for Point { type Output = Point; fn add(self, other: Point) -> Point { Point { x: self.x + other.x, y: self.y + other.y } } } let p1 = Point { x: 1, y: 0 }; let p2 = Point { x: 2, y: 3 }; let p3 = p1 + p2; 

प्रारंभ

एक संरचना में एक सामान्य प्रकार का उपयोग करने का एक उदाहरण:

 struct Point<T> { x: T, y: T, } let int_origin = Point { x: 0, y: 0 }; let float_origin = Point { x: 0.0, y: 0.0 }; 

प्रारंभ

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

2. सुविधाजनक निर्माण और निर्भरता प्रबंधन उपकरण

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

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

कार्गो कॉन्फ़िगरेशन फ़ाइल प्रोजेक्ट सेटिंग्स का वर्णन करने के लिए अनुकूल और न्यूनतम टोलमार्क मार्कअप भाषा का उपयोग करता है। यहाँ एक विशिष्ट Cargo.toml विन्यास Cargo.toml का एक उदाहरण Cargo.toml गया Cargo.toml :

 [package] name = "some_app" version = "0.1.0" authors = ["Your Name <you@example.com>"] [dependencies] regex = "1.0" chrono = "0.4" [dev-dependencies] rand = "*" 

और नीचे कार्गो का उपयोग करने के लिए तीन विशिष्ट आदेश दिए गए हैं:

 $ cargo check $ cargo test $ cargo run 

उनकी मदद से, संकलन त्रुटियों के लिए स्रोत कोड, परियोजना की विधानसभा और परीक्षणों की शुरूआत, क्रमशः निष्पादन के लिए कार्यक्रम की विधानसभा और लॉन्च की जाँच की जाएगी।

3. निर्मित परीक्षण

रस्ट में इकाई परीक्षण लिखना इतना आसान और सरल है कि आप इसे बार-बार करना चाहते हैं। :) अक्सर दूसरे तरीके से कार्यक्षमता का परीक्षण करने की कोशिश करने की तुलना में एक इकाई परीक्षण लिखना आसान होगा। यहाँ उनके लिए कार्यों और परीक्षणों का एक उदाहरण है:

 pub fn is_false(a: bool) -> bool { !a } pub fn add_two(a: i32) -> i32 { a + 2 } #[cfg(test)] mod test { use super::*; #[test] fn is_false_works() { assert!(is_false(false)); assert!(!is_false(true)); } #[test] fn add_two_works() { assert_eq!(1, add_two(-1)); assert_eq!(2, add_two(0)); assert_eq!(4, add_two(2)); } } 

प्रारंभ

test मॉड्यूल में कार्य, #[test] विशेषता के साथ चिह्नित हैं, इकाई परीक्षण हैं। cargo test कमांड को बुलाए जाने पर उन्हें समानांतर में निष्पादित किया जाएगा। सशर्त संकलन विशेषता #[cfg(test)] , जो परीक्षणों के साथ पूरे मॉड्यूल को चिह्नित करता है, इस तथ्य को जन्म देगा कि मॉड्यूल केवल तभी संकलित किया जाएगा जब परीक्षण निष्पादित किए जाते हैं, और सामान्य विधानसभा में नहीं मिलेगा।

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

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

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

4. वर्तमान उदाहरणों के साथ अच्छा प्रलेखन

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

 /// Returns a byte slice of this `String`'s contents. /// /// The inverse of this method is [`from_utf8`]. /// /// [`from_utf8`]: #method.from_utf8 /// /// # Examples /// /// Basic usage: /// /// ``` /// let s = String::from("hello"); /// /// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes()); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn as_bytes(&self) -> &[u8] { &self.vec } 

प्रलेखन

प्रकार String के as_bytes पद्धति का उपयोग करने का एक उदाहरण यहां दिया गया है

 let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes()); 

परीक्षण के शुभारंभ के दौरान एक परीक्षण के रूप में निष्पादित किया जाएगा।

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

5. स्मार्ट ऑटो-प्रकार की कटौती

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

 let mut vec = Vec::new(); let text = "Message"; vec.push(text); 

प्रारंभ

यदि हम प्रकार एनोटेशन की व्यवस्था करते हैं, तो यह उदाहरण इस तरह दिखेगा:

 let mut vec: Vec<&str> = Vec::new(); let text: &str = "Message"; vec.push(text); 

यही है, हमारे पास स्ट्रिंग स्लाइस का एक वेक्टर है और प्रकार स्ट्रिंग स्लाइस का एक चर है। लेकिन इस मामले में, प्रकार निर्दिष्ट करना पूरी तरह से बेमानी है, क्योंकि कंपाइलर उन्हें अपने आप से आउटपुट कर सकते हैं ( हिंडले-मिलनर एल्गोरिदम के विस्तारित संस्करण का उपयोग करके)। तथ्य यह है कि vec एक वेक्टर है, Vec::new() से वापसी मान के प्रकार से पहले से ही स्पष्ट है, लेकिन यह अभी तक स्पष्ट नहीं है कि इसके तत्व किस प्रकार के होंगे। तथ्य यह है कि text प्रकार एक स्ट्रिंग टुकड़ा है इस तथ्य से समझ में आता है कि इसे इस प्रकार का शाब्दिक रूप सौंपा गया है। इस प्रकार, vec.push(text) बाद, वेक्टर तत्वों का प्रकार स्पष्ट हो जाता है। ध्यान दें कि vec चर का प्रकार निष्पादन थ्रेड में इसके उपयोग से पूरी तरह से निर्धारित किया गया था, और आरम्भिक अवस्था में नहीं।

इस तरह की एक प्रणाली का आविष्कार कोड से शोर को समाप्त करता है और इसे कुछ गतिशील रूप से टाइप की गई प्रोग्रामिंग भाषा में कोड के रूप में संक्षिप्त बनाता है। और यह सख्त स्थिर टाइपिंग को बनाए रखते हुए!

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

6. चर घोषणा बिंदुओं पर पैटर्न का मिलान

ऑपरेशन करते हैं

 let p = Point::new(); 

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

 let Point { x, y } = Point::new(); 

प्रारंभ

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

 let [a, b, _] = [1, 2, 3]; 

और भी बहुत कुछ करना है। सबसे उल्लेखनीय बात यह है कि इस तरह की तुलनाएं उन सभी स्थानों पर की जाती हैं, जहां नए चर नाम रुस्त में दर्ज किए जा सकते हैं, अर्थात्: match , let , if let , while let if let , लूप के हेडर में, फ़ंक्शन और क्लोजर के तर्कों में। यहाँ लूप के for लूप से मेल खाते पैटर्न का उपयोग कर उदाहरण दिया गया है:

 for (i, ch) in "foo".chars().enumerate() { println!("Index: {}, char: {}", i, ch); } 

प्रारंभ

enumerate विधि, जिसे इट्रेटर पर कहा जाता है, एक नया ईटरेटर बनाता है, जो प्रारंभिक मूल्यों पर नहीं, बल्कि टुपल्स, जोड़े "ऑर्डिनल इंडेक्स, प्रारंभिक मूल्य" पर प्रसारित करेगा। चक्र की पुनरावृत्ति के दौरान इनमें से प्रत्येक ट्यूपल्स को निर्दिष्ट पैटर्न (i, ch) मैप किया जाएगा, जिसके परिणामस्वरूप चर i को टुपल से पहला मान प्राप्त होगा - सूचकांक, और चर ch - दूसरा, वह, स्ट्रिंग का चरित्र। लूप के शरीर में आगे हम इन चर का उपयोग कर सकते हैं।

लूप के for पैटर्न का उपयोग करने का एक और लोकप्रिय उदाहरण:

 for _ in 0..5 { //   5  } 

यहाँ हम _ पैटर्न का उपयोग करके पुनरावृति के मान को अनदेखा करते हैं। क्योंकि हम लूप के शरीर में पुनरावृति संख्या का उपयोग नहीं करते हैं। एक ही किया जा सकता है, उदाहरण के लिए, एक फ़ंक्शन तर्क के साथ:

 fn foo(a: i32, _: bool) { //      } 

या match स्टेटमेंट में match करते समय:

 match p { Point { x: 1, .. } => println!("Point with x == 1 detected"), Point { y: 2, .. } => println!("Point with x != 1 and y == 2 detected"), _ => (), //        } 

प्रारंभ

पैटर्न का मिलान कोड को बहुत कॉम्पैक्ट और अभिव्यंजक बनाता है, और match स्टेटमेंट में यह आमतौर पर अपूरणीय है। match ऑपरेटर पूर्ण परिवर्तनशील विश्लेषण का एक ऑपरेटर है, इसलिए आप गलती से इसमें विश्लेषण किए गए अभिव्यक्ति के लिए कुछ संभावित मैचों की जांच करना नहीं भूल पाएंगे।

7. सिंटैक्स एक्सटेंशन और कस्टम डीएसएल

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

 println!("Hello, {name}! Do you know about {}?", 42, name = "User"); 

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

 let name = "Bob"; let result = js! { var msg = "Hello from JS, " + @{name} + "!"; console.log(msg); alert(msg); return 2 + 2; }; println!("2 + 2 = {:?}", result); 

मैक्रों js! stdweb पैकेज में परिभाषित किया गया है और यह आपको अपने प्रोग्राम में पूर्ण-विकसित जावास्क्रिप्ट कोड को एम्बेड करने की अनुमति देता है (एकल-उद्धृत स्ट्रिंग्स और ऑपरेटरों को एक अर्धविराम के साथ पूरा नहीं किया जाता है) और वाक्यविन्यास @{expr} का उपयोग करके रस्ट कोड से ऑब्जेक्ट का उपयोग करें।

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

8. निर्भर कोड की ऑटो-पीढ़ी

रस्ट के प्रक्रियात्मक व्युत्पन्न मैक्रोज़ को व्यापक रूप से लक्षण और अन्य कोड पीढ़ी को स्वचालित रूप से लागू करने के लिए उपयोग किया जाता है। यहाँ एक उदाहरण है:

 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)] struct Point { x: i32, y: i32, } 

चूंकि मानक पुस्तकालय से मानक पुस्तकालय से इन सभी प्रकारों ( Copy , Clone , Debug , Default , PartialEq और Eq ) को लागू किया जाता है, इसलिए उनका कार्यान्वयन पूरे ढांचे के लिए स्वचालित रूप से संपूर्ण रूप में प्रदर्शित किया जा सकता है। एक और उदाहरण:

 extern crate serde_derive; extern crate serde_json; use serde_derive::{Serialize, Deserialize}; #[derive(Serialize, Deserialize)] struct Point { x: i32, y: i32, } let point = Point { x: 1, y: 2 }; //  Point  JSON . let serialized = serde_json::to_string(&point).unwrap(); assert_eq!("{\"x\":1,\"y\":2}", serialized); //  JSON   Point. let deserialized: Point = serde_json::from_str(&serialized).unwrap(); 

प्रारंभ

यहाँ, Point संरचना के लिए serde लाइब्रेरी से Deserialize और Deserialize का उपयोग करते हुए, इसके क्रमांकन और deserialization के तरीके स्वतः उत्पन्न होते हैं। फिर आप इस संरचना का एक उदाहरण विभिन्न क्रमांकन कार्यों के लिए पारित कर सकते हैं, उदाहरण के लिए, इसे JSON स्ट्रिंग में परिवर्तित करना।

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

9. बीजगणितीय डेटा प्रकार

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

 enum Message { Quit, ChangeColor(i32, i32, i32), Move { x: i32, y: i32 }, Write(String), } 

Message के एक चर के विशेष मूल्य का प्रकार Message में सूचीबद्ध संरचना प्रकारों में से केवल एक हो सकता है। यह या तो एक यूनिट-जैसा फ़ील्डलेस Quit स्ट्रक्चर है, जो चेंजकोलर में से एक है या टैंपल स्ट्रक्चर को ChangeColor फील्ड या सामान्य Move स्ट्रक्चर के साथ Write । एक पारंपरिक एन्यूमरेटेड प्रकार को बीजीय डेटा प्रकार के विशेष मामले के रूप में दर्शाया जा सकता है:

 enum Color { Red, Green, Blue, White, Black, Unknown, } 

यह पता लगाना संभव है कि पैटर्न मिलान के उपयोग से किसी विशेष मामले में वास्तव में किस प्रकार का मूल्य लिया गया है:

 let color: Color = get_color(); let text = match color { Color::Red => "Red", Color::Green => "Green", Color::Blue => "Blue", _ => "Other color", }; println!("{}", text); ... fn process_message(msg: Message) { match msg { Message::Quit => quit(), Message::ChangeColor(r, g, b) => change_color(r, g, b), Message::Move { x, y } => move_cursor(x, y), Message::Write(s) => println!("{}", s), }; } 

प्रारंभ

बीजीय डेटा प्रकारों के रूप में, रस्ट Option और Result जैसे महत्वपूर्ण प्रकारों को लागू करता है, जिनका उपयोग क्रमशः लापता मूल्य और सही / गलत परिणाम का प्रतिनिधित्व करने के लिए किया जाता है। मानक पुस्तकालय में Option को कैसे परिभाषित किया गया है:

 pub enum Option<T> { None, Some(T), } 

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

 fn divide(numerator: f64, denominator: f64) -> Option<f64> { if denominator == 0.0 { None } else { Some(numerator / denominator) } } let result = divide(2.0, 3.0); match result { Some(x) => println!("Result: {}", x), None => println!("Cannot divide by 0"), } 

प्रारंभ

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

10. आसान रीफैक्टरिंग

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

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