रस्ट लिखना शुरू करने के लिए वह सब कुछ जो आपको जानना चाहिए

2015 में रिलीज़ होने के बाद से, रस्ट ने डेवलपर्स की पसंदीदा प्रोग्रामिंग भाषाओं में से एक के रूप में लोकप्रियता हासिल की है। रस्ट सहज और संक्षिप्त सिंटैक्स के साथ उत्कृष्ट प्रदर्शन और सुरक्षा सुविधाएँ प्रदान करता है जो भाषा को वांछनीय बनाते हैं।

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

जंग के साथ शुरुआत करना

रस्ट एक क्रॉस-प्लेटफ़ॉर्म प्रोग्रामिंग भाषा है जो अधिकांश ऑपरेटिंग सिस्टम पर चलती है। रस्ट के साथ आरंभ करने के लिए, अधिकारी के पास जाएँ जंग वेबसाइट और अपने ऑपरेटिंग सिस्टम के लिए पसंदीदा संस्करण स्थापित करें।

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

जंग में चर और स्थिरांक

जंग अत्यधिक अभिव्यंजक है, और चर घोषित करने के कई तरीके हैं। आप उपयोग कर सकते हैं होने देना चर घोषित करने के लिए कीवर्ड।

यहां बताया गया है कि आप रस्ट में चर कैसे घोषित कर सकते हैं:

होने देना ए: डोरी;
होने देना बी: i32;
होने देना सी: () = ();

ए और बी चर क्रमशः एक स्ट्रिंग और एक पूर्णांक हैं। सी चर एक जंग इकाई प्रकार है जो कार्यों और अभिव्यक्तियों के लिए प्लेसहोल्डर के रूप में कार्य करता है।

वैकल्पिक डेटा प्रकार की घोषणा के बाद, आप एक समान चिह्न का उपयोग करके मूल्यों के साथ चर घोषित और आरंभ कर सकते हैं।

fnमुख्य(){
होने देना आयु: डोरी = डोरी::से("पांच वर्षीय");
होने देना उम्र = 5; // समतुल्य उम्र देने के लिए: i32 = 5;
प्रिंटल!("{}", आयु);
}

कार्यक्रम दो घोषित करता है आयु मुद्रण से पहले चर प्रिंटल! मैक्रो। पहला आयु चर डेटा प्रकार निर्दिष्ट करता है, और दूसरा नहीं।

जब आप इसे घोषित करते हैं तो आपको चर के डेटा प्रकार को निर्दिष्ट करने की आवश्यकता नहीं होती है। रस्ट कंपाइलर संकलन समय पर मान के डेटा प्रकार से प्रकार का अनुमान लगाता है।

आप इसके साथ रस्ट में स्थिरांक भी घोषित कर सकते हैं कॉन्स्ट चर घोषित करने के समान ही कीवर्ड:

कॉन्स्ट आयु: &एसटीआर = "पांच वर्षीय";

आप उस चर के मान को संशोधित नहीं कर सकते जिसे आप स्थिर घोषित करते हैं।

