รันเนอร์ Rust CLI ออนไลน์

เขียนและรัน Rust code ผ่าน CLI ออนไลน์ ไม่ต้องติดตั้ง เหมาะสำหรับการเรียนรู้ ทดสอบ และตรวจสอบข้อผิดพลาดในเบราว์เซอร์

เวอร์ชัน

ตัวอย่าง

🚀 247,223 การดำเนินการทั้งหมด (140 ในเดือนนี้)

🎯 คอร์ส Rust ที่เหมาะกับคุณโดยเฉพาะ

🦀 เกี่ยวกับตัวรัน Rust ออนไลน์นี้

CodeUtility Rust Executor ให้คุณเขียนและรันโค้ด Rust ได้โดยตรงบนเบราว์เซอร์ - ไม่ต้องติดตั้ง ไม่ต้องตั้งค่า toolchain หรือสภาพแวดล้อมในเครื่อง ใช้งานผ่าน sandbox ที่ปลอดภัย รองรับเวอร์ชันคอมไพเลอร์ Rust จริง 1.70, 1.72, 1.73, และ 1.74

เครื่องมือนี้จะคอมไพล์และรันโปรแกรม Rust ของคุณบนคลาวด์ด้วยคอมไพเลอร์ rustc จริง เพื่อให้ผลลัพธ์ถูกต้องและสม่ำเสมอ คุณสามารถทดลองใช้งาน variables, ownership, borrowing, pattern matching, traits, generics และฟีเจอร์สมัยใหม่อื่นๆ ของ Rust ได้อย่างง่ายดาย

เหมาะสำหรับการเรียนรู้แนวคิดหลักของ Rust - โดยเฉพาะ memory safety, error handling และ concurrency - โดยไม่ต้องติดตั้ง Cargo หรือเซ็ตอัปใดๆ ในเครื่อง ทุกอย่างรันตรงบนเบราว์เซอร์ของคุณภายในไม่กี่วินาที

⚙️ วิธีใช้งานเครื่องมือนี้

1. เลือกเวอร์ชัน Rust (1.70, 1.72, 1.73 หรือ 1.74) จากดรอปดาวน์ด้านบนของตัวแก้ไข
2. พิมพ์หรือวางโค้ด Rust ของคุณลงในพื้นที่แก้ไข
3. คลิก Run เพื่อคอมไพล์และรันโปรแกรม - เอาต์พุตจะแสดงในคอนโซลด้านล่าง
4. ระหว่างกำลังรันจะมีปุ่ม Stop ปรากฏ - คลิกเพื่อหยุดการทำงานก่อนเวลา
5. ใช้ Fix Code เพื่อแก้ไขปัญหาการจัดรูปแบบหรือไวยากรณ์เล็กน้อยโดยอัตโนมัติ
6. หลังจากแก้แล้วจะมีปุ่ม Fixes ปรากฏ - คลิกเพื่อดูการแก้ไขล่าสุด
7. ใช้ปุ่ม Upload เพื่อนำเข้าโค้ดจากไฟล์ในเครื่อง หรือใช้ปุ่ม Download เพื่อบันทึกโค้ดปัจจุบันจากตัวแก้ไข
8. การรันแต่ละครั้งทำได้สูงสุด 20 วินาที ก่อนจะหยุดเองอัตโนมัติ

🧠 เคล็ดลับ: สภาพแวดล้อมนี้รันโค้ด Rust จริงอย่างปลอดภัยในเบราว์เซอร์ของคุณ - ไม่ต้องล็อกอินหรือเซ็ตอัปใดๆ

💡 พื้นฐาน Rust และตัวอย่างที่คุณลองได้ด้านบน

1. การประกาศตัวแปรและค่าคงที่

ใช้ let ในการประกาศตัวแปร ใช้ const สำหรับค่าคงที่ และใช้ mut สำหรับตัวแปรที่แก้ไขค่าได้

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

const MAX_USERS: u32 = 100;

2. เงื่อนไข (if / match)

Rust ใช้ if สำหรับเงื่อนไข และใช้ match สำหรับ pattern matching

let x = 2;
if x == 1 {
    println!("หนึ่ง");
} else if x == 2 {
    println!("สอง");
} else {
    println!("อื่น");
}

match x {
    1 => println!("หนึ่ง"),
    2 => println!("สอง"),
    _ => println!("อื่น"),
}

3. ลูป

Rust รองรับ for, while และ loop สำหรับลูปไม่รู้จบ

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

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

4. อาร์เรย์

อาร์เรย์ขนาดคงที่ใน Rust ใช้วงเล็บเหลี่ยม ใช้ slices เพื่อดูบางส่วนของข้อมูล

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

5. เวกเตอร์ (อาร์เรย์แบบไดนามิก)

Vec ใช้สำหรับอาร์เรย์แบบไดนามิก

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

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

6. อินพุต/เอาต์พุตผ่านคอนโซล

ใช้ println! สำหรับเอาต์พุต และใช้ std::io สำหรับอินพุต

use std::io;

let mut name = String::new();
println!("กรอกชื่อของคุณ:");
io::stdin().read_line(&mut name).unwrap();
println!("สวัสดี, {}", name.trim());

7. ฟังก์ชัน

ฟังก์ชันใช้ fn และสามารถคืนค่าได้ด้วย ->

fn greet(name: &str) -> String {
    format!("สวัสดี, {}", name)
}

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

8. HashMap

ใช้ std::collections::HashMap สำหรับข้อมูลแบบคีย์-ค่า

use std::collections::HashMap;

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

9. การจัดการข้อผิดพลาด

Rust จัดการข้อผิดพลาดด้วย Result และ match หรือ unwrap()

fn fail() -> Result<(), String> {
    Err("มีบางอย่างผิดพลาด".to_string())
}

match fail() {
    Ok(_) => println!("สำเร็จ"),
    Err(e) => println!("{}", e),
}

10. การทำงานกับไฟล์ (File I/O)

ใช้ std::fs เพื่ออ่านและเขียนไฟล์

use std::fs;

fs::write("file.txt", "สวัสดีไฟล์").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. การจัดการสตริง

สตริงใน Rust ถูกจัดเก็บบน heap และมีเมธอดให้ใช้งานมากมาย

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

12. Struct และ Methods

Rust ใช้ struct สำหรับประเภทข้อมูล และใช้ impl สำหรับเมธอด

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("สวัสดี ฉันชื่อ {}", self.name)
    }
}

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

13. การอ้างอิงและการยืม

Rust ใช้ & เพื่อ borrow ค่า และใช้ &mut สำหรับการอ้างอิงที่แก้ไขค่าได้

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

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