Trình Chạy Rust CLI Online

Trải nghiệm Rust trong CLI online: chạy code, test, học cú pháp — không cần setup, ngay trên trình duyệt của bạn!

Phiên bản

Code mẫu

🚀 247,218 tổng số lượt thực thi (135 trong tháng này)

👨‍💻 Làm chủ Rust qua các khóa học thực tế

🦀 Về Trình thực thi Rust trực tuyến này

Trình thực thi Rust của CodeUtility cho phép bạn viết và chạy mã Rust trực tiếp trong trình duyệt - không cần cài đặt, thiết lập toolchain hay môi trường cục bộ. Công cụ được vận hành bởi một sandbox an toàn hỗ trợ các phiên bản trình biên dịch Rust thực 1.70, 1.72, 1.73, và 1.74.

Công cụ này biên dịch và thực thi chương trình Rust của bạn trên đám mây bằng trình biên dịch rustc chính thống, đảm bảo kết quả chính xác và nhất quán. Bạn có thể dễ dàng thử nghiệm với biến, ownership, borrowing, so khớp mẫu, trait, generic và nhiều tính năng hiện đại khác của Rust.

Rất lý tưởng để học các khái niệm cốt lõi của Rust - đặc biệt là an toàn bộ nhớ, xử lý lỗi và lập trình đồng thời - mà không cần cài đặt Cargo hay bất kỳ cấu hình cục bộ nào. Mọi thứ chạy trực tiếp trong trình duyệt chỉ trong vài giây.

⚙️ Cách sử dụng công cụ này

1. Chọn phiên bản Rust (1.70, 1.72, 1.73, hoặc 1.74) từ menu thả xuống ở phía trên trình soạn thảo.
2. Viết hoặc dán mã Rust của bạn vào vùng soạn thảo.
3. Nhấp Chạy để biên dịch và thực thi chương trình - đầu ra sẽ xuất hiện ở bảng điều khiển bên dưới.
4. Khi đang chạy, sẽ xuất hiện nút Dừng - nhấp để dừng thực thi sớm.
5. Dùng Sửa mã để tự động chỉnh các vấn đề nhỏ về định dạng hoặc cú pháp.
6. Sau khi sửa, sẽ có nút Các bản sửa - nhấp để xem lại các sửa gần đây.
7. Dùng nút Tải lên để nhập mã từ tệp cục bộ, hoặc nút Tải xuống để lưu mã hiện tại từ trình soạn thảo.
8. Mỗi lần thực thi chạy tối đa 20 giây trước khi tự động kết thúc.

🧠 Mẹo: Môi trường này chạy mã Rust thật một cách an toàn ngay trong trình duyệt - không cần đăng nhập hay cấu hình.

💡 Kiến thức cơ bản về Rust & Ví dụ bạn có thể thử ở trên

1. Khai báo biến và hằng

Dùng let để khai báo biến. Dùng const cho hằng và mut cho biến có thể thay đổi.

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

const MAX_USERS: u32 = 100;

2. Câu điều kiện (if / match)

Rust dùng if cho điều kiện và match cho so khớp mẫu.

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. Vòng lặp

Rust hỗ trợ for, while và loop vô hạn.

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

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

4. Mảng

Mảng kích thước cố định trong Rust dùng dấu ngoặc vuông. Dùng slice để truy cập một phần mảng.

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

5. Vector (Mảng động)

Vec được dùng cho mảng động.

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

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

6. Nhập/Xuất console

Dùng println! để xuất và std::io để nhập.

use std::io;

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

7. Hàm

Hàm dùng fn và có thể trả về giá trị với ->.

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

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

8. HashMap

Dùng std::collections::HashMap cho dữ liệu key-value.

use std::collections::HashMap;

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

9. Xử lý lỗi

Rust xử lý lỗi bằng Result và match hoặc unwrap().

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

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

10. I/O tệp

Dùng std::fs để đọc và ghi tệp.

use std::fs;

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

11. Xử lý chuỗi

Chuỗi trong Rust được cấp phát trên heap và hỗ trợ nhiều phương thức.

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

12. Struct & Phương thức

Rust dùng struct cho kiểu dữ liệu và impl để định nghĩa phương thức.

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. Tham chiếu & Mượn

Rust dùng & để mượn giá trị và &mut cho tham chiếu có thể thay đổi.

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

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