जंग एकल-पंक्ति और ब्लॉक टिप्पणियों के लिए कार्यक्षमता प्रदान करता है। आप डबल फ़ॉरवर्ड स्लैश का उपयोग कर सकते हैं (//) सिंगल-लाइन टिप्पणियों के लिए:

fnमुख्य() {
// यह एक पंक्ति टिप्पणी है
होने देना एक्स = 5; // यह टिप्पणी `x` चर के उद्देश्य की व्याख्या करती है
}

बहु-पंक्ति टिप्पणियों (टिप्पणियों को ब्लॉक करें) के लिए, एक फ़ॉरवर्ड स्लैश का उपयोग करें जिसके बाद एक तारांकन चिह्न (/*) और एक तारक चिह्न के साथ ब्लॉक को बंद करें और उसके बाद एक फ़ॉरवर्ड स्लैश (*/):

fnमुख्य() {
/*
 यह एक ब्लॉक टिप्पणी है जो कई पंक्तियों में फैली हुई है।
 यह अक्सर कोड के एक बड़े ब्लॉक का वर्णन करने के लिए प्रयोग किया जाता है।
 */
होने देना एक्स = 5;
}

आपकी टिप्पणियाँ संक्षिप्त और सीधी होनी चाहिए।

जंग में सारणियाँ

Arrays समान डेटा प्रकार के तत्वों का एक निश्चित आकार का संग्रह है। जंग डिफ़ॉल्ट रूप से ढेर पर सरणी आवंटित करता है।

यहां बताया गया है कि आप रस्ट में सरणियों की घोषणा कैसे कर सकते हैं:

fnमुख्य() {
होने देना संख्या = [1, 2, 3, 4, 5];
}

नंबर सरणी में पाँच आइटम हैं। आप सरणी में किसी स्थान पर उसके अनुक्रमणिका का उपयोग करके मान तक पहुँच सकते हैं:

fnमुख्य() {
होने देना संख्या = [1, 2, 3, 4, 5];
होने देना एक्स = संख्या [3];
प्रिंटल!("{}", एक्स)
}

मुख्य फ़ंक्शन प्रिंट करता है एक्स चर जो सरणी के चौथे तत्व तक पहुँचता है।

जंग में वैक्टर

जंग सरणी की सीमाओं को कवर करने के लिए वैक्टर प्रदान करता है। वेक्टर गतिशील रूप से आकार के होते हैं; वे आवश्यकतानुसार बढ़ और सिकुड़ सकते हैं।

यहां बताया गया है कि आप जंग में वैक्टर कैसे घोषित कर सकते हैं:

fnमुख्य() {
होने देना my_vec: वी.ई.सी<i32> = वीसी![1, 2, 3, 4, 5];
होने देना एक्स = my_vec [3];
प्रिंटल!("{}", एक्स)
}

my_vec वेक्टर 32-बिट पूर्णांक का वेक्टर है। एक्स चर सदिश के चौथे तत्व तक पहुँचता है, और मुख्य फ़ंक्शन मान को कंसोल पर प्रिंट करता है।

जंग के सशर्त बयान

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

यहाँ एक है अगर बयान जो दो पूर्णांकों की समानता के आधार पर एक स्ट्रिंग को कंसोल पर प्रिंट करता है।

fnमुख्य() {
होने देना ए: i32 = 12;
अगर एक == 12 {
प्रिंटल!("एक बारह के बराबर");
 }
}

मुख्य फ़ंक्शन स्ट्रिंग को प्रिंट करता है प्रिंटल! मैक्रो क्योंकि चर 12 के बराबर है।

आप उपयोग कर सकते हैं अन्य कीवर्ड उन मामलों को संभालने के लिए जहां अगर बयान झूठा मूल्यांकन करता है:

fnमुख्य() {
होने देना ए: i32 = 12;
अगर एक == 123 {
प्रिंटल!("एक बारह के बराबर");
 } अन्य {
प्रिंटल!("एक बारह के बराबर नहीं है");
 }
}

इस उदाहरण में, अन्य कथन चलता है क्योंकि a का मान 123 के बराबर नहीं है।

आप के साथ मैच स्टेटमेंट घोषित कर सकते हैं मिलान जटिल शर्तों के लिए कीवर्ड:

fnमुख्य() {
होने देना आयु: i32 = 7;
मिलान आयु {
1 => प्रिंटल!("एक"),
2 => प्रिंटल!("दो"),
3 => प्रिंटल!("तीन"),
 _ => प्रिंटल!("शून्य"),
 }
}

मुख्य समारोह से मेल खाता है आयु में मामलों के लिए चर मिलान बयान और मूल्य से मेल खाने वाली अभिव्यक्ति को निष्पादित करता है। अंडरस्कोर (_) डिफ़ॉल्ट स्टेटमेंट है जो वैल्यू के लिए मैच होने पर चलता है।

जंग में लूप्स

जंग दोहराए जाने वाले कार्यों के लिए लूप प्रदान करता है। जंग के तीन मुख्य प्रकार हैं: कुंडली, जबकि, और के लिए छोरों।

कुंडली कीवर्ड एक अनंत लूप बनाता है जो ब्रेक कीवर्ड का सामना करने तक चलता है:

fnमुख्य() {
कुंडली {
प्रिंटल!("ब्रेक स्टेटमेंट मिलने तक बार-बार प्रिंट किया जाता है।");
तोड़ना;
 }
}

जबकि लूप आसान है जब आप कोड के एक ब्लॉक को तब तक दोहराना चाहते हैं जब तक कि कोई शर्त सत्य का मूल्यांकन करती है:

fnमुख्य() {
होने देनामुठ गिनती = 0;
जबकि गिनती < 5 {
प्रिंटल!("गिनती {} है", गिनती करना);
 गिनती + = 1;
 }
}

ए के लिए लूप वस्तुओं के संग्रह पर पुनरावृति के लिए अच्छा है, जैसे एक सरणी:

fnमुख्य() {
होने देना संख्या = [1, 2, 3, 4, 5];
के लिए वस्तु में नंबर.इटर () {
प्रिंटल!("वर्तमान वस्तु {} है", वस्तु);
 }
}

यह के लिए लूप के माध्यम से पुनरावृति करता है नंबर सरणी और प्रत्येक आइटम को कंसोल पर प्रिंट करता है।

जंग कार्यों की घोषणा और आह्वान

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

यहां बताया गया है कि आप पैरामीटर और रिटर्न प्रकार के साथ फ़ंक्शन कैसे घोषित कर सकते हैं:

fnजोड़ना(ए: i32, बी: i32) -> i32 {
वापस करना ए + बी;
}

जोड़ना फ़ंक्शन दो 32-बिट पूर्णांक लेता है और 32-बिट पूर्णांक देता है, दो पैरामीटर का योग।

अपने कोड में किसी फ़ंक्शन को कहीं और से कॉल करने के लिए, बस नाम और तर्क निर्दिष्ट करें (यदि कोई हो):

fnमुख्य() {
होने देना परिणाम = जोड़ (2, 3);
प्रिंटल!("2 + 3 = {}", परिणाम);
}

परिणाम वेरिएबल कॉल करने से परिणाम रखता है जोड़ना समारोह। मुख्य फ़ंक्शन का उपयोग करके परिणाम को कंसोल पर प्रिंट करता है प्रिंटल! मैक्रो।

जंग में संरचनाएं

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

यहां बताया गया है कि आप किसी संरचना की घोषणा कैसे कर सकते हैं:

structव्यक्ति {
 नाम: डोरी,
 आयु: यू32,
 is_male: बूल,
}

व्यक्ति संरचना में तीन क्षेत्र होते हैं: एक स्ट्रिंग, एक अहस्ताक्षरित 32-बिट पूर्णांक और एक बूलियन।

संरचना को परिभाषित करने के बाद, आप अपने कार्यक्रम के अन्य भागों में इसके उदाहरण बना सकते हैं:

fnमुख्य() {
होने देना व्यक्ति 1 = व्यक्ति {
 नाम: डोरी::से("कैंडेस फ्लिन"),
 आयु: 16,
 is_male: असत्य,
 };
}

व्यक्ति1 चर का एक उदाहरण है व्यक्ति संरचना। इन्स्टेन्शियशन पर, आप स्ट्रक्चर फील्ड्स को वैल्यू असाइन कर सकते हैं। आप जितनी चाहें उतनी संरचना के उदाहरण बना सकते हैं।

आप OOP अवधारणाओं को जंग में लागू कर सकते हैं

जंग लचीला है, और आप ओओपी अवधारणाओं को जंग में अंतर्निहित डेटा संरचनाओं जैसे स्ट्रक्चर्स के साथ लागू कर सकते हैं।

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