Rust 2025: शुरुआती लोगों के लिए शून्य से पूर्ण गाइड

परिचय: क्यों Rust 2025 की पसंद है

2025 में, Rust दुनिया भर के डेवलपर्स के दिलों पर लगातार राज कर रहा है। Stack Overflow के वार्षिक सर्वेक्षण के अनुसार, Rust को लगातार आठवें वर्ष सबसे पसंदीदा प्रोग्रामिंग भाषा के रूप में मान्यता दी गई है। इसके मुख्य तुरुप के पत्ते हैं — गार्बेज कलेक्टर के बिना मेमोरी सुरक्षा और अत्यधिक उच्च प्रदर्शन, जो C और C++ के बराबर है। यदि आप Python से परिचित हैं, लेकिन तेज़ और विश्वसनीय सिस्टम एप्लिकेशन, वेब असेंबलर या यहां तक कि ऑपरेटिंग सिस्टम लिखना सीखना चाहते हैं — तो Rust आपका आदर्श अगला कदम होगा।

इस लेख में, हम जानेंगे कि 2025 में Rust सीखना कहाँ से शुरू करें: टूलचेन कैसे स्थापित करें, अपना पहला प्रोग्राम कैसे लिखें और प्रमुख अवधारणाओं को कैसे समझें। चलिए शुरू करते हैं!

1. Rust की स्थापना और Cargo से परिचय

पहली चीज़ जो आपको करनी है वह है कंपाइलर rustc और पैकेज मैनेजर Cargo स्थापित करना। 2025 में, यह प्रक्रिया अत्यंत सरल हो गई है।

rustup के माध्यम से स्थापना

आधिकारिक और अनुशंसित तरीका rustup उपयोगिता का उपयोग करना है। टर्मिनल खोलें और यह कमांड चलाएँ:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

स्क्रिप्ट डिफ़ॉल्ट सेटिंग्स सुझाएगी — बस Enter दबाएँ। स्थापना के बाद, टर्मिनल को पुनः लोड करें या यह चलाएँ:

source $HOME/.cargo/env

जाँच करें कि सब कुछ काम कर रहा है:

rustc --version
cargo --version

पहला प्रोग्राम: "Hello, world!"

Cargo का उपयोग करके एक नया प्रोजेक्ट बनाएँ:

cargo new hello_rust
cd hello_rust

Cargo एक डायरेक्टरी संरचना बनाएगा। फ़ाइल src/main.rs खोलें — इसमें पहले से ही एक टेम्पलेट है:

fn main() {
    println!("Hello, world!");
}

एक ही कमांड से प्रोग्राम को बनाएँ और चलाएँ:

cargo run

आपको वह प्रतिष्ठित अभिवादन दिखाई देगा। बधाई हो, आपने Rust में अपना पहला प्रोग्राम लिखा है!

2. Rust सिंटैक्स की मूल बातें: वेरिएबल, प्रकार और फंक्शन

Rust एक सख्त स्टैटिक टाइपिंग वाली भाषा है, लेकिन कंपाइलर अक्सर स्वयं प्रकारों का अनुमान लगाता है। आइए बुनियादी संरचनाओं को समझें।

वेरिएबल और अपरिवर्तनीयता

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

fn main() {
    let x = 5;          // अपरिवर्तनीय वेरिएबल
    // x = 6;           // त्रुटि! बदला नहीं जा सकता
    let mut y = 10;     // परिवर्तनीय वेरिएबल (mut)
    y += 5;             // अब y = 15
    println!("x = {}, y = {}", x, y);
}

डेटा प्रकार

Rust परिचित प्रकारों का समर्थन करता है: पूर्णांक (i32, u64), फ़्लोटिंग-पॉइंट संख्याएँ (f64), बूलियन (bool), कैरेक्टर (char) और स्ट्रिंग्स (String, &str)।

fn main() {
    let a: i32 = -42;          // साइन वाला पूर्णांक
    let b: u8 = 255;           // 8-बिट अहस्ताक्षरित
    let c: f64 = 3.1415;       // double
    let is_rust_cool = true;   // bool
    let letter = 'R';          // char (4 बाइट्स, Unicode)
    let greeting = String::from("Привет, Rust!");
    println!("{} {} {} {} {} {}", a, b, c, is_rust_cool, letter, greeting);
}

फंक्शन

फंक्शन को fn कीवर्ड के साथ घोषित किया जाता है। रिटर्न वैल्यू का प्रकार एरो -> के बाद निर्दिष्ट किया जाता है।

fn add(x: i32, y: i32) -> i32 {
    x + y   // अंतिम अभिव्यक्ति return है (सेमीकोलन के बिना)
}

fn main() {
    let sum = add(10, 20);
    println!("10 + 20 = {}", sum);
}

3. मुख्य अवधारणा: स्वामित्व और उधार लेना

Rust में सबसे जटिल, लेकिन सबसे महत्वपूर्ण विषय स्वामित्व प्रणाली (ownership) है। यही वह चीज़ है जो गार्बेज कलेक्टर के बिना मेमोरी सुरक्षा की गारंटी देती है।