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

मैं मुख्य के साथ शुरू करूँगा, मेरी राय में, जंग की विशेषताएं
मैं दिलचस्प वाक्यविन्यास विवरणों का वर्णन करूंगा
मैं समझाऊंगा कि रस्ट को दुनिया में लेने की संभावना क्यों नहीं है

मैं अभी समझाता हूं कि मैं लगभग दस वर्षों से जावा में लिख रहा हूं, इसलिए मैं अपने घंटी टॉवर से बहस करूंगा।

हत्यारा सुविधा

Rust निम्न-स्तरीय भाषाओं जैसे C / C ++ और उच्च-स्तरीय Java / C # / Python / Ruby ... के बीच एक मध्यवर्ती स्थिति लेने की कोशिश कर रहा है ... भाषा हार्डवेयर के जितना करीब होती है, उतना ही अधिक नियंत्रण, यह भविष्यवाणी करना आसान है कि कोड कैसे निष्पादित करेगा। लेकिन अपने पैर को शूट करने के लिए मेमोरी तक पूरी पहुंच होना बहुत आसान है। सी / सी ++ के विपरीत, पायथन / जावा और शेष सभी दिखाई दिए। उन्हें मेमोरी साफ़ करने के बारे में सोचने की ज़रूरत नहीं है। सबसे बुरी बात एनपीई है, लीक यह आम नहीं है। लेकिन इसके लिए काम करने के लिए, आपको कम से कम, एक कचरा उठाने वाले की आवश्यकता होती है, जो बदले में, उपयोगकर्ता कोड के समानांतर, अपनी भविष्यवाणी को कम करते हुए, अपना जीवन जीना शुरू कर देता है। वर्चुअल मशीन अभी भी प्लेटफ़ॉर्म स्वतंत्रता प्रदान करती है, लेकिन इसकी कितनी आवश्यकता है, यह एक महत्वपूर्ण बिंदु है, मैंने इसे अभी नहीं बढ़ाया है।

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

स्मृति प्रबंधन के मूल में एक वस्तु संदर्भ के मालिक और उधार लेने का विचार है। यदि केवल एक चर प्रत्येक वस्तु का मालिक है, तो जैसे ही यह ब्लॉक के अंत में समाप्त हो जाता है, वह सब कुछ जो इसे इंगित करता है पुनरावर्ती रूप से साफ किया जा सकता है। लिंक को पढ़ने या लिखने के लिए भी उधार लिया जा सकता है। यहाँ एक लेखक और कई पाठकों के सिद्धांत काम करते हैं।

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

fn main() { test(); println!("End of main") } fn test() { let a = MyStruct { v: 1, s: Box::new( Some(MyStruct { v: 2, s: Box::new(None), }) ), }; println!("End of test") } struct MyStruct { v: i32, s: Box<Option<MyStruct>>, } impl Drop for MyStruct { fn drop(&mut self) { println!("Cleaning {}", self.v) } }

निष्कर्ष इस प्रकार होगा:

 End of test Cleaning 1 Cleaning 2 End of main

यानी परीक्षण () से बाहर निकलने से पहले , मेमोरी को पुन: साफ़ कर दिया गया था। संकलक ने आवश्यक कोड डालकर इस पर ध्यान दिया। बॉक्स और विकल्प क्या है, थोड़ी देर बाद वर्णन करेगा।

इस तरह, रस्ट उच्च-स्तरीय भाषाओं से सुरक्षा लेती है और निम्न-स्तरीय प्रोग्रामिंग भाषाओं से पूर्वानुमानित होती है।

और क्या दिलचस्प है

इसके बाद, मैं अपने विचार में, महत्व के अवरोही क्रम में भाषा की विशेषताओं को सूचीबद्ध करूंगा।

OOP

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

