Executor CLI Rust Online

Execute code Rust online em um CLI seguro via browser. Ideal para testar, aprender e debugar sem configuração prévia.

Versão

Exemplo

🚀 247,215 execuções totais (132 este mês)

✨ Os cursos de Rust que todos estão amando

🦀 Sobre este executor online de Rust

O CodeUtility Rust Executor permite escrever e executar código Rust diretamente no seu navegador - sem instalação, configuração de toolchain ou ambiente local. Ele é alimentado por um sandbox seguro que oferece suporte às versões reais do compilador Rust 1.70, 1.72, 1.73 e 1.74.

Esta ferramenta compila e executa seus programas Rust na nuvem usando um compilador rustc autêntico, garantindo resultados precisos e consistentes. Você pode experimentar com variáveis, ownership, borrowing, pattern matching, traits, genéricos e outros recursos modernos do Rust com facilidade.

É ideal para aprender os conceitos fundamentais de Rust - especialmente segurança de memória, tratamento de erros e concorrência - sem precisar instalar o Cargo ou qualquer setup local. Tudo roda diretamente no seu navegador em segundos.

⚙️ Como usar esta ferramenta

1. Selecione uma versão do Rust (1.70, 1.72, 1.73 ou 1.74) no menu suspenso no topo do editor.
2. Escreva ou cole seu código Rust na área do editor.
3. Clique em Executar para compilar e executar seu programa - a saída aparecerá no console abaixo.
4. Enquanto estiver em execução, aparece um botão Parar - clique nele para encerrar a execução antecipadamente.
5. Use Corrigir código para ajustar automaticamente pequenos problemas de formatação ou sintaxe.
6. Após corrigir, um botão Correções aparece - clique para revisar as correções recentes.
7. Use o botão Enviar para importar código de um arquivo local, ou o botão Baixar para salvar o código atual do editor.
8. Cada execução roda por até 20 segundos antes de terminar automaticamente.

🧠 Dica: Este ambiente executa código Rust real com segurança no seu navegador - sem login ou configuração.

💡 Noções básicas de Rust e exemplos que você pode testar acima

1. Declarando variáveis e constantes

Use let para declarar variáveis. Use const para constantes e mut para variáveis mutáveis.

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

const MAX_USERS: u32 = 100;

2. Condicionais (if / match)

Rust usa if para condições e match para correspondência de padrões.

let x = 2;
if x == 1 {
    println!("One");
} else if x == 2 {
    println!("Two");
} else {
    println!("Other");
}

match x {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Other"),
}

3. Loops

Rust oferece suporte a for, while e loop infinito.

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

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

4. Arrays

Arrays de tamanho fixo em Rust usam colchetes. Use slices para visualizações.

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

5. Vetores (arrays dinâmicos)

Vec é usado para arrays dinâmicos.

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

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

6. Entrada/Saída no console

Use println! para saída e std::io para entrada.

use std::io;

let mut name = String::new();
println!("Enter your name:");
io::stdin().read_line(&mut name).unwrap();
println!("Hello, {}", name.trim());

7. Funções

Funções usam fn e podem retornar valores usando ->.

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

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

8. HashMaps

Use std::collections::HashMap para dados chave-valor.

use std::collections::HashMap;

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

9. Tratamento de erros

Rust lida com erros usando Result e match ou unwrap().

fn fail() -> Result<(), String> {
    Err("Something went wrong".to_string())
}

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

10. I/O de arquivos

Use std::fs para ler e escrever arquivos.

use std::fs;

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

11. Manipulação de strings

Strings em Rust são alocadas no heap e oferecem muitos métodos.

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

12. Structs e métodos

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

struct Person {
    name: String,
}

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

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

13. Referências e empréstimo

Rust usa & para emprestar valores e &mut para referências mutáveis.

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

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