Exécuteur CLI Rust en ligne

Exécutez et testez du code Rust instantanément dans une CLI en ligne sécurisée, sans installation. Idéal pour apprendre et déboguer.

Version

Exemple

🚀 247,215 exécutions totales (132 ce mois-ci)

📚 Tout le monde apprend Rust - et vous ?

🦀 À propos de cet exécuteur de code Rust en ligne

L’exécuteur Rust CodeUtility vous permet d’écrire et d’exécuter du code Rust directement dans votre navigateur - aucune installation, configuration de la chaîne d’outils ou environnement local requis. Il s’appuie sur un bac à sable sécurisé qui prend en charge de vraies versions du compilateur Rust 1.70, 1.72, 1.73 et 1.74.

Cet outil compile et exécute vos programmes Rust dans le cloud à l’aide d’un véritable compilateur rustc, garantissant des résultats précis et cohérents. Vous pouvez expérimenter facilement les variables, la propriété, l’emprunt, la correspondance de motifs, les traits, les génériques et d’autres fonctionnalités modernes de Rust.

C’est idéal pour apprendre les concepts essentiels de Rust - en particulier la sécurité mémoire, la gestion des erreurs et la concurrence - sans devoir installer Cargo ni effectuer de configuration locale. Tout s’exécute directement dans votre navigateur en quelques secondes.

⚙️ Comment utiliser cet outil

1. Sélectionnez une version de Rust (1.70, 1.72, 1.73 ou 1.74) dans le menu déroulant en haut de l’éditeur.
2. Écrivez ou collez votre code Rust dans la zone de l’éditeur.
3. Cliquez sur Exécuter pour compiler et exécuter votre programme - la sortie s’affichera dans la console ci‑dessous.
4. Pendant l’exécution, un bouton Arrêter apparaît - cliquez dessus pour interrompre l’exécution.
5. Utilisez Corriger le code pour corriger automatiquement les petits problèmes de formatage ou de syntaxe.
6. Après correction, un bouton Corrections apparaît - cliquez dessus pour consulter les corrections récentes.
7. Utilisez le bouton Téléverser pour importer du code depuis un fichier local, ou le bouton Télécharger pour enregistrer le code actuel depuis l’éditeur.
8. Chaque exécution peut durer jusqu’à 20 secondes avant de se terminer automatiquement.

🧠 Astuce : Cet environnement exécute du vrai code Rust en toute sécurité dans votre navigateur - aucune connexion ni configuration requise.

💡 Notions de base de Rust et exemples à essayer ci‑dessus

1. Déclarer des variables et des constantes

Utilisez let pour déclarer des variables. Utilisez const pour les constantes et mut pour les variables mutables.

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

const MAX_USERS: u32 = 100;

2. Conditions (if / match)

Rust utilise if pour les conditions et match pour la correspondance de motifs.

let x = 2;
if x == 1 {
    println!("Un");
} else if x == 2 {
    println!("Deux");
} else {
    println!("Autre");
}

match x {
    1 => println!("Un"),
    2 => println!("Deux"),
    _ => println!("Autre"),
}

3. Boucles

Rust prend en charge for, while et loop pour les boucles infinies.

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

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

4. Tableaux

Les tableaux de taille fixe en Rust utilisent des crochets. Utilisez des slices pour obtenir des vues.

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

5. Vecteurs (tableaux dynamiques)

Vec est utilisé pour les tableaux dynamiques.

let mut fruits = vec!["pomme", "banane"];
fruits.push("cerise");
fruits.pop();

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

6. Entrée/Sortie console

Utilisez println! pour la sortie et std::io pour l’entrée.

use std::io;

let mut name = String::new();
println!("Entrez votre nom :");
io::stdin().read_line(&mut name).unwrap();
println!("Bonjour, {}", name.trim());

7. Fonctions

Les fonctions utilisent fn et peuvent retourner des valeurs avec ->.

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

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

8. HashMaps

Utilisez std::collections::HashMap pour les données clé‑valeur.

use std::collections::HashMap;

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

9. Gestion des erreurs

Rust gère les erreurs avec Result et match ou unwrap().

fn fail() -> Result<(), String> {
    Err("Quelque chose s’est mal passé".to_string())
}

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

10. Entrée/Sortie de fichiers

Utilisez std::fs pour lire et écrire des fichiers.

use std::fs;

fs::write("fichier.txt", "Bonjour fichier").unwrap();
let content = fs::read_to_string("fichier.txt").unwrap();
println!("{}", content);

11. Manipulation de chaînes

Les chaînes en Rust sont allouées sur le tas et prennent en charge de nombreuses méthodes.

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

12. Structs et méthodes

Rust utilise struct pour les types de données et impl pour les méthodes.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Salut, je m'appelle {}", self.name)
    }
}

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

13. Références et emprunt

Rust utilise & pour emprunter des valeurs et &mut pour des références mutables.

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

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