Rust CLI Ausführungsumgebung

Führe Rust-Code direkt in der CLI aus — ideal zum Testen, Lernen und Debuggen, ganz ohne Installation.

Version

Beispiel

🚀 247,215 Gesamt-Ausführungen (132 diesen Monat)

📈 Rust liegt im Trend - jetzt lernen

🦀 Über diesen Rust-Online-Executor

Der CodeUtility Rust Executor ermöglicht es dir, Rust-Code direkt in deinem Browser zu schreiben und auszuführen - keine Installation, kein Toolchain-Setup und keine lokale Umgebung nötig. Er wird von einer sicheren Sandbox betrieben, die echte Rust-Compiler-Versionen 1.70, 1.72, 1.73 und 1.74 unterstützt.

Dieses Tool kompiliert und führt deine Rust-Programme in der Cloud mit einem echten rustc-Compiler aus, was genaue und konsistente Ergebnisse sicherstellt. Du kannst ganz einfach mit Variablen, Ownership, Borrowing, Pattern Matching, Traits, Generics und anderen modernen Rust-Features experimentieren.

Es eignet sich ideal, um die Kernkonzepte von Rust zu lernen - insbesondere Speichersicherheit, Fehlerbehandlung und Nebenläufigkeit - ganz ohne Cargo-Installation oder lokale Einrichtung. Alles läuft in Sekunden direkt in deinem Browser.

⚙️ So verwendest du dieses Tool

1. Wähle oben im Editor über das Dropdown eine Rust-Version (1.70, 1.72, 1.73 oder 1.74) aus.
2. Schreibe deinen Rust-Code oder füge ihn in den Editor ein.
3. Klicke auf Ausführen, um dein Programm zu kompilieren und auszuführen - die Ausgabe erscheint in der Konsole darunter.
4. Während der Ausführung erscheint eine Stopp-Schaltfläche - klicke sie an, um die Ausführung vorzeitig zu beenden.
5. Verwende Code korrigieren, um kleinere Formatierungs- oder Syntaxprobleme automatisch zu beheben.
6. Nach dem Korrigieren erscheint eine Korrekturen-Schaltfläche - klicke sie, um die letzten Korrekturen anzusehen.
7. Verwende die Schaltfläche Hochladen, um Code aus einer lokalen Datei zu importieren, oder die Schaltfläche Herunterladen, um deinen aktuellen Code aus dem Editor zu speichern.
8. Jeder Durchlauf dauert bis zu 20 Sekunden, bevor er automatisch beendet wird.

🧠 Tipp: Diese Umgebung führt echten Rust-Code sicher in deinem Browser aus - kein Login und keine Einrichtung erforderlich.

💡 Rust-Grundlagen & Beispiele, die du oben ausprobieren kannst

1. Variablen und Konstanten deklarieren

Verwende let, um Variablen zu deklarieren. Verwende const für Konstanten und mut für veränderliche Variablen.

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

const MAX_USERS: u32 = 100;

2. Bedingungen (if / match)

Rust verwendet if für Bedingungen und match für Pattern Matching.

let x = 2;
if x == 1 {
    println!("Eins");
} else if x == 2 {
    println!("Zwei");
} else {
    println!("Sonstiges");
}

match x {
    1 => println!("Eins"),
    2 => println!("Zwei"),
    _ => println!("Sonstiges"),
}

3. Schleifen

Rust unterstützt for, while und die unendliche Schleife loop.

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

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

4. Arrays

Arrays fester Größe in Rust verwenden eckige Klammern. Verwende Slices für Ansichten.

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

5. Vektoren (dynamische Arrays)

Vec wird für dynamische Arrays verwendet.

let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();

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

6. Konsolen-Ein-/Ausgabe

Verwende println! für Ausgaben und std::io für Eingaben.

use std::io;

let mut name = String::new();
println!("Gib deinen Namen ein:");
io::stdin().read_line(&mut name).unwrap();
println!("Hallo, {}", name.trim());

7. Funktionen

Funktionen verwenden fn und können mit -> Werte zurückgeben.

fn greet(name: &str) -> String {
    format!("Hallo, {}", name)
}

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

8. HashMaps

Verwende std::collections::HashMap für Schlüssel-Wert-Daten.

use std::collections::HashMap;

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

9. Fehlerbehandlung

Rust behandelt Fehler mit Result und match oder unwrap().

fn fail() -> Result<(), String> {
    Err("Etwas ist schiefgelaufen".to_string())
}

match fail() {
    Ok(_) => println!("Erfolg"),
    Err(e) => println!("{}", e),
}

10. Datei-Ein-/Ausgabe

Verwende std::fs zum Lesen und Schreiben von Dateien.

use std::fs;

fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. String-Verarbeitung

Strings in Rust liegen auf dem Heap und unterstützen viele Methoden.

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

12. Structs & Methoden

Rust verwendet struct für Datentypen und impl für Methoden.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Hi, ich bin {}", self.name)
    }
}

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

13. Referenzen & Borrowing

Rust verwendet & zum Borrowing von Werten und &mut für veränderliche Referenzen.

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

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