13 หัวข้อสำคัญที่ Dev ต้องรู้เมื่อเริ่มต้นเขียน Rust

Jan. 14, 2025 · boychawin

Rust กลายเป็นหนึ่งในภาษายอดนิยมสำหรับ Dev ที่ต้องการเขียนโค้ดที่ปลอดภัยและมีประสิทธิภาพสูง การเรียนรู้ Rust ให้ลึกซึ้งจำเป็นต้องเข้าใจแนวคิดพื้นฐานและเทคนิคขั้นสูงที่ช่วยยกระดับการพัฒนาโปรเจกต์ของคุณ

ในบทความนี้ เราจะสำรวจ 10 หัวข้อที่ Dev ควรรู้เพื่อเริ่มต้นและพัฒนาโค้ดด้วย Rust อย่างมีประสิทธิภาพ


1. Ownership, Borrowing, และ Lifetimes

หัวใจหลักของ Rust คือระบบ Ownership ที่ช่วยจัดการหน่วยความจำโดยไม่ต้องพึ่ง Garbage Collector

  • Ownership: ทุกตัวแปรใน Rust มีเจ้าของ และเมื่อเจ้าของหมดอายุ ตัวแปรนั้นจะถูกลบออกจากหน่วยความจำทันที
  • Borrowing: การอ้างอิงตัวแปรโดยไม่ยึดสิทธิ์
  • Lifetimes: กำหนดขอบเขตการใช้งานของอ้างอิง

ตัวอย่าง

fn main() {
    let data = String::from("Rust");
    let reference = &data; // Borrowing
    println!("Data: {}", reference);
} // data และ reference หมดอายุพร้อมกัน

2. Pattern Matching

Rust มีระบบ Pattern Matching ที่ทรงพลัง เช่น match, if let, และ while let

enum Status {
    Success,
    Error(String),
}

fn handle_status(status: Status) {
    match status {
        Status::Success => println!("Operation succeeded!"),
        Status::Error(msg) => println!("Error: {}", msg),
    }
}

3. Error Handling

Rust ใช้ Result และ Option ในการจัดการข้อผิดพลาด

  • Result<T, E> สำหรับข้อผิดพลาดที่อาจเกิดขึ้น
  • Option<T> สำหรับค่าที่อาจไม่มี
fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(err) => println!("Error: {}", err),
    }
}

4. Generics และ Traits

  • Generics ช่วยให้ฟังก์ชันและโครงสร้างข้อมูลรองรับหลายประเภท
  • Traits กำหนดพฤติกรรมร่วมที่ใช้กับหลายประเภท
fn display<T: std::fmt::Debug>(value: T) {
    println!("{:?}", value);
}

fn main() {
    display(42);
    display("Hello, Rust!");
}

5. Concurrency และ Asynchronous Programming

Rust รองรับการเขียนโค้ดที่ปลอดภัยสำหรับงานที่ทำพร้อมกัน (Concurrency)

  • ใช้ std::thread สำหรับงาน Thread-based
  • ใช้ async/await สำหรับงาน Asynchronous
async fn fetch_data() {
    println!("Fetching data...");
}

#[tokio::main]
async fn main() {
    fetch_data().await;
}

6. Macros

Macros เช่น macro_rules! และ Procedural Macros ช่วยลดความซ้ำซ้อนของโค้ด

macro_rules! create_vector {
    ($($item:expr),*) => {
        vec![$($item),*]
    };
}

fn main() {
    let numbers = create_vector![1, 2, 3, 4];
    println!("{:?}", numbers);
}

7. Tools ใน Rust Ecosystem

Rust มีเครื่องมือช่วยพัฒนา

  • Cargo: จัดการ dependencies
  • Clippy: ช่วยตรวจสอบโค้ด
  • Rustfmt: จัดรูปแบบโค้ด

ตัวอย่าง:

cargo new my_project
cd my_project
cargo add serde

8. Unsafe Code

แม้ Rust จะเน้นความปลอดภัย แต่ยังรองรับโค้ด unsafe สำหรับงานที่ต้องจัดการหน่วยความจำระดับต่ำ

unsafe {
    let mut num = 5;
    let r = &mut num as *mut i32;
    *r += 1;
    println!("Value: {}", *r);
}

9. Advanced Data Structures

Rust มีโครงสร้างข้อมูลที่ยืดหยุ่น เช่น

  • Vec: อาร์เรย์ไดนามิก
  • HashMap: คีย์-ค่า
  • Rc และ Arc: การแชร์ข้อมูล
use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 10);
    scores.insert("Bob", 20);
    println!("{:?}", scores);
}

10. Smart Pointers และ Memory Management

Rust มี Smart Pointers หลายประเภท

  • Box<T>: สำหรับเก็บข้อมูลบน Heap
  • Rc<T>: แชร์ข้อมูลระหว่างหลายตัวแปร
  • Arc<T>: แชร์ข้อมูลใน Multithreading

ตัวอย่าง:

use std::rc::Rc;

fn main() {
    let a = Rc::new(10);
    let b = Rc::clone(&a);
    println!("Count: {}", Rc::strong_count(&a));
}

11. WebAssembly (Wasm)

Rust สามารถสร้าง WebAssembly โมดูลสำหรับงานเว็บ

  • ใช้ Crates เช่น wasm-bindgen

ตัวอย่าง:

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

12. การทำ Performance Optimization

  • ใช้ Benchmarking ด้วย Criterion
  • เขียนโค้ดให้ Zero-cost Abstraction

13. Community และ Ecosystem

  • เข้าร่วม Community เช่น Rust Forums
  • ใช้เครื่องมือและไลบรารี เช่น Serde, Tokio, หรือ Diesel

สรุป

Rust เป็นภาษาที่ผสมผสานความปลอดภัย ประสิทธิภาพ และความยืดหยุ่นในการเขียนโค้ด ระบบ Ownership และ Borrowing ช่วยให้ Dev เขียนโค้ดที่ปลอดภัยโดยปราศจากปัญหาเกี่ยวกับหน่วยความจำ หัวข้อเหล่านี้จะช่วยให้คุณสร้างพื้นฐานที่แข็งแกร่งในการพัฒนา Rust

Tags: rust