CodeUtility
ใช้ชีวิตนักพัฒนาให้ง่ายขึ้นไปอีก!

Online Rust Compiler

Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.

ไลบรารีที่ติดตั้งไว้
🚀 252,325 การดำเนินการทั้งหมด (41 ในเดือนนี้)

Udemy Logo 📈 Rust กำลังมาแรง - เรียนวันนี้เลย

กำลังโหลด...

💡 กำลังมองหาการพัฒนาทักษะของคุณหรือไม่? หลักสูตรเหล่านี้อาจช่วยได้ ลองดูในขณะที่โมเดล AI ของเราประมวลผลคำขอของคุณ

🦀 เกี่ยวกับตัวรัน 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. เลือกเวอร์ชันแล้วแก้ไขไฟล์ปัจจุบัน หรือเปิดไฟล์อื่นในพื้นที่ทำงาน
  2. เรียกใช้โค้ด ป้อนข้อมูลในเทอร์มินัลเมื่อระบบร้องขอ และตรวจสอบประวัติการเรียกใช้ที่บันทึกไว้
  3. ใช้ไลบรารี เครื่องมือพื้นที่ทำงาน การแชร์ และแชท เมื่องานของคุณต้องใช้โค้ดมากกว่าหนึ่งส่วน

💡 พื้นฐาน 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);