रस्ट प्रदर्शन, विश्वसनीयता और सुरक्षा के लिए डिजाइन की गई स्टैटिकली-टाइप की गई आधुनिक प्रोग्रामिंग लैंग्वेज है। अन्य वैधानिक रूप से टाइप की गई भाषाओं की तरह, आप संकलन समय पर रस्ट डेटा प्रकारों की घोषणा करते हैं। इससे आपके द्वारा अपना कोड चलाने से पहले प्रकार की त्रुटियों को पकड़ना आसान हो जाता है।
रस्ट स्केलर, कंपाउंड, रेफरेंस टाइप, स्ट्रक्चर्स, एनम और स्ट्रिंग्स प्रदान करता है। इसका प्रकार अनुमान सांख्यिकीय रूप से टाइप की गई भाषा की सुरक्षा को बनाए रखते हुए संक्षिप्त कोड लिखने के लिए कार्यक्षमता प्रदान करता है।
जंग में पूर्णांक
जंग बिट्स की संख्या के आधार पर वर्गीकृत हस्ताक्षरित और अहस्ताक्षरित पूर्णांक प्रकार प्रदान करता है। हस्ताक्षरित पूर्णांक प्रकार हैं i8, i16, i32, और i64 क्रमशः 8-बिट, 16-बिट, 32-बिट और 64-बिट हस्ताक्षरित पूर्णांक का प्रतिनिधित्व करते हैं। यह अहस्ताक्षरित पूर्णांक प्रकारों का भी समर्थन करता है यू8, यू 16, यू32, और u64, 8-बिट, 16-बिट, 32-बिट और 64-बिट अहस्ताक्षरित पूर्णांकों का प्रतिनिधित्व करता है।
// हस्ताक्षरित पूर्णांक
होने देना ए: i8 = -10;
होने देना बी: i16 = -2048;
होने देना सी: i32 = -2147483648;
होने देना डी: i64 = -9223372036854775808;
// अहस्ताक्षरित पूर्णांक
होने देना ई: यू 8 = 255;
होने देना एफ: यू 16 = 65535;
होने देना जी: यू 32 = 4294967295;
होने देना एच: यू 64 = 18446744073709551615;
जंग का उपयोग करता है i32 डिफ़ॉल्ट रूप से पूर्णांक अक्षर के लिए टाइप करें।
रस्ट फ़्लोटिंग पॉइंट प्रकार
जंग प्रदान करता है f32 और f64 फ़्लोटिंग पॉइंट प्रकार के रूप में जो एकल-सटीक और डबल-परिशुद्धता फ़्लोटिंग पॉइंट नंबरों का प्रतिनिधित्व करते हैं। f32 प्रकार मूल्यों को संग्रहीत करने के लिए 32 बिट्स का उपयोग करता है, और f64 टाइप 64 बिट्स का उपयोग करता है।
रस्ट में फ़्लोटिंग-पॉइंट नंबर फ़्लोटिंग-पॉइंट अंकगणित के लिए IEEE 754 मानक का पालन करते हैं।
होने देना एक = 3.14159265358979323_f32;
होने देना बी = 2.718281828459045235_f64;
रस्ट बूलियंस का उपयोग करना
जंग प्रदान करता है बूल प्रतिनिधित्व करने के लिए टाइप करें सत्य या असत्य मान। प्रोग्राम निर्णय लेने के लिए बूलियन का उपयोग अक्सर सशर्त और नियंत्रण प्रवाह विवरण में किया जाता है।
होने देना चर_1: बूल = सत्य;
होने देना चर_2: बूल = असत्य;
आप समानता ऑपरेटर के साथ बूलियन मानों की तुलना कर सकते हैं, ==, और असमानता ऑपरेटर, !=. जंग तुलना ऑपरेटरों को परिभाषित नहीं करता है, , <=, और >=, के लिए बूल मान।
होने देना चर_1: बूल = सत्य;
होने देना चर_2: बूल = असत्य;
अगर चर_1 == चर_2 {
प्रिंटल! ("वैरिएबल_1 वेरिएबल_2 के बराबर है");
} अन्यअगर चर_1! = चर_2 {
प्रिंटल! ("वैरिएबल_1 वेरिएबल_2 के बराबर नहीं है");
}
चार प्रकार
जंग चार प्रकार एकल यूनिकोड स्केलर मान का प्रतिनिधित्व करता है जो किसी भी वर्ण का प्रतिनिधित्व कर सकता है यूनिकोड मानक. आप एक निर्दिष्ट कर सकते हैं चार मूल्य एकल उद्धरण का उपयोग कर।
// एक चार मूल्य घोषित करना
होने देना सी = 'ए';
चार रस्ट में इमोजीस के साथ काम करने के लिए टाइप मददगार है।
जंग में टुपल्स
टपल डेटा संरचना आपको एक से अधिक मानों को एक यौगिक मान में समूहित करने देती है। इन मानों में एक ही प्रकार या विभिन्न प्रकार हो सकते हैं। आप कोष्ठकों से घिरे मूल्यों की अल्पविराम से अलग सूची के रूप में लिखकर टुपल्स की घोषणा कर सकते हैं।
यहां बताया गया है कि आप 32-बिट पूर्णांक, स्ट्रिंग्स और फ्लोट64 मानों के साथ टपल कैसे घोषित कर सकते हैं।
होने देना tup: (i32, &str, f64) = (500, "नमस्ते", 3.14);
टुपल्स की एक निश्चित लंबाई होती है, और आप उनका उपयोग किसी फ़ंक्शन से कई मान वापस करने के लिए कर सकते हैं या एकल तर्क के रूप में फ़ंक्शन के लिए कई मान पास कर सकते हैं।
आप पैटर्न मिलान का उपयोग करके इसे नष्ट करके या डॉट (।) सिंटैक्स और एक इंडेक्स का उपयोग करके व्यक्तिगत तत्वों तक सीधे पहुँच कर टपल के अलग-अलग तत्वों तक पहुँच सकते हैं।
यहां बताया गया है कि आप पैटर्न मिलान का उपयोग करके किसी संरचना के अलग-अलग तत्वों तक कैसे पहुंच सकते हैं:
होने देना my_tuple = (10, "हैलो वर्ल्ड!", असत्य);होने देना (एक्स, वाई, जेड) = my_tuple;
प्रिंटल! ("पहला तत्व है: {}", एक्स);
प्रिंटल! ("दूसरा तत्व है: {}", वाई);
प्रिंटल! ("तीसरा तत्व है: {}", जेड);
डॉट नोटेशन का उपयोग करके आप अलग-अलग तत्वों तक कैसे पहुंच सकते हैं:
होने देना my_tuple = (10, "हैलो वर्ल्ड!", असत्य);
println!("पहलातत्वहै: {}", my_tuple.0);
println!("दूसरातत्वहै: {}", my_tuple.1);
println!("तीसरातत्वहै: {}", my_tuple.2);
संबंधित डेटा को एक मान में समूहीकृत करते समय टुपल्स बहुत उपयोगी होते हैं। यदि आप उनका संयम से उपयोग करते हैं तो वे आपके कोड की पठनीयता में भी सुधार कर सकते हैं।
जंग में सारणियाँ
एक सरणी निश्चित लंबाई के साथ एक ही प्रकार के तत्वों का संग्रह है। आप रस्ट सरणियों को अल्पविराम द्वारा अलग किए गए मानों की वर्ग-कोष्ठक सूची के रूप में लिखते हैं।
यहां बताया गया है कि आप रस्ट में सरणियों की घोषणा कैसे कर सकते हैं:
होने देना आगमन = [1, 2, 3, 4, 5];
एक बार घोषित करने के बाद आप किसी सरणी में तत्वों की संख्या नहीं बदल सकते हैं, लेकिन आप इंडेक्सिंग का उपयोग करके किसी सरणी के अलग-अलग तत्वों तक पहुंच, संशोधन और हेरफेर कर सकते हैं।
होने देना म्यूट my_array = [1, 2, 3, 4, 5];// एक्सेस करने वाले तत्व
println!("पहलातत्वहै: {}", my_array[0]);// तत्वों को संशोधित करना
my_array [0] = 100;
println!("पहलातत्वबादपरिवर्तनहै: {}", my_array[0]);// एक सरणी पर लूपिंग और तत्वों में हेरफेर करना
के लिएमैंमें 0..my_arrayलेन() {
my_array [मैं] * = 2;
}
// सरणी प्रिंट करना
प्रिंटल! ("हेरफेर के बाद सरणी: {:?}", my_array);
रस्ट ऐरे हैं ढेर पर संग्रहीत और एक सन्निहित मेमोरी आवंटन है, इसलिए किसी सरणी के तत्वों तक पहुँच तेज़ और कुशल है। यह सरणियों को उन स्थितियों के लिए उपयुक्त बनाता है जहाँ आपको कई तत्वों को संग्रहीत और संसाधित करने की आवश्यकता होती है।
जंग के टुकड़ों के साथ काम करना
एक टुकड़ा एक डेटा संरचना है जो एक संग्रह में तत्वों के एक सन्निहित अनुक्रम को संदर्भित करने की अनुमति देता है। स्लाइस द्वारा दर्शाया गया है &[टी] प्रकार, जहाँ T स्लाइस में संग्रहीत तत्वों का प्रकार है।
fn मुख्य(){
// एक सरणी घोषित करें
होने देना my_array = [1, 2, 3, 4, 5];// सरणी से एक टुकड़ा बनाएँ
होने देना my_slice = &my_array[1..3];
// टुकड़ा प्रिंट करें
प्रिंटल! ("टुकड़ा: {:?}", my_slice);
}
ध्यान दें कि कैसे रेंज सिंटैक्स, .., आरंभिक अनुक्रमणिका और अंत से बड़ी अनुक्रमणिका का उपयोग करके सरणी से एक स्लाइस निकालता है:
स्लाइस गतिशील हैं, इसलिए रस्ट रनटाइम पर उनकी लंबाई निर्धारित कर सकता है। आप ढेर आवंटन की आवश्यकता के बिना कार्यों के तर्क के रूप में स्लाइस भी पास कर सकते हैं।
आप आमतौर पर स्ट्रिंग ऑपरेशंस के लिए स्लाइस का उपयोग करेंगे और डेटा के सबसेट को फ़ंक्शंस में पास करेंगे। वे रस्ट में संग्रह के प्रबंधन के लिए एक शक्तिशाली और कुशल उपकरण हैं, जो सरणियों के लिए अधिक लचीला विकल्प प्रदान करते हैं।
आप रस्ट में WebAssembly- संचालित फ्रंटएंड वेब ऐप्स बना सकते हैं
डेटा प्रकारों का ज्ञान आपकी रस्ट यात्रा के लिए महत्वपूर्ण है क्योंकि आप एप्लिकेशन बनाते समय अधिकांश कार्यों के लिए उनका उपयोग करेंगे।
WebAssembly एक निम्न-स्तरीय बाइनरी प्रारूप है जो निकट-देशी प्रदर्शन के साथ आधुनिक वेब ब्राउज़र पर चलता है। यह आपको कई अलग-अलग भाषाओं में कोड लिखने और इसे WebAssembly में बदलने की सुविधा देता है।
WebAssembly को रस्ट के माध्यम से अपनाया जा रहा है। यू, सीकैमोर और सीड जैसे कई फ्रेमवर्क हैं जिनका उपयोग आप रस्ट के साथ WebAssembly-संचालित फ्रंटएंड बनाने के लिए कर सकते हैं।
