Rust ट्यूटोरियल
Rust के साथ शुरुआत करना

टिप्पणियों

संस्करण

Println का उन्नत उपयोग!

println! (और इसका सहोदर, print! ) पाठ का निर्माण और मुद्रण के लिए एक सुविधाजनक तंत्र प्रदान करता है जिसमें गतिशील डेटा होता है, जो कई अन्य भाषाओं में पाए जाने वाले कार्यों के printf परिवार के समान है। इसका पहला तर्क एक प्रारूप स्ट्रिंग है , जो यह बताता है कि पाठ के रूप में अन्य तर्कों को कैसे मुद्रित किया जाना चाहिए। प्रारूप स्ट्रिंग में प्लेसहोल्डर ( {} में संलग्न) हो सकता है यह निर्दिष्ट करने के लिए कि प्रतिस्थापन होना चाहिए:

// No substitution -- the simplest kind of format string
println!("Hello World");
// Output: Hello World

// The first {} is substituted with a textual representation of
// the first argument following the format string. The second {}
// is substituted with the second argument, and so on.
println!("{} {} {}", "Hello", true, 42);
// Output: Hello true 42

इस बिंदु पर, आप पूछ सकते हैं: कैसे println! बुलियन मान मुद्रित करने के लिए पता है true स्ट्रिंग के रूप में "सही"? {} वास्तव में फॉर्मेटर को निर्देश है कि Display विशेषता का उपयोग करके मूल्य को पाठ में परिवर्तित किया जाना चाहिए। यह विशेषता सबसे आदिम जंग प्रकार (तार, संख्या, बूलियन, आदि) के लिए लागू की जाती है, और "उपयोगकर्ता-सामना आउटपुट" के लिए होती है। इसलिए, संख्या 42 को दशमलव में 42 के रूप में मुद्रित किया जाएगा, और नहीं, बाइनरी में कहें, जो कि आंतरिक रूप से संग्रहीत है।

हम प्रकार कैसे प्रिंट करते हैं, फिर, Display लागू नहीं करते हैं , उदाहरण स्लाइस ( [i32] ), वैक्टर ( Vec<i32> ), या विकल्प ( Option<&str> )? इनका कोई स्पष्ट उपयोगकर्ता-सामना करने वाला पाठ-निरूपण नहीं है (अर्थात जिसे आप वाक्य में तुच्छ रूप से सम्मिलित कर सकते हैं)। ऐसे मूल्यों के मुद्रण की सुविधा के लिए, रस्ट में भी Debug गुण है, और इसी {:?} प्लेसहोल्डर है। प्रलेखन से: " Debug को प्रोग्रामर-फेसिंग, डीबगिंग संदर्भ में आउटपुट को प्रारूपित करना चाहिए।" आइए देखते हैं कुछ उदाहरण:

println!("{:?}", vec!["a", "b", "c"]);
// Output: ["a", "b", "c"]

println!("{:?}", Some("fantastic"));
// Output: Some("fantastic")

println!("{:?}", "Hello");
// Output: "Hello"
// Notice the quotation marks around "Hello" that indicate
// that a string was printed.

Debug में एक अंतर्निहित सुंदर-प्रिंट तंत्र भी है, जिसे आप कोलन के बाद # संशोधक का उपयोग करके सक्षम कर सकते हैं:

println!("{:#?}", vec![Some("Hello"), None, Some("World")]);
// Output: [
//    Some(
//        "Hello"
//    ),
//    None,
//    Some(
//        "World"
//    )
// ]

प्रारूप के तार आपको काफी जटिल प्रतिस्थापन व्यक्त करने की अनुमति देते हैं:

// You can specify the position of arguments using numerical indexes.
println!("{1} {0}", "World", "Hello");
// Output: Hello World

// You can use named arguments with format
println!("{greeting} {who}!", greeting="Hello", who="World");
// Output: Hello World

// You can mix Debug and Display prints:
println!("{greeting} {1:?}, {0}", "and welcome", Some(42), greeting="Hello");
// Output: Hello Some(42), and welcome

println! और दोस्त आपको चेतावनी देंगे कि अगर आप कुछ ऐसा करने की कोशिश कर रहे हैं जो काम नहीं करेगा, बजाय रनटाइम के दुर्घटनाग्रस्त होने के:

// This does not compile, since we don't use the second argument.
println!("{}", "Hello World", "ignored");

// This does not compile, since we don't give the second argument.
println!("{} {}", "Hello");

// This does not compile, since Option type does not implement Display
println!("{}", Some(42));

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

