ऑनलाइन Rust CLI रनर

Rust कोड सीखें, टेस्ट करें और डिबग करें—बिना सेटअप के ब्राउज़र-आधारित CLI में आसानी से रन करें।

संस्करण

नमूना

🚀 247,215 कुल निष्पादन (132 इस महीने)

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

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

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

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

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

⚙️ इस टूल का उपयोग कैसे करें

1. एडिटर के ऊपर दिए ड्रॉपडाउन से Rust संस्करण (1.70, 1.72, 1.73, या 1.74) चुनें।
2. एडिटर एरिया में अपना Rust कोड लिखें या पेस्ट करें।
3. अपने प्रोग्राम को कम्पाइल और चलाने के लिए रन पर क्लिक करें - आउटपुट नीचे कंसोल में दिखाई देगा।
4. रन के दौरान स्टॉप बटन दिखाई देगा - जल्दी रोकने के लिए इसे क्लिक करें।
5. छोटे फॉर्मैटिंग या सिंटैक्स मुद्दों को अपने-आप ठीक करने के लिए कोड ठीक करें का उपयोग करें।
6. फिक्स के बाद सुधार बटन दिखाई देगा - हालिया सुधारों की समीक्षा करने के लिए इसे क्लिक करें।
7. लोकल फ़ाइल से कोड इम्पोर्ट करने के लिए अपलोड बटन का उपयोग करें, या एडिटर से अपना मौजूदा कोड सेव करने के लिए डाउनलोड बटन का।
8. प्रत्येक निष्पादन अधिकतम 20 सेकंड तक चलता है, उसके बाद स्वतः समाप्त हो जाता है।

🧠 टिप: यह वातावरण आपके ब्राउज़र में सुरक्षित रूप से असली Rust कोड चलाता है - लॉगिन या सेटअप की ज़रूरत नहीं।

💡 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);