Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है जिसे प्रदर्शन, सुरक्षा और समवर्तीता के लिए डिज़ाइन किया गया है। यह उपयोगकर्ताओं को शक्तिशाली भाषा सुविधाएँ प्रदान करती है जबकि सामान्य प्रोग्रामिंग त्रुटियों, जैसे कि नल पॉइंटर डेरिफरेंस और डेटा रेस, को समाप्त करने का प्रयास करती है। Rust शून्य-लागत अमूर्तताओं पर जोर देती है, जिससे डेवलपर्स उच्च-स्तरीय कोड लिख सकते हैं बिना प्रदर्शन का बलिदान किए। यह विशेष रूप से उन कार्यों के लिए उपयुक्त है जहाँ हार्डवेयर और मेमोरी प्रबंधन का निम्न-स्तरीय नियंत्रण आवश्यक है, जैसे कि सिस्टम प्रोग्रामिंग, वेब असेंबली, और उच्च-प्रदर्शन अनुप्रयोगों का निर्माण।
Rust का विचार 2006 में ग्रेइडन होरे द्वारा मोज़िला रिसर्च में किया गया था। भाषा का प्रारंभिक उद्देश्य सुरक्षित समवर्ती सॉफ़्टवेयर विकसित करने की चुनौतियों का समाधान करना और मौजूदा सिस्टम प्रोग्रामिंग भाषाओं के लिए एक अधिक विश्वसनीय विकल्प बनाना था। 2010 में, Rust का पहला सार्वजनिक संस्करण जारी किया गया, और इसने मेमोरी सुरक्षा और समवर्तीता के लिए अपने नवोन्मेषी दृष्टिकोण के लिए तेजी से ध्यान आकर्षित किया।
Rust कई प्रोग्रामिंग भाषाओं से प्रेरणा लेती है, जैसे कि प्रदर्शन-उन्मुख डिज़ाइन के लिए C++ और अपरिवर्तनीयता और शक्तिशाली अमूर्तताओं पर जोर देने के लिए कार्यात्मक प्रोग्रामिंग भाषाएँ। इसका डिज़ाइन Haskell जैसी भाषाओं के सिद्धांतों को भी दर्शाता है, विशेष रूप से इसके मजबूत प्रकार प्रणाली और पैटर्न मिलान क्षमताओं में।
अपने निर्माण के बाद से, Rust एक व्यापक रूप से मान्यता प्राप्त भाषा में विकसित हो गई है, जिसमें एक मजबूत डेवलपर समुदाय और बढ़ती पुस्तकालय पारिस्थितिकी है। इस भाषा को मोज़िला द्वारा आधिकारिक रूप से समर्थन प्राप्त है और यह विभिन्न क्षेत्रों में लोकप्रियता प्राप्त कर रही है, जिसमें वेब विकास, एम्बेडेड सिस्टम, और गेम विकास शामिल हैं। 2015 में Rust 1.0 का विमोचन एक महत्वपूर्ण मील का पत्थर था, जिसने इसकी स्थिरता और उत्पादन उपयोग के लिए तत्परता को मजबूत किया। 2021 में स्थापित Rust फाउंडेशन इसके निरंतर विकास और शासन का समर्थन करता है।
Rust का अद्वितीय स्वामित्व मॉडल डेवलपर्स को बिना गारबेज कलेक्टर के मेमोरी प्रबंधित करने की अनुमति देता है। Rust में प्रत्येक चर का एक ही मालिक होता है, और स्वामित्व को संदर्भों के माध्यम से स्थानांतरित या "उधार" लिया जा सकता है। यह विशेषता सख्त उधारी नियमों को लागू करके मेमोरी सुरक्षा सुनिश्चित करने में मदद करती है।
fn main() {
let s1 = String::from("Hello");
let s2 = &s1; // s1 को उधार लेना
println!("{}", s2);
}
Rust में पैटर्न मिलान डेवलपर्स को डेटा प्रकारों को विघटित करने और जटिल नियंत्रण प्रवाह को सहजता से प्रबंधित करने की अनुमति देता है। match कथन मूल्य पैटर्न के आधार पर तर्क को शाखाबद्ध करने का एक शक्तिशाली तरीका प्रदान करता है।
fn main() {
let number = 4;
match number {
1 => println!("One"),
2 => println!("Two"),
_ => println!("Other"),
}
}
Rust प्रकार अनुमान का उपयोग करता है, जिससे संकलक स्वचालित रूप से चर के प्रकार का अनुमान लगा सकता है, जो कोड को सरल बनाता है और पठनीयता को बढ़ाता है।
fn main() {
let x = 5; // संकलक अनुमान लगाता है कि x का प्रकार i32 है
}
गुण अन्य भाषाओं में इंटरफेस के समान होते हैं और बहुरूपता की अनुमति देते हैं। वे साझा व्यवहार को परिभाषित करते हैं जिसे प्रकार लागू कर सकते हैं।
trait Speak {
fn speak(&self);
}
struct Dog;
impl Speak for Dog {
fn speak(&self) {
println!("Woof!");
}
}
Rust के Option और Result प्रकार मजबूत त्रुटि प्रबंधन और नल-सुरक्षित प्रोग्रामिंग पैरेडाइम प्रदान करते हैं, जिससे डेवलपर्स अनुपस्थिति या त्रुटि की संभावना को स्पष्ट रूप से व्यक्त कर सकते हैं।
fn divide(x: f64, y: f64) -> Option<f64> {
if y == 0.0 {
None
} else {
Some(x / y)
}
}
Rust अपने स्वामित्व प्रणाली के माध्यम से निर्भीक समवर्तीता का समर्थन करता है, जिससे कई थ्रेड डेटा पर न्यूनतम डेटा रेस के जोखिम के साथ कार्य कर सकते हैं।
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Hello from a thread!");
});
handle.join().unwrap();
}
Rust का मैक्रो सिस्टम कोड जनरेशन की अनुमति देता है, जिससे कस्टम सिंटैक्स संरचनाएँ लिखना संभव हो जाता है जिन्हें कोडबेस में पुन: उपयोग किया जा सकता है।
macro_rules! say_hello {
() => {
println!("Hello!");
};
}
fn main() {
say_hello!();
}
Rust में क्लोजर्स अनाम फ़ंक्शन होते हैं जो अपने वातावरण से चर को कैप्चर कर सकते हैं, जिससे वे कार्यात्मक प्रोग्रामिंग पैरेडाइम के लिए लचीले होते हैं।
fn main() {
let add = |a, b| a + b;
println!("{}", add(5, 7));
}
Rust कोड को व्यवस्थित करने और दृश्यता को नियंत्रित करने के लिए एक मॉड्यूल सिस्टम का उपयोग करता है। क्रेट्स Rust कोड के पैकेज होते हैं जिन्हें साझा और पुन: उपयोग किया जा सकता है।
mod my_module {
pub fn hello() {
println!("Hello from my_module!");
}
}
fn main() {
my_module::hello();
}
Rust में अंतर्निहित दस्तावेज़ीकरण सुविधाएँ हैं, और Rustdoc उपकरण स्वचालित रूप से स्रोत कोड में टिप्पणियों से दस्तावेज़ीकरण उत्पन्न करता है।
/// यह फ़ंक्शन दो संख्याएँ जोड़ता है.
///
/// # उदाहरण
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
a + b
}
Rust में डेवलपर उपकरणों का एक समृद्ध सेट है, जिसमें इसका पैकेज प्रबंधक, Cargo, शामिल है, जो निर्भरता प्रबंधन, निर्माण, और पुस्तकालयों और अनुप्रयोगों को प्रकाशित करने में सहायता करता है। Rust मानक पुस्तकालय विभिन्न कार्यों के लिए प्रचुर रनटाइम समर्थन प्रदान करता है।
कई IDEs और संपादक Rust विकास का समर्थन करते हैं, जिनमें शामिल हैं:
एक नया Rust प्रोजेक्ट बनाने के लिए, डेवलपर्स Cargo का उपयोग निम्नलिखित कमांड के साथ कर सकते हैं:
cargo new my_project
यह कमांड एक नए निर्देशिका का निर्माण करता है जिसमें एक बुनियादी Rust प्रोजेक्ट संरचना होती है। परियोजना का निर्माण करने के लिए, बस परियोजना निर्देशिका में जाएँ और चलाएँ:
cargo build
Rust अपने प्रदर्शन और सुरक्षा सुविधाओं के कारण विभिन्न क्षेत्रों में उपयोग किया जाता है। प्रमुख अनुप्रयोगों में शामिल हैं:
Rust को अक्सर अन्य सिस्टम प्रोग्रामिंग भाषाओं के साथ इसकी प्रदर्शन और सुरक्षा पर जोर देने के कारण तुलना की जाती है। यहाँ कुछ तुलना हैं:
Rust कोड को अन्य भाषाओं में अनुवाद करना इसकी अद्वितीय स्वामित्व मॉडल और उन्नत सुविधाओं के कारण चुनौतीपूर्ण हो सकता है। हालाँकि, कुछ उपकरण स्रोत से स्रोत अनुवाद को सुविधाजनक बनाते हैं, जैसे: