CodeUtility
Facilitiamo la vita agli sviluppatori!

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.

Librerie preinstallate
🚀 252,314 esecuzioni totali (30 questo mese)

Udemy Logo 🎯 Corsi di Rust selezionati per te

Caricamento in corso…

💡 Vuoi migliorare le tue capacità? Questi corsi possono aiutarti: dai un'occhiata mentre il nostro modello di intelligenza artificiale elabora la tua richiesta.

🦀 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.

Più di un semplice esecutore di codice

Usa nello stesso esecutore un editor multifile, un terminale di esecuzione isolato, librerie specifiche per il runtime, spazi di lavoro persistenti, condivisione e collaborazione in tempo reale.

Come si usa questo esecutore?

Scegli un runtime, apri o crea un file, scrivi il codice e seleziona Esegui. L’output appare nel terminale; gli utenti che hanno effettuato l’accesso possono conservare i file in uno spazio di lavoro, installare librerie e collaborare tramite le condivisioni.

  1. Seleziona una versione e modifica il file corrente oppure apri un altro file dello spazio di lavoro.
  2. Esegui il codice, inserisci i dati nel terminale quando richiesto e consulta la cronologia delle esecuzioni salvate.
  3. Usa librerie, strumenti dello spazio di lavoro, condivisione e chat quando l’attività richiede più di un frammento di codice.

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