Esegui Rust CLI Online

Esegui code Rust direttamente dal browser con una CLI online. Ideale per test, apprendimento e debugging senza installazione.

Versione

Esempio

🚀 247,215 esecuzioni totali (132 questo mese)

💡 Migliora le tue competenze con Rust

🦀 Informazioni su questo esecutore Rust online

Il CodeUtility Rust Executor ti permette di scrivere ed eseguire codice Rust direttamente nel browser - nessuna installazione, configurazione della toolchain o ambiente locale richiesti. È alimentato da una sandbox sicura che supporta le vere versioni del compilatore Rust 1.70, 1.72, 1.73 e 1.74.

Questo strumento compila ed esegue i tuoi programmi Rust nel cloud utilizzando un vero compilatore rustc, garantendo risultati accurati e coerenti. Puoi sperimentare con variabili, ownership, borrowing, pattern matching, trait, generics e altre funzionalità moderne di Rust con facilità.

È ideale per imparare i concetti fondamentali di Rust - in particolare la sicurezza della memoria, la gestione degli errori e la concorrenza - senza dover installare Cargo o alcuna configurazione locale. Tutto gira direttamente nel tuo browser in pochi secondi.

⚙️ Come usare questo strumento

1. Seleziona una versione di Rust (1.70, 1.72, 1.73 o 1.74) dal menu a discesa in alto nell'editor.
2. Scrivi o incolla il tuo codice Rust nell'area dell'editor.
3. Fai clic su Esegui per compilare ed eseguire il programma - l'output apparirà nella console sottostante.
4. Durante l'esecuzione, compare un pulsante Interrompi - fai clic per fermare l'esecuzione in anticipo.
5. Usa Correggi codice per correggere automaticamente piccoli problemi di formattazione o sintassi.
6. Dopo la correzione, appare un pulsante Correzioni - cliccalo per rivedere le correzioni recenti.
7. Usa il pulsante Carica per importare codice da un file locale, oppure il pulsante Scarica per salvare il codice corrente dall'editor.
8. Ogni esecuzione può durare fino a 20 secondi prima di terminare automaticamente.

🧠 Suggerimento: Questo ambiente esegue vero codice Rust in modo sicuro nel tuo browser - nessun accesso o configurazione necessari.

💡 Basi di Rust ed esempi che puoi provare qui sopra

1. Dichiarare variabili e costanti

Usa let per dichiarare variabili. Usa const per le costanti e mut per variabili mutabili.

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

const MAX_USERS: u32 = 100;

2. Condizionali (if / match)

Rust usa if per le condizioni e match per il pattern matching.

let x = 2;
if x == 1 {
    println!("Uno");
} else if x == 2 {
    println!("Due");
} else {
    println!("Altro");
}

match x {
    1 => println!("Uno"),
    2 => println!("Due"),
    _ => println!("Altro"),
}

3. Cicli

Rust supporta for, while e il ciclo infinito loop.

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

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

4. Array

Gli array a dimensione fissa in Rust usano le parentesi quadre. Usa gli slice per ottenere viste.

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

5. Vettori (array dinamici)

Vec è usato per array dinamici.

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

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

6. Input/Output da console

Usa println! per l'output e std::io per l'input.

use std::io;

let mut name = String::new();
println!("Inserisci il tuo nome:");
io::stdin().read_line(&mut name).unwrap();
println!("Ciao, {}", name.trim());

7. Funzioni

Le funzioni usano fn e possono restituire valori usando ->.

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

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

8. HashMap

Usa std::collections::HashMap per dati chiave-valore.

use std::collections::HashMap;

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

9. Gestione degli errori

Rust gestisce gli errori usando Result e match o unwrap().

fn fail() -> Result<(), String> {
    Err("Qualcosa è andato storto".to_string())
}

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

10. I/O su file

Usa std::fs per leggere e scrivere file.

use std::fs;

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

11. Manipolazione delle stringhe

Le stringhe in Rust sono allocate sull'heap e supportano molti metodi.

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

12. Struct e metodi

Rust usa struct per i tipi di dato e impl per i metodi.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Ciao, sono {}", self.name)
    }
}

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

13. Riferimenti e borrowing

Rust usa & per prendere in prestito valori e &mut per riferimenti mutabili.

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

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