CodeUtility
कोडिंग को डेवलपर्स के लिए आसान बनाना।!

Online Rust Compiler

Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.

पहले से इंस्टॉल लाइब्रेरी
🚀 252,316 कुल निष्पादन (32 इस महीने)

Udemy Logo ✨ सबसे ज़्यादा पसंद किए जाने वाले Rust कोर्स

लोड हो रहा है…

💡 क्या आप अपने कौशल में सुधार करना चाहते हैं? ये पाठ्यक्रम मदद कर सकते हैं—जब हमारा एआई मॉडल आपके अनुरोध को संसाधित करता है तो इन्हें जांचें।

🦀 इस Rust ऑनलाइन एक्ज़ीक्यूटर के बारे में

CodeUtility Rust Executor आपको अपने ब्राउज़र में सीधे Rust कोड लिखने और चलाने देता है - किसी इंस्टॉलेशन, टूलचेन सेटअप, या लोकल एनवायरनमेंट की जरूरत नहीं। यह एक सुरक्षित सैंडबॉक्स द्वारा संचालित है जो असली Rust कंपाइलर संस्करण 1.70, 1.72, 1.73, और 1.74 को सपोर्ट करता है।

यह टूल क्लाउड में वास्तविक rustc कंपाइलर का उपयोग करके आपके Rust प्रोग्राम्स को कम्पाइल और रन करता है, जिससे सटीक और एकसमान परिणाम मिलते हैं। आप वेरिएबल्स, ओनरशिप, बॉरोइंग, पैटर्न मैचिंग, ट्रेट्स, जेनरिक्स, और अन्य आधुनिक Rust फीचर्स के साथ आसानी से प्रयोग कर सकते हैं।

Rust की मूल अवधारणाएँ सीखने के लिए यह आदर्श है - खासकर मेमोरी सेफ़्टी, एरर हैंडलिंग, और कंकरेन्सी - और इसके लिए आपको Cargo इंस्टॉल करने या कोई लोकल सेटअप करने की ज़रूरत नहीं। सब कुछ कुछ ही सेकंड में सीधे आपके ब्राउज़र में चलता है।

सिर्फ़ एक कोड रनर से कहीं अधिक

एक ही एक्ज़ीक्यूटर में मल्टी-फ़ाइल एडिटर, अलग-थलग निष्पादन टर्मिनल, रनटाइम-विशिष्ट लाइब्रेरी, स्थायी वर्कस्पेस, साझाकरण और रीयल-टाइम सहयोग का उपयोग करें।

इस एक्ज़ीक्यूटर का उपयोग कैसे करें?

रनटाइम चुनें, फ़ाइल खोलें या बनाएँ, अपना कोड लिखें और चलाएँ चुनें। आउटपुट टर्मिनल में दिखाई देता है। साइन-इन उपयोगकर्ता वर्कस्पेस में फ़ाइलें रख सकते हैं, लाइब्रेरी इंस्टॉल कर सकते हैं और शेयर के माध्यम से सहयोग कर सकते हैं।

  1. एक संस्करण चुनें और वर्तमान फ़ाइल संपादित करें या वर्कस्पेस की दूसरी फ़ाइल खोलें।
  2. कोड चलाएँ, माँगे जाने पर टर्मिनल में इनपुट दें और सहेजा गया रन इतिहास देखें।
  3. जब कार्य के लिए एक से अधिक कोड अंश चाहिए, तो लाइब्रेरी, वर्कस्पेस टूल, शेयरिंग और चैट का उपयोग करें।

💡 Rust की बुनियादी बातें और उदाहरण जिन्हें आप ऊपर आज़मा सकते हैं

1. वेरिएबल और कॉन्स्टेंट घोषित करना

वेरिएबल घोषित करने के लिए let का उपयोग करें। const कॉन्स्टेंट के लिए और mut परिवर्तनशील वेरिएबल के लिए।

let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;

const MAX_USERS: u32 = 100;

2. कंडीशनल्स (if / match)

Rust शर्तों के लिए if और पैटर्न मैचिंग के लिए match का उपयोग करता है।

let x = 2;
if x == 1 {
    println!("एक");
} else if x == 2 {
    println!("दो");
} else {
    println!("अन्य");
}

match x {
    1 => println!("एक"),
    2 => println!("दो"),
    _ => println!("अन्य"),
}

3. लूप्स

Rust for, while, और अनंत loop को सपोर्ट करता है।

for i in 0..3 {
    println!("{}", i);
}

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

4. ऐरे

Rust में निश्चित आकार के ऐरे स्क्वेयर ब्रैकेट्स का उपयोग करते हैं। व्यू के लिए slices का उपयोग करें।

let nums = [10, 20, 30];
println!("{}", nums[1]);

5. वेक्टर (डायनामिक ऐरे)

Vec का उपयोग डायनामिक ऐरे के लिए होता है।

let mut fruits = vec!["सेब", "केला"];
fruits.push("चेरी");
fruits.pop();

for fruit in &fruits {
    println!("{}", fruit);
}

6. कंसोल इनपुट/आउटपुट

आउटपुट के लिए println! और इनपुट के लिए std::io का उपयोग करें।

use std::io;

let mut name = String::new();
println!("अपना नाम दर्ज करें:");
io::stdin().read_line(&mut name).unwrap();
println!("नमस्ते, {}", name.trim());

7. फ़ंक्शन्स

फ़ंक्शन्स fn का उपयोग करते हैं और -> के ज़रिए मान वापस कर सकते हैं।

fn greet(name: &str) -> String {
    format!("नमस्ते, {}", name)
}

println!("{}", greet("Alice"));

8. हैशमैप्स

कुंजी-मूल्य डेटा के लिए std::collections::HashMap का उपयोग करें।

use std::collections::HashMap;

let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])

9. एरर हैंडलिंग

Rust Result और match या unwrap() के ज़रिए त्रुटियों को संभालता है।

fn fail() -> Result<(), String> {
    Err("कुछ गड़बड़ हो गई".to_string())
}

match fail() {
    Ok(_) => println!("सफलता"),
    Err(e) => println!("{}", e),
}

10. फ़ाइल I/O

फ़ाइल पढ़ने-लिखने के लिए std::fs का उपयोग करें।

use std::fs;

fs::write("file.txt", "हैलो फ़ाइल").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. स्ट्रिंग मैनिपुलेशन

Rust में स्ट्रिंग्स हीप पर एलोकेट होती हैं और कई मेथड्स सपोर्ट करती हैं।

let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);

12. स्ट्रक्ट्स और मेथड्स

Rust डेटा टाइप्स के लिए struct और मेथड्स के लिए impl का उपयोग करता है।

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("हाय, मैं {} हूँ", self.name)
    }
}

let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());

13. रेफ़रेंसेज़ और बॉरोइंग

Rust मान उधार लेने के लिए & और परिवर्तनशील रेफ़रेंस के लिए &mut का उपयोग करता है।

fn update(x: &mut i32) {
    *x += 1;
}

let mut value = 10;
update(&mut value);
println!("{}", value);