let x: String = format!("{} {}", "Hello", 42);
assert_eq!(x, "Hello 42");

मैक्रो के बिना कंसोल आउटपुट

// use Write trait that contains write() function
use std::io::Write;

fn main() {
    std::io::stdout().write(b"Hello, world!\n").unwrap();
}

• std::io::Write विशेषता उन वस्तुओं के लिए डिज़ाइन की गई है जो बाइट धाराओं को स्वीकार करते हैं। इस स्थिति में, मानक आउटपुट का एक हैंडल std::io::stdout() साथ प्राप्त किया जाता है।

• Write::write() एक बाइट स्लाइस ( &[u8] Write::write() स्वीकार करता है, जो बाइट-स्ट्रिंग शाब्दिक ( b"<string>" ) के साथ बनाया गया है। Write::write() एक Result<usize, IoError> देता है Result<usize, IoError> , जिसमें या तो लिखी गई बाइट की संख्या (सफलता पर) या त्रुटि मान (विफलता पर) शामिल है।

• Result::unwrap() का Result::unwrap() इंगित करता है कि कॉल सफल होने की उम्मीद है ( Result<usize, IoError> -> usize ), और मान को त्याग दिया गया है।

न्यूनतम उदाहरण

hello.rs में पारंपरिक हैलो वर्ल्ड प्रोग्राम लिखने के लिए, hello.rs नामक एक पाठ फ़ाइल बनाएँ। इसमें निम्न स्रोत कोड होते हैं:

fn main() {
    println!("Hello World!");
}

यह main नामक एक नए फ़ंक्शन को परिभाषित करता है, जो कोई पैरामीटर नहीं लेता है और कोई डेटा नहीं देता है। यह वह जगह है जहां आपके कार्यक्रम को चलाने के दौरान निष्पादन शुरू होता है। इसके अंदर, आपके पास एक println! , जो एक मैक्रो है जो टेक्स्ट को कंसोल में प्रिंट करता है।

एक बाइनरी एप्लिकेशन को जेनरेट करने के लिए, रस्ट कंपाइलर को सोर्स फाइल के नाम से पास करें।

$ rustc hello.rs

परिणामी निष्पादन योग्य का मुख्य स्रोत मॉड्यूल के समान नाम होगा, इसलिए लिनक्स या मैकओएस सिस्टम पर प्रोग्राम चलाने के लिए, रन करें:

$ ./hello
Hello World!

Windows सिस्टम पर, चलाएँ:

C:\Rust> hello.exe
Hello World!

शुरू करना

स्थापित कर रहा है

इससे पहले कि आप रस्ट प्रोग्रामिंग भाषा का उपयोग करके कुछ भी कर सकते हैं, आपको इसे हासिल करने की आवश्यकता है- या तो विंडोज के लिए या यूनिक्स जैसी प्रणालियों पर अपने टर्मिनल का उपयोग करके, जहां $ टर्मिनल में इनपुट का प्रतीक है:

$ curl https://sh.rustup.rs -sSf | sh

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

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

जंग संकलक

अब हम यह देखने के लिए जाँच कर सकते हैं कि क्या वास्तव में रस्ट वास्तव में हमारे कंप्यूटर पर हमारे टर्मिनल में निम्नलिखित कमांड को चलाकर स्थापित किया गया था - यदि UNIX- या कमांड प्रॉम्प्ट पर - यदि विंडोज़ पर:

$ rustc --version

क्या यह आदेश सफल होना चाहिए, हमारे कंप्यूटर पर स्थापित रस्ट के संकलक का संस्करण हमारी आंखों के सामने प्रदर्शित किया जाएगा।

माल

Rust के साथ कार्गो आता है, जो एक बिल्ड टूल है जिसका उपयोग आपके Rust पैकेज और प्रोजेक्ट को प्रबंधित करने के लिए किया जाता है। यह सुनिश्चित करने के लिए, आपके कंप्यूटर पर भी मौजूद है, कंसोल के अंदर निम्नलिखित चलाएँ- कंसोल या तो टर्मिनल या कमांड प्रॉम्प्ट पर निर्भर करता है कि आप किस सिस्टम पर निर्भर हैं:

$ cargo --version

रस्ट कंपाइलर के समतुल्य कमांड की तरह, यह कार्गो के वर्तमान संस्करण को लौटाएगा और प्रदर्शित करेगा।

अपना पहला कार्गो प्रोजेक्ट बनाने के लिए, आप कार्गो में जा सकते हैं।

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