Ejecutor CLI en Línea para Rust

Ejecuta code Rust en CLI online. Ideal para probar, aprender y depurar sin configuración en un entorno seguro.

Versión

Ejemplo

🚀 247,215 ejecuciones totales (132 este mes)

📈 Rust está en tendencia - empieza hoy

🦀 Acerca de este ejecutor de Rust en línea

El CodeUtility Rust Executor te permite escribir y ejecutar código Rust directamente en tu navegador - sin instalación, configuración de la toolchain ni entorno local. Está impulsado por un sandbox seguro que admite versiones reales del compilador de Rust 1.70, 1.72, 1.73 y 1.74.

Esta herramienta compila y ejecuta tus programas de Rust en la nube usando un compilador rustc auténtico, garantizando resultados precisos y coherentes. Puedes experimentar con variables, ownership, borrowing, pattern matching, traits, genéricos y otras características modernas de Rust con facilidad.

Es ideal para aprender los conceptos clave de Rust - especialmente seguridad de memoria, manejo de errores y concurrencia - sin necesidad de instalar Cargo ni ninguna configuración local. Todo se ejecuta directamente en tu navegador en cuestión de segundos.

⚙️ Cómo usar esta herramienta

1. Selecciona una versión de Rust (1.70, 1.72, 1.73 o 1.74) desde el menú desplegable en la parte superior del editor.
2. Escribe o pega tu código Rust en el área del editor.
3. Haz clic en Ejecutar para compilar y ejecutar tu programa - la salida aparecerá en la consola de abajo.
4. Mientras se ejecuta, aparece un botón Detener - haz clic en él para detener la ejecución antes de tiempo.
5. Usa Corregir código para corregir automáticamente problemas menores de formato o sintaxis.
6. Después de corregir, aparece un botón Correcciones - haz clic para revisar las correcciones recientes.
7. Usa el botón Subir para importar código desde un archivo local, o el botón Descargar para guardar tu código actual desde el editor.
8. Cada ejecución dura hasta 20 segundos antes de finalizar automáticamente.

🧠 Consejo: Este entorno ejecuta código Rust real de forma segura en tu navegador - no requiere inicio de sesión ni configuración.

💡 Conceptos básicos de Rust y ejemplos que puedes probar arriba

1. Declaración de variables y constantes

Usa let para declarar variables. Usa const para constantes y mut para variables mutables.

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

const MAX_USERS: u32 = 100;

2. Condicionales (if / match)

Rust usa if para condiciones y match para coincidencia de patrones.

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

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

3. Bucles

Rust admite for, while y loop para bucles infinitos.

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

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

4. Arrays

Los arrays de tamaño fijo en Rust usan corchetes. Usa slices como vistas.

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

5. Vectores (arrays dinámicos)

Vec se usa para arrays dinámicos.

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

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

6. Entrada/Salida por consola

Usa println! para salida y std::io para entrada.

use std::io;

let mut name = String::new();
println!("Ingresa tu nombre:");
io::stdin().read_line(&mut name).unwrap();
println!("Hola, {}", name.trim());

7. Funciones

Las funciones usan fn y pueden devolver valores usando ->.

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

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

8. HashMaps

Usa std::collections::HashMap para datos clave-valor.

use std::collections::HashMap;

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

9. Manejo de errores

Rust maneja los errores usando Result y match o unwrap().

fn fail() -> Result<(), String> {
    Err("Algo salió mal".to_string())
}

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

10. E/S de archivos

Usa std::fs para leer y escribir archivos.

use std::fs;

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

11. Manipulación de cadenas

Las cadenas en Rust se asignan en el heap y admiten muchos métodos.

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

12. Structs y métodos

Rust usa struct para tipos de datos e impl para métodos.

struct Person {
    name: String,
}

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

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

13. Referencias y préstamo

Rust usa & para tomar prestados valores y &mut para referencias mutables.

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

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