डेटा के संयोजन के लिए, ऐसी संरचनाएँ हैं जिनमें कार्यान्वयन हो सकता है। इंटरफेस को लक्षण कहा जाता है और इसमें डिफ़ॉल्ट कार्यान्वयन भी हो सकते हैं। वे अमूर्त वर्गों तक नहीं पहुँचते, क्योंकि इसमें फ़ील्ड नहीं हो सकते, इस प्रतिबंध के बारे में कई लोग शिकायत करते हैं। सिंटैक्स निम्नानुसार है, मुझे लगता है कि टिप्पणियों की यहां आवश्यकता नहीं है:

 fn main() { MyPrinter { value: 10 }.print(); } trait Printer { fn print(&self); } impl Printer { fn print(&self) { println!("hello!") } } struct MyPrinter { value: i32 } impl Printer for MyPrinter { fn print(&self) { println!("{}", self.value) } }

जिन विशेषताओं पर मैंने गौर किया, वे निम्नलिखित पर ध्यान देने योग्य हैं:

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

कुछ और सुरक्षा

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

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

 let mut x = Some(2); let y = x.take(); assert_eq!(x, None); assert_eq!(y, Some(2));

स्थानांतरण

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

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

ऐसे मूल्यों के प्रसंस्करण के लिए एक विशेष निर्माण है:

 fn main() { let a = Some(1); match a { None => println!("empty"), Some(v) => println!("{}", v) } }

साथ ही

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

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

मरहम में उड़ना

यह अनुभाग चित्र को पूरा करने के लिए आवश्यक है।

हत्यारे की समस्या

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

बॉक्स - ढेर पर एक अपरिवर्तनीय मूल्य, जावा में आदिम के लिए रैपर का एक एनालॉग
सेल - चर मूल्य
RefCell - संदर्भ द्वारा सुलभ चर मान
आरसी - संदर्भ काउंटर, एक वस्तु के कई संदर्भों के लिए

और यह एक अधूरी सूची है। पहले जंग के नमूने के लिए, मैंने लापरवाही से बुनियादी तरीकों से एक एकल लिंक की गई सूची लिखने का फैसला किया। अंत में, नोड के लिंक के परिणामस्वरूप निम्नलिखित विकल्प <Rc <RefCell <ListNode> >> :

विकल्प - एक खाली लिंक को संसाधित करने के लिए
आरसी - कई लिंक के लिए, के रूप में पिछले नोड को पिछले नोड और शीट द्वारा संदर्भित किया जाता है
RefCell - परस्पर लिंक के लिए
ListNode - अगला तत्व स्वयं

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

 struct ListNode { val: i32, next: Node, } pub struct LinkedList { root: Node, last: Node, } type Node = Option<Rc<RefCell<ListNode>>>; impl LinkedList { pub fn add(mut self, val: i32) -> LinkedList { let n = Rc::new(RefCell::new(ListNode { val: val, next: None })); if (self.root.is_none()){ self.root = Some(n.clone()); } self.last.map(|v| { v.borrow_mut().next = Some(n.clone()) }); self.last = Some(n); self } ...

कोटलिन पर, एक बहुत सरल दिखता है:

 public fun add(value: Int) { val newNode = ListNode(null, value); root = root ?: newNode; last?.next = newNode last = newNode; }

जैसा कि मुझे बाद में पता चला, ऐसी संरचनाएं रूस्ट के लिए विशिष्ट नहीं हैं, और मेरा कोड पूरी तरह से गैर-मुहावरेदार है। लोग भी पूरे लेख लिखते हैं:

यहाँ जंग सुरक्षा के लिए पठनीयता का त्याग करती है। इसके अलावा, ऐसे अभ्यास अभी भी लूप किए गए लिंक को जन्म दे सकते हैं जो स्मृति में लटकाते हैं, क्योंकि कोई कचरा बीनने वाला उन्हें नहीं ले जाएगा। मैंने रस्ट में वर्किंग कोड नहीं लिखा, इसलिए मेरे लिए यह कहना मुश्किल है कि इस तरह की मुश्किलें जीवन को कितना जटिल बनाती हैं। यह दिलचस्प होगा कि अभ्यास करने वाले इंजीनियरों से टिप्पणियां प्राप्त करें।

सीखने में कठिनाई

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

अंत में

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

यह करें

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

आदर

यदि आप रूस्ट में रुचि रखते हैं, तो यहां कुछ लिंक दिए गए हैं:

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

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

जंग के लिए पहला कदम