# Rust — คู่มือฉบับสมบูรณ์ ตั้งแต่พื้นฐานยันระดับมืออาชีพ > Rust คือภาษาที่ "ยากตอนเรียน แต่ปลอดภัยตอนรัน" — ระบบ ownership ทำให้ compiler จับ bug ที่ภาษาอื่นต้องไปเจอตอน production บทความนี้พาคุณเข้าใจ Rust อย่างลึกซึ้ง ตั้งแต่ syntax พื้นฐานจนถึงการสร้าง production-grade backend --- ## สารบัญ 1. [ทำไมต้อง Rust](#1-ทำไมต้อง-rust) 2. [Setup สภาพแวดล้อม](#2-setup-สภาพแวดล้อม) 3. [Hello World และโครงสร้างโปรเจกต์](#3-hello-world-และโครงสร้างโปรเจกต์) 4. [Variables, Mutability, Constants](#4-variables-mutability-constants) 5. [Data Types พื้นฐาน](#5-data-types-พื้นฐาน) 6. [Control Flow](#6-control-flow) 7. [Ownership — หัวใจของ Rust](#7-ownership--หัวใจของ-rust) 8. [References และ Borrowing](#8-references-และ-borrowing) 9. [Slices](#9-slices) 10. [Structs](#10-structs) 11. [Enums และ Pattern Matching](#11-enums-และ-pattern-matching) 12. [Option และ Result](#12-option-และ-result) 13. [Methods และ Associated Functions](#13-methods-และ-associated-functions) 14. [Traits](#14-traits) 15. [Generics](#15-generics) 16. [Lifetimes](#16-lifetimes) 17. [Error Handling ระดับ Production](#17-error-handling-ระดับ-production) 18. [Collections](#18-collections) 19. [Iterators และ Closures](#19-iterators-และ-closures) 20. [Modules, Crates, Cargo](#20-modules-crates-cargo) 21. [Smart Pointers — Box, Rc, Arc, RefCell](#21-smart-pointers) 22. [Concurrency — Threads และ Channels](#22-concurrency--threads-และ-channels) 23. [Async/Await และ Tokio](#23-asyncawait-และ-tokio) 24. [Macros เบื้องต้น](#24-macros-เบื้องต้น) 25. [Unsafe Rust](#25-unsafe-rust) 26. [Testing](#26-testing) 27. [Performance, Profiling, Benchmark](#27-performance-profiling-benchmark) 28. [Patterns ใน Production](#28-patterns-ใน-production) 29. [REST API ด้วย Axum](#29-rest-api-ด้วย-axum) 30. [Database ด้วย sqlx](#30-database-ด้วย-sqlx) 31. [Observability](#31-observability) 32. [Build, Deploy, Docker](#32-build-deploy-docker) 33. [สรุปและเส้นทางต่อไป](#33-สรุปและเส้นทางต่อไป) --- ## 1. ทำไมต้อง Rust Rust เริ่มต้นที่ Mozilla ในปี 2010 โดย Graydon Hoare เปิดตัวเวอร์ชัน 1.0 ในปี 2015 ปัจจุบันถูกนำไปใช้ใน Linux Kernel, Firefox, AWS Firecracker, Cloudflare Workers, Discord backend และอีกมากมาย ### จุดเด่นที่ทำให้ Rust แตกต่าง - **Memory safety โดยไม่ใช้ Garbage Collector** — ระบบ ownership ทำให้รู้ว่าเมื่อไหร่ memory จะถูกคืนตั้งแต่ตอน compile - **Zero-cost abstractions** — abstraction ระดับสูงไม่มีค่าใช้จ่ายตอน runtime - **Fearless concurrency** — compiler บังคับให้เขียน thread-safe code ตั้งแต่แรก - **No null** — ใช้ `Option` แทน null ลด null pointer exception - **No exceptions** — ใช้ `Result` ทำให้ error handling explicit - **Pattern matching ระดับเทพ** — `match` ของ Rust ทรงพลังกว่า switch ของภาษาอื่นมาก - **Cargo** — package manager + build tool + test runner ที่ถือว่าดีที่สุดในวงการ ### Rust เหมาะกับงานแบบไหน - **Systems programming** — OS, embedded, kernel module, driver - **Performance-critical backend** — ที่เคยใช้ C++ มาก่อน - **WebAssembly** — Rust compile เป็น WASM ได้ขนาดเล็กและเร็ว - **CLI tools** — ripgrep, fd, bat, exa ทั้งหมดเขียนด้วย Rust - **Network services** — proxies, load balancers, cryptography - **Blockchain** — Solana, Polkadot, NEAR ### Rust ไม่เหมาะกับงานแบบไหน - **Rapid prototyping** — เขียนช้ากว่า Python/Go ในช่วงเริ่มต้นมาก - **Simple CRUD app** — Go หรือ TypeScript เร็วกว่าสำหรับงานทั่วไป - **เรียนรู้รวดเร็ว** — learning curve สูงเป็นอันดับต้นๆ ในวงการ ### Rust vs Go — เลือกอย่างไร | ปัจจัย | Go | Rust | |---|---|---| | Learning curve | 1-2 สัปดาห์เขียนได้ | 2-6 เดือนถึงคล่อง | | Compile speed | เร็วมาก | ช้ากว่า Go ~5-10 เท่า | | Runtime perf | ดี (มี GC) | ยอดเยี่ยม (ไม่มี GC) | | Memory safety | GC จัดการ | compile-time guarantee | | Concurrency | goroutine ง่าย | async/await + ownership ยากกว่า | | Ecosystem | สมบูรณ์ในงาน backend | สมบูรณ์ในงาน systems | | เหมาะกับ | API, microservices, DevOps | OS, embedded, hot path | --- ## 2. Setup สภาพแวดล้อม ### ติดตั้ง rustup `rustup` เป็น toolchain manager — ติดตั้งครั้งเดียวจัดการได้ทุกเวอร์ชัน ```bash # Linux / macOS curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Windows: ดาวน์โหลด rustup-init.exe จาก rustup.rs ``` หลังติดตั้ง: ```bash rustc --version # 1.78.0 (หรือใหม่กว่า) cargo --version rustup component add clippy rustfmt rust-analyzer ``` - **rustc** — compiler - **cargo** — package manager + build tool - **clippy** — linter (must-have) - **rustfmt** — formatter - **rust-analyzer** — LSP server สำหรับ editor ### จัดการ toolchain ```bash rustup update rustup install nightly # nightly toolchain (สำหรับ feature ทดลอง) rustup default stable rustup target add wasm32-unknown-unknown # cross-compile target ``` ### โครงสร้างโปรเจกต์มาตรฐาน ``` my-project/ ├── Cargo.toml # manifest (เทียบเท่า package.json) ├── Cargo.lock # lock file (commit สำหรับ binary, gitignore สำหรับ library) ├── src/ │ ├── main.rs # entry สำหรับ binary │ ├── lib.rs # entry สำหรับ library │ └── bin/ # binary หลายตัวในโปรเจกต์เดียว ├── tests/ # integration tests ├── benches/ # benchmarks ├── examples/ # example code └── target/ # build output (gitignore) ``` --- ## 3. Hello World และโครงสร้างโปรเจกต์ ```bash cargo new hello-rust cd hello-rust cargo run ``` ไฟล์ `src/main.rs`: ```rust fn main() { println!("สวัสดีชาวโลก"); } ``` ไฟล์ `Cargo.toml`: ```toml [package] name = "hello-rust" version = "0.1.0" edition = "2021" [dependencies] ``` ### คำสั่ง Cargo ที่ใช้บ่อย ```bash cargo run # compile + run (debug mode) cargo run --release # compile + run (optimized) cargo build # compile เท่านั้น cargo check # ตรวจ syntax/type โดยไม่ build (เร็วกว่า build มาก) cargo test # รัน test cargo doc --open # generate docs และเปิด browser cargo clippy # lint cargo fmt # format cargo update # อัปเดต dependencies cargo add tokio # เพิ่ม dependency (เหมือน npm install) ``` > **Tip สำคัญ:** ใช้ `cargo check` ระหว่างเขียนเพื่อ feedback ที่เร็ว ใช้ `cargo build` เฉพาะตอนที่จะรัน ### println! ทำไมมี ! `println!` คือ **macro** ไม่ใช่ function — Rust มี macro หลายตัวจะอธิบายในส่วน Macros --- ## 4. Variables, Mutability, Constants ### ค่าเริ่มต้นคือ immutable ```rust let x = 5; x = 6; // ❌ Compile error: cannot assign twice to immutable variable let mut y = 5; y = 6; // ✓ ok ``` นี่คือปรัชญาของ Rust — บังคับให้คิดก่อนว่าตัวแปรนี้จำเป็นต้องเปลี่ยนค่าจริงไหม ### Shadowing ต่างจาก Mutation ```rust let x = 5; let x = x + 1; // shadow ตัวเดิม สร้างตัวแปรใหม่ let x = x * 2; // ทำได้แม้ไม่ได้ประกาศ mut // shadow เปลี่ยน type ได้ด้วย let s = "hello"; let s = s.len(); // s กลายเป็น usize ``` Shadowing สร้างตัวแปรใหม่ทุกครั้ง ส่วน mutation เปลี่ยนค่าใน memory เดียวกัน ### Constants ```rust const MAX_USERS: u32 = 100_000; const PI: f64 = 3.14159; ``` ความต่างจาก `let`: - ต้องระบุ type เสมอ - ใช้ได้ใน global scope - ค่าต้อง compile-time constant - เป็น `SCREAMING_SNAKE_CASE` ตามแบบแผน ### Static ```rust static APP_NAME: &str = "MyApp"; static mut COUNTER: u32 = 0; // mutable static — ต้องใช้ใน unsafe block ``` ความต่างจาก const: static มี memory address คงที่ตลอด program lifetime — ใช้น้อยมากในโค้ดทั่วไป --- ## 5. Data Types พื้นฐาน ### Integer ```rust let a: i8 = -128; // -128 ถึง 127 let b: i32 = 100; // default ของ integer literal let c: i64 = 100_000_000; let d: isize = 100; // ขนาดเท่า pointer ของ platform let e: u8 = 255; // unsigned 0-255 let f: u32 = 4_000_000_000; let g: u64 = 18_446_744_073_709_551_615; // literal แบบต่างๆ let hex = 0xff; let octal = 0o77; let binary = 0b1111_0000; let byte = b'A'; // u8 ``` ### Floating point ```rust let x = 2.0; // f64 (default) let y: f32 = 3.0; ``` ### Boolean และ Character ```rust let t = true; let f: bool = false; let c = 'z'; // char เป็น Unicode scalar value 4 byte let heart = '❤'; let thai = 'ก'; ``` ### Tuples ```rust let tup: (i32, f64, &str) = (500, 6.4, "hello"); // destructure let (x, y, z) = tup; // access ด้วย index let first = tup.0; let second = tup.1; // unit type — tuple ว่าง ใช้แทน "ไม่มีค่า" let unit: () = (); ``` ### Arrays ```rust let a = [1, 2, 3, 4, 5]; // type inferred = [i32; 5] let b: [i32; 5] = [1, 2, 3, 4, 5]; let zeros = [0; 100]; // [0, 0, 0, ...] 100 ตัว let first = a[0]; println!("len = {}", a.len()); // ❌ index เกินขอบเขต = panic ที่ runtime (แต่ Rust จะตรวจให้) // let x = a[10]; // panic: index out of bounds ``` ### String types Rust มี string สองแบบที่ต้องเข้าใจตั้งแต่แรก: ```rust // &str — string slice (immutable view, ขนาดคงที่) let s1: &str = "hello"; // String — heap-allocated, growable let s2: String = String::from("hello"); let s3 = "world".to_string(); let s4 = String::new(); let mut s = String::from("hello"); s.push_str(", world"); s.push('!'); ``` ตอนเริ่มแรกอย่าเพิ่งงงกับ `&str` vs `String` — เราจะเข้าใจมากขึ้นเมื่อพูดถึง ownership --- ## 6. Control Flow ### if expression ใน Rust `if` เป็น **expression** — มี return value ด้วย ```rust let n = 5; if n > 0 { println!("positive"); } else if n < 0 { println!("negative"); } else { println!("zero"); } // if เป็น expression let abs = if n >= 0 { n } else { -n }; ``` > **สำคัญ:** condition ต้องเป็น `bool` เท่านั้น — ไม่ implicit convert จาก integer เหมือน C ### loop ```rust let mut count = 0; let result = loop { count += 1; if count == 10 { break count * 2; // loop คืนค่าได้ } }; println!("{}", result); // 20 ``` ### while ```rust let mut n = 3; while n > 0 { println!("{}", n); n -= 1; } ``` ### for และ ranges ```rust for i in 0..5 { // 0, 1, 2, 3, 4 println!("{}", i); } for i in 0..=5 { // 0, 1, 2, 3, 4, 5 (inclusive) println!("{}", i); } let arr = [10, 20, 30]; for x in arr.iter() { println!("{}", x); } // reverse for i in (0..5).rev() { println!("{}", i); } ``` ### Loop labels ```rust 'outer: for i in 0..10 { for j in 0..10 { if i * j > 50 { break 'outer; } } } ``` --- ## 7. Ownership — หัวใจของ Rust นี่คือสิ่งที่ทำให้ Rust แตกต่างจากภาษาอื่นทั้งหมด เข้าใจส่วนนี้ได้คือเข้าใจ Rust ไปครึ่งทางแล้ว ### กฎ 3 ข้อของ Ownership 1. **ทุกค่ามี owner เดียว** ในแต่ละช่วงเวลา 2. **เมื่อ owner ออกจาก scope ค่าจะถูก drop** (คืน memory) 3. **เมื่อมี ownership transfer (move) — owner เดิมใช้ค่าไม่ได้อีก** ### Move ```rust let s1 = String::from("hello"); let s2 = s1; // ownership ย้ายจาก s1 ไป s2 println!("{}", s1); // ❌ Compile error: borrow of moved value println!("{}", s2); // ✓ ok ``` > ที่ Go จะ copy pointer แต่ใน Rust — compiler ห้ามใช้ s1 ต่อเพราะป้องกัน double-free bug ### Clone ถ้าต้องการ deep copy ต้องเรียก `.clone()` ชัดเจน ```rust let s1 = String::from("hello"); let s2 = s1.clone(); println!("{} {}", s1, s2); // ✓ ใช้ทั้งคู่ได้ ``` ปรัชญา Rust: การ copy raw memory แพง ดังนั้นต้องเขียน `clone()` เห็นชัดในโค้ด ไม่มี implicit clone ### Copy types Type ที่อยู่ใน stack ทั้งหมด (integer, float, bool, char, tuple ของ Copy types) implement trait `Copy` — ไม่เกิด move ```rust let x = 5; let y = x; // copy ไม่ใช่ move println!("{} {}", x, y); // ✓ ใช้ได้ทั้งคู่ ``` | Type | Move หรือ Copy | |---|---| | `i32`, `f64`, `bool`, `char` | Copy | | `(i32, i32)` | Copy | | `String`, `Vec`, `Box` | Move | | `&T` (reference) | Copy | ### Functions และ Ownership ```rust fn takes_ownership(s: String) { println!("{}", s); } // s drop ที่นี่ fn makes_copy(n: i32) { println!("{}", n); } // n drop แต่เพราะเป็น Copy ตัวเดิมยังใช้ได้ fn main() { let s = String::from("hello"); takes_ownership(s); // println!("{}", s); // ❌ s ถูก move เข้าไปในฟังก์ชัน let n = 5; makes_copy(n); println!("{}", n); // ✓ n ยังอยู่ } ``` ### Return value และ ownership ```rust fn gives_ownership() -> String { String::from("yours") } fn takes_and_gives_back(s: String) -> String { s } fn main() { let s1 = gives_ownership(); let s2 = String::from("hello"); let s3 = takes_and_gives_back(s2); // s2 ใช้ไม่ได้แล้ว แต่ s3 ใช้ได้ } ``` --- ## 8. References และ Borrowing ถ้าเราอยากใช้ค่าโดยไม่ต้อง move ทุกครั้ง — ใช้ **reference** (borrowing) ### Immutable reference ```rust fn calculate_length(s: &String) -> usize { s.len() } fn main() { let s = String::from("hello"); let len = calculate_length(&s); // ส่ง reference println!("{} = {}", s, len); // s ยังใช้ได้ } ``` `&s` คือการสร้าง reference ที่ "ยืม" ค่า — ไม่ได้เอา ownership ไป ### Mutable reference ```rust fn change(s: &mut String) { s.push_str(", world"); } fn main() { let mut s = String::from("hello"); change(&mut s); println!("{}", s); } ``` ### กฎของ Borrowing — สำคัญที่สุดของ Rust ในเวลาเดียวกัน คุณมีได้แค่อย่างใดอย่างหนึ่ง: - **immutable reference จำนวนเท่าไหร่ก็ได้** (`&T`) - **mutable reference เพียงตัวเดียว** (`&mut T`) ห้ามมีทั้งสองอย่างพร้อมกัน ```rust let mut s = String::from("hello"); let r1 = &s; let r2 = &s; println!("{} {}", r1, r2); // ✓ immutable reference หลายตัวได้ let r3 = &mut s; // ✓ ได้ เพราะ r1, r2 ไม่ใช้แล้ว println!("{}", r3); ``` ```rust let mut s = String::from("hello"); let r1 = &s; let r2 = &mut s; // ❌ Error: cannot borrow as mutable println!("{} {}", r1, r2); ``` ### ทำไมกฎนี้ถึงสำคัญ ป้องกัน **data race** ตั้งแต่ compile-time: - ห้ามอ่านพร้อมเขียน → ป้องกัน read-while-write - ห้ามเขียนหลายที่ → ป้องกัน double-write ในภาษาอื่น bug แบบนี้เกิดที่ runtime (ถ้าโชคไม่ดีถึง production) แต่ใน Rust compiler จับให้ตั้งแต่แรก ### Dangling Reference ในภาษาอื่นการ return reference ของ local variable ทำให้เกิด dangling pointer Rust ห้ามทำ: ```rust fn dangle() -> &String { let s = String::from("hello"); &s // ❌ s drop ที่นี่ reference ไม่ valid } // ต้อง return ownership แทน fn no_dangle() -> String { let s = String::from("hello"); s // ✓ ownership ย้ายออก } ``` --- ## 9. Slices Slice คือ reference ไปยังส่วนหนึ่งของ collection — ไม่มี ownership ```rust let s = String::from("hello world"); let hello = &s[0..5]; // "hello" let world = &s[6..11]; // "world" let whole = &s[..]; // "hello world" let from_six = &s[6..]; // "world" ``` ### String literal คือ slice ```rust let s: &str = "hello"; // "hello" อยู่ใน binary โปรแกรม, s เป็น &str ชี้ไปที่นั่น ``` นี่คือเหตุผลที่ `&str` เป็น immutable เสมอ — มันเป็น reference ของข้อมูลที่ readonly ### ใช้ &str เป็น parameter ```rust // ดี — รับได้ทั้ง String และ &str fn first_word(s: &str) -> &str { let bytes = s.as_bytes(); for (i, &b) in bytes.iter().enumerate() { if b == b' ' { return &s[0..i]; } } &s[..] } let s = String::from("hello world"); let w = first_word(&s); // String → &str อัตโนมัติ let w = first_word("hello world"); // ทำงานกับ literal ได้ด้วย ``` ### Array slice ```rust let arr = [1, 2, 3, 4, 5]; let s: &[i32] = &arr[1..3]; // [2, 3] ``` --- ## 10. Structs ```rust struct User { username: String, email: String, active: bool, sign_in_count: u64, } let user1 = User { username: String::from("rata"), email: String::from("r@example.com"), active: true, sign_in_count: 1, }; // แก้ field — instance ทั้งตัวต้อง mut let mut user2 = User { /* ... */ }; user2.email = String::from("new@example.com"); ``` ### Struct update syntax ```rust let user2 = User { email: String::from("another@example.com"), ..user1 // copy field ที่เหลือจาก user1 }; // ระวัง — ถ้ามี field ที่เป็น String จะถูก move ``` ### Tuple struct ```rust struct Color(u8, u8, u8); struct Point(i32, i32, i32); let black = Color(0, 0, 0); let origin = Point(0, 0, 0); println!("{} {} {}", black.0, black.1, black.2); ``` ### Unit-like struct ```rust struct AlwaysEqual; let subject = AlwaysEqual; ``` ใช้บ่อยตอน implement trait กับ type ที่ไม่มี data ### Derive `#[derive(...)]` คือ macro ที่ implement trait มาตรฐานให้อัตโนมัติ ```rust #[derive(Debug, Clone, PartialEq)] struct User { name: String, age: u32, } let u = User { name: "A".into(), age: 30 }; println!("{:?}", u); // ใช้ Debug let u2 = u.clone(); // ใช้ Clone println!("{}", u == u2); // ใช้ PartialEq ``` trait ที่ derive บ่อย: `Debug`, `Clone`, `Copy`, `PartialEq`, `Eq`, `Hash`, `Default`, `Serialize`, `Deserialize` --- ## 11. Enums และ Pattern Matching Enum ของ Rust ทรงพลังกว่า enum ของภาษา C-family มาก — แต่ละ variant เก็บข้อมูลต่างกันได้ ```rust enum IpAddr { V4(u8, u8, u8, u8), V6(String), } let home = IpAddr::V4(127, 0, 0, 1); let loopback = IpAddr::V6(String::from("::1")); ``` ### Enum ที่ซับซ้อน ```rust enum Message { Quit, // unit variant Move { x: i32, y: i32 }, // struct-like variant Write(String), // tuple-like variant ChangeColor(i32, i32, i32), } ``` ### Match — หัวใจของ enum ```rust fn process(msg: Message) { match msg { Message::Quit => println!("quit"), Message::Move { x, y } => println!("move to ({}, {})", x, y), Message::Write(text) => println!("write: {}", text), Message::ChangeColor(r, g, b) => println!("color: {}, {}, {}", r, g, b), } } ``` `match` บังคับให้ครอบคลุม **ทุก variant** — ถ้าลืม compiler ไม่ผ่าน ### Match patterns ขั้นสูง ```rust let x = 5; match x { 1 => println!("one"), 2 | 3 => println!("two or three"), // multiple patterns 4..=6 => println!("four to six"), // range n if n > 100 => println!("big: {}", n), // guard _ => println!("other"), // catch-all } ``` ### if let — match ที่สนใจกรณีเดียว ```rust let some_value = Some(3); // แทนที่จะเขียน match some_value { Some(n) => println!("{}", n), _ => (), } // เขียนแบบนี้ได้ if let Some(n) = some_value { println!("{}", n); } // while let ก็มี let mut stack = vec![1, 2, 3]; while let Some(top) = stack.pop() { println!("{}", top); } ``` ### let else (Rust 1.65+) ```rust fn get_count(s: &str) -> Result { let Ok(n) = s.parse::() else { return Err(format!("invalid: {}", s)); }; // n ใช้ได้ปกติด้านล่าง Ok(n * 2) } ``` --- ## 12. Option และ Result Rust ไม่มี null และไม่มี exception — ใช้ enum สองตัวแทน ### Option — แทน null ```rust enum Option { Some(T), None, } ``` ```rust fn find_user(id: u32) -> Option { if id == 1 { Some(String::from("Alice")) } else { None } } match find_user(1) { Some(name) => println!("found: {}", name), None => println!("not found"), } // shortcut methods let user = find_user(1); let name = user.unwrap_or(String::from("anonymous")); let name = user.unwrap_or_else(|| String::from("default")); let exists = user.is_some(); // map let length: Option = find_user(1).map(|s| s.len()); ``` ### Result — แทน exception ```rust enum Result { Ok(T), Err(E), } ``` ```rust use std::num::ParseIntError; fn parse_age(s: &str) -> Result { s.parse::() } match parse_age("25") { Ok(n) => println!("age = {}", n), Err(e) => println!("error: {}", e), } ``` ### ? operator — ลายเซ็นของ Rust error handling ```rust use std::fs; use std::io; fn read_username() -> Result { let content = fs::read_to_string("user.txt")?; // ถ้า error → return ทันที Ok(content.trim().to_string()) } ``` `?` เทียบเท่า: ```rust let content = match fs::read_to_string("user.txt") { Ok(c) => c, Err(e) => return Err(e), }; ``` ### Chain ของ ? ```rust fn read_and_parse() -> Result> { let s = fs::read_to_string("number.txt")?; let n = s.trim().parse::()?; Ok(n * 2) } ``` > **กฎ:** `?` ใช้ได้เฉพาะในฟังก์ชันที่ return `Result` หรือ `Option` (หรือ type ที่ implement `Try`) --- ## 13. Methods และ Associated Functions ```rust struct Rectangle { width: u32, height: u32, } impl Rectangle { // associated function (= static method) fn new(width: u32, height: u32) -> Self { Self { width, height } } // method — รับ &self fn area(&self) -> u32 { self.width * self.height } // method ที่แก้ state fn double(&mut self) { self.width *= 2; self.height *= 2; } // method ที่กิน ownership fn into_tuple(self) -> (u32, u32) { (self.width, self.height) } } let mut r = Rectangle::new(10, 20); println!("{}", r.area()); // 200 r.double(); println!("{}", r.area()); // 800 let (w, h) = r.into_tuple(); // r ถูก consume แล้ว ``` ### self, &self, &mut self — ความต่าง | ประเภท | เทียบกับ Go | ใช้เมื่อ | |---|---|---| | `self` | (ไม่มี) | กิน ownership ของ instance | | `&self` | value receiver | อ่านอย่างเดียว | | `&mut self` | pointer receiver | แก้ไข state | --- ## 14. Traits Trait คือ interface ของ Rust — บอกว่า type นี้มี behavior อะไรบ้าง ```rust trait Summary { fn summarize(&self) -> String; // default implementation fn preview(&self) -> String { format!("(Read more...) {}", self.summarize()) } } struct Article { title: String, author: String, } impl Summary for Article { fn summarize(&self) -> String { format!("{} by {}", self.title, self.author) } // preview ใช้ default } ``` ### Trait bound — ในฟังก์ชัน generic ```rust fn notify(item: &T) { println!("Breaking news: {}", item.summarize()); } // syntactic sugar fn notify(item: &impl Summary) { println!("{}", item.summarize()); } // multiple bounds fn process(item: &T) { } // where clause (อ่านง่ายกว่าตอน bound เยอะ) fn complex(t: &T, u: &U) -> String where T: Summary + Clone, U: std::fmt::Debug, { format!("{:?}", u) } ``` ### Trait object — dynamic dispatch ```rust fn notify_all(items: Vec>) { for item in items { println!("{}", item.summarize()); } } ``` ความต่างของ `impl Trait` (static dispatch) กับ `dyn Trait` (dynamic dispatch): - `impl Trait` — compiler generate function ใหม่สำหรับแต่ละ type ที่ใช้ → เร็วแต่ binary ใหญ่ - `dyn Trait` — runtime polymorphism ผ่าน vtable → ยืดหยุ่นแต่มี indirect call ### Trait มาตรฐานที่สำคัญ | Trait | ใช้ทำอะไร | |---|---| | `Debug` | format ด้วย `{:?}` | | `Display` | format ด้วย `{}` | | `Clone` | `.clone()` | | `Copy` | implicit copy แทน move | | `PartialEq`, `Eq` | `==`, `!=` | | `PartialOrd`, `Ord` | `<`, `>` | | `Hash` | ใช้กับ `HashMap` / `HashSet` | | `Default` | `T::default()` | | `From`, `Into` | type conversion | | `Iterator` | `for x in iter` | | `Drop` | destructor (เรียกอัตโนมัติเมื่อ scope จบ) | ### From / Into ```rust struct Celsius(f64); struct Fahrenheit(f64); impl From for Fahrenheit { fn from(c: Celsius) -> Self { Fahrenheit(c.0 * 9.0 / 5.0 + 32.0) } } let c = Celsius(100.0); let f: Fahrenheit = c.into(); // ใช้ From ที่ implement ไว้ let f = Fahrenheit::from(Celsius(100.0)); ``` > Rust convention: implement แค่ `From` เท่านั้น `Into` จะมาให้อัตโนมัติ --- ## 15. Generics ```rust fn largest(list: &[T]) -> &T { let mut largest = &list[0]; for item in list { if item > largest { largest = item; } } largest } let nums = vec![10, 25, 3, 47, 5]; println!("{}", largest(&nums)); let chars = vec!['a', 'z', 'm']; println!("{}", largest(&chars)); ``` ### Generic struct ```rust struct Point { x: T, y: T, } impl Point { fn new(x: T, y: T) -> Self { Self { x, y } } } // impl เฉพาะตอน T เป็น f64 impl Point { fn distance_from_origin(&self) -> f64 { (self.x.powi(2) + self.y.powi(2)).sqrt() } } ``` ### Generic enum ```rust // Option และ Result คือ generic enum นั่นเอง enum Option { Some(T), None, } enum Result { Ok(T), Err(E), } ``` ### Monomorphization Rust compile generic ด้วยการ generate code แยกสำหรับแต่ละ concrete type — ไม่มี runtime cost แต่ binary จะใหญ่ขึ้น --- ## 16. Lifetimes Lifetime คือ "ระยะเวลาที่ reference valid" — Rust ใช้ตรวจให้แน่ใจว่า reference ไม่ outlive ค่าที่มันชี้ ส่วนใหญ่ Rust **infer ให้อัตโนมัติ** — ไม่ต้องเขียน แต่บางกรณีต้องบอก compiler ชัดเจน ### กรณีที่ต้องเขียน lifetime ```rust fn longest(x: &str, y: &str) -> &str { if x.len() > y.len() { x } else { y } } // ❌ Compile error: missing lifetime specifier ``` Compiler ไม่รู้ว่า return value มี lifetime เท่ากับ x หรือ y ต้องบอก: ```rust fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } ``` `'a` ไม่ได้ "เปลี่ยน" lifetime แต่ "บอก" relationship: return value มี lifetime สั้นที่สุดเท่ากับ x หรือ y ### Lifetime ใน struct ```rust struct ImportantExcerpt<'a> { part: &'a str, } impl<'a> ImportantExcerpt<'a> { fn announce(&self, text: &str) -> &str { println!("{}", text); self.part } } ``` ### Static lifetime ```rust let s: &'static str = "hello, world"; ``` `'static` หมายถึง "ตลอด lifetime ของโปรแกรม" — string literal ทุกตัวมี lifetime นี้ ### Lifetime elision rules Rust มีกฎอนุมาน lifetime ให้อัตโนมัติ 3 ข้อ: 1. parameter ทุกตัวที่เป็น reference ได้ lifetime ของตัวเอง 2. ถ้ามี input parameter ตัวเดียว — output reference ได้ lifetime นั้น 3. ถ้ามี `&self` หรือ `&mut self` — output ได้ lifetime ของ self นี่คือเหตุผลที่ฟังก์ชันส่วนใหญ่ไม่ต้องเขียน lifetime explicit --- ## 17. Error Handling ระดับ Production ### thiserror — สำหรับ library ```rust // Cargo.toml // thiserror = "1.0" use thiserror::Error; #[derive(Error, Debug)] pub enum DatabaseError { #[error("connection failed: {0}")] ConnectionFailed(String), #[error("query timeout after {timeout_ms}ms")] Timeout { timeout_ms: u64 }, #[error("record not found: id={0}")] NotFound(u64), #[error(transparent)] Sqlx(#[from] sqlx::Error), // auto-convert จาก sqlx::Error } fn get_user(id: u64) -> Result { // ... Err(DatabaseError::NotFound(id)) } ``` ### anyhow — สำหรับ application ```rust use anyhow::{Context, Result}; fn read_config() -> Result { let content = std::fs::read_to_string("config.toml") .context("failed to read config file")?; let config: Config = toml::from_str(&content) .context("failed to parse config")?; Ok(config) } ``` `anyhow::Result` คือ shortcut ของ `Result` — error type generic ที่กลืน error อื่นได้หมด ### กฎทอง - เขียน **library** → ใช้ `thiserror` (caller จะได้รู้ error type ชัดเจน) - เขียน **application/binary** → ใช้ `anyhow` (สั้น สะดวก) - ห้ามใช้ `unwrap()` หรือ `expect()` ใน production ยกเว้นกรณีที่รู้ 100% ว่าไม่มีทาง fail ### Custom error pattern ```rust #[derive(Error, Debug)] pub enum AppError { #[error("validation failed: {0}")] Validation(String), #[error("unauthorized")] Unauthorized, #[error("internal error")] Internal(#[from] anyhow::Error), } // implement IntoResponse สำหรับ Axum impl axum::response::IntoResponse for AppError { fn into_response(self) -> axum::response::Response { let (status, message) = match self { AppError::Validation(msg) => (StatusCode::BAD_REQUEST, msg), AppError::Unauthorized => (StatusCode::UNAUTHORIZED, "unauthorized".into()), AppError::Internal(e) => { tracing::error!("internal error: {:?}", e); (StatusCode::INTERNAL_SERVER_ERROR, "internal error".into()) } }; (status, Json(json!({"error": message}))).into_response() } } ``` --- ## 18. Collections ### Vec — growable array ```rust let mut v: Vec = Vec::new(); v.push(1); v.push(2); let v = vec![1, 2, 3, 4, 5]; // access let third = &v[2]; // panic ถ้า out of bounds let third = v.get(2); // Option<&i32> // iterate for x in &v { println!("{}", x); } for x in &mut v { *x *= 2; } // useful methods v.len(); v.is_empty(); v.contains(&3); v.pop(); // Option v.remove(0); v.iter().sum::(); ``` ### HashMap ```rust use std::collections::HashMap; let mut scores = HashMap::new(); scores.insert(String::from("Blue"), 10); scores.insert(String::from("Red"), 50); let team = String::from("Blue"); let score = scores.get(&team); // Option<&i32> let score = scores.get(&team).copied().unwrap_or(0); // iterate for (key, value) in &scores { println!("{}: {}", key, value); } // entry API — สำคัญมาก scores.entry(String::from("Yellow")).or_insert(50); // ใส่ถ้ายังไม่มี // count occurrences pattern let text = "hello world wonderful world"; let mut counts = HashMap::new(); for word in text.split_whitespace() { let count = counts.entry(word).or_insert(0); *count += 1; } ``` ### HashSet, BTreeMap, BTreeSet, VecDeque ```rust use std::collections::{HashSet, BTreeMap, VecDeque}; let mut set: HashSet = HashSet::new(); set.insert(1); set.contains(&1); // BTreeMap — sorted by key let mut map = BTreeMap::new(); map.insert(3, "c"); map.insert(1, "a"); map.insert(2, "b"); for (k, v) in &map { // เรียง 1, 2, 3 println!("{} {}", k, v); } // VecDeque — double-ended queue let mut queue: VecDeque = VecDeque::new(); queue.push_back(1); queue.push_front(0); queue.pop_back(); ``` --- ## 19. Iterators และ Closures ### Closures ```rust let add = |a, b| a + b; let result = add(2, 3); // closure capture environment let x = 10; let add_x = |n| n + x; println!("{}", add_x(5)); // 15 // move closure (กิน ownership) let s = String::from("hello"); let print_s = move || println!("{}", s); print_s(); // s ใช้ไม่ได้แล้ว ``` ### Iterator trait — หัวใจของ Rust collection ```rust let v = vec![1, 2, 3, 4, 5]; // iterator chain — lazy ทั้งหมด ไม่ทำงานจนกว่าจะมี consumer let sum: i32 = v.iter() .filter(|&&x| x > 1) .map(|&x| x * 2) .sum(); // collect — สร้าง collection ใหม่ let doubled: Vec = v.iter().map(|x| x * 2).collect(); // reduce let product = v.iter().fold(1, |acc, x| acc * x); // find let first_even = v.iter().find(|&&x| x % 2 == 0); // Option<&i32> ``` ### iter() vs iter_mut() vs into_iter() | Method | Element type | ผลต่อ collection | |---|---|---| | `iter()` | `&T` | ไม่กิน — ยังใช้ได้ | | `iter_mut()` | `&mut T` | ไม่กิน แต่แก้ค่าได้ | | `into_iter()` | `T` | กิน collection ทิ้ง | ### Adapter ที่ใช้บ่อย ```rust let words = vec!["hello", "world", "rust"]; // เลขลำดับ for (i, w) in words.iter().enumerate() { println!("{}: {}", i, w); } // zip คู่ let nums = vec![1, 2, 3]; let pairs: Vec<_> = words.iter().zip(nums.iter()).collect(); // chunks / windows let v: Vec = (1..=10).collect(); for chunk in v.chunks(3) { println!("{:?}", chunk); // [1,2,3], [4,5,6], [7,8,9], [10] } // take / skip let first_three: Vec<_> = v.iter().take(3).collect(); let skip_two: Vec<_> = v.iter().skip(2).collect(); // any / all let has_negative = v.iter().any(|&x| x < 0); let all_positive = v.iter().all(|&x| x > 0); // max / min let max = v.iter().max(); let min_by_abs = v.iter().min_by_key(|&&x| x.abs()); // group / sort let mut sorted = v.clone(); sorted.sort(); sorted.sort_by(|a, b| b.cmp(a)); // descending sorted.sort_by_key(|&x| -x); // dedup (ติดกันเท่านั้น) let mut v = vec![1, 1, 2, 3, 3, 3, 4]; v.dedup(); // [1, 2, 3, 4] ``` --- ## 20. Modules, Crates, Cargo ### Module system ```rust // src/lib.rs mod auth { pub fn login(user: &str, pass: &str) -> bool { verify(user, pass) } fn verify(user: &str, pass: &str) -> bool { // private function true } pub mod jwt { pub fn sign(claims: &str) -> String { String::from("token") } } } // ใช้ use crate::auth::login; use crate::auth::jwt::sign; ``` ### แยก module ออกเป็นไฟล์ ``` src/ ├── lib.rs ├── auth.rs // mod auth; └── auth/ └── jwt.rs // mod jwt; ใน auth.rs ``` ```rust // src/lib.rs pub mod auth; // src/auth.rs pub mod jwt; pub fn login() { /* ... */ } // src/auth/jwt.rs pub fn sign() { /* ... */ } ``` ### Workspace — multi-crate project ```toml # Cargo.toml ของ workspace [workspace] members = [ "api", "core", "common", ] [workspace.dependencies] serde = { version = "1", features = ["derive"] } tokio = { version = "1", features = ["full"] } ``` ```toml # api/Cargo.toml [package] name = "api" version = "0.1.0" [dependencies] core = { path = "../core" } common = { path = "../common" } serde.workspace = true tokio.workspace = true ``` ### Feature flags ```toml [dependencies] tokio = { version = "1", features = ["full"] } serde = { version = "1", features = ["derive"], optional = true } [features] default = [] json = ["serde"] ``` ```rust #[cfg(feature = "json")] pub fn to_json(&self) -> String { /* ... */ } ``` --- ## 21. Smart Pointers ### Box — heap allocation ```rust let b = Box::new(5); println!("{}", *b); // recursive types enum List { Cons(i32, Box), Nil, } ``` ใช้ Box เมื่อ: - ต้องการ heap allocation - type ที่ recursive (compiler ต้องรู้ขนาดแน่นอน) - ต้องการ trait object ที่ owned ### Rc — Reference Counted (single thread) ```rust use std::rc::Rc; let a = Rc::new(String::from("hello")); let b = Rc::clone(&a); // เพิ่ม count, ไม่ deep clone let c = Rc::clone(&a); println!("count = {}", Rc::strong_count(&a)); // 3 ``` ใช้เมื่อต้องการ shared ownership ใน single thread ### Arc — Atomic Reference Counted (multi-thread) ```rust use std::sync::Arc; use std::thread; let data = Arc::new(vec![1, 2, 3]); let mut handles = vec![]; for _ in 0..3 { let data = Arc::clone(&data); handles.push(thread::spawn(move || { println!("{:?}", data); })); } for h in handles { h.join().unwrap(); } ``` ### RefCell — interior mutability ปกติแล้ว borrow checking ตรวจที่ compile-time แต่ `RefCell` เลื่อนการตรวจไป runtime ```rust use std::cell::RefCell; let value = RefCell::new(5); *value.borrow_mut() += 1; // mutate ทั้งที่ value ไม่ใช่ mut println!("{}", value.borrow()); // 6 ``` ใช้กับ pattern เช่น Rc> สำหรับ shared mutable state ใน single thread ### Mutex, RwLock multi-thread version ของ RefCell ```rust use std::sync::{Arc, Mutex}; let counter = Arc::new(Mutex::new(0)); let mut handles = vec![]; for _ in 0..10 { let counter = Arc::clone(&counter); handles.push(thread::spawn(move || { let mut num = counter.lock().unwrap(); *num += 1; })); } for h in handles { h.join().unwrap(); } println!("{}", counter.lock().unwrap()); // 10 ``` --- ## 22. Concurrency — Threads และ Channels ### Thread ```rust use std::thread; use std::time::Duration; let handle = thread::spawn(|| { for i in 1..=5 { println!("from thread: {}", i); thread::sleep(Duration::from_millis(100)); } }); handle.join().unwrap(); ``` ### Move closure กับ thread ```rust let v = vec![1, 2, 3]; let handle = thread::spawn(move || { // ต้องใช้ move println!("{:?}", v); }); handle.join().unwrap(); ``` ### Channel (mpsc — multi-producer, single-consumer) ```rust use std::sync::mpsc; let (tx, rx) = mpsc::channel(); thread::spawn(move || { tx.send(String::from("hello")).unwrap(); }); let received = rx.recv().unwrap(); println!("{}", received); ``` ### หลาย producer ```rust let (tx, rx) = mpsc::channel(); for i in 0..5 { let tx = tx.clone(); thread::spawn(move || { tx.send(i).unwrap(); }); } drop(tx); // ปิด original for received in rx { // วนจนกว่า channel จะปิด println!("{}", received); } ``` > **ปรัชญา Rust ตรงนี้เหมือน Go:** "Don't communicate by sharing memory; share memory by communicating" --- ## 23. Async/Await และ Tokio Rust มี `async`/`await` แต่ไม่มี runtime ในตัว — ต้องเลือก runtime เอง ที่ใช้กันมากคือ **Tokio** ```toml [dependencies] tokio = { version = "1", features = ["full"] } ``` ### พื้นฐาน ```rust use tokio::time::{sleep, Duration}; async fn say_hello() { sleep(Duration::from_secs(1)).await; println!("hello"); } #[tokio::main] async fn main() { say_hello().await; } ``` ### concurrent tasks ```rust use tokio::task; #[tokio::main] async fn main() { let h1 = task::spawn(async { sleep(Duration::from_secs(1)).await; "task 1 done" }); let h2 = task::spawn(async { sleep(Duration::from_secs(1)).await; "task 2 done" }); let (r1, r2) = tokio::join!(h1, h2); println!("{} | {}", r1.unwrap(), r2.unwrap()); } ``` ### tokio::select! รอ multiple async operation พร้อมกัน — แค่ตัวแรกที่เสร็จ ```rust use tokio::{select, time::{sleep, Duration}}; async fn run() { let task = sleep(Duration::from_secs(5)); let timeout = sleep(Duration::from_secs(2)); select! { _ = task => println!("task done"), _ = timeout => println!("timeout"), } } ``` ### HTTP request ด้วย reqwest ```rust use reqwest; #[tokio::main] async fn main() -> Result<(), Box> { let res = reqwest::get("https://api.github.com/repos/rust-lang/rust") .await? .json::() .await?; println!("{}", res["name"]); Ok(()) } ``` ### Stream ```rust use tokio_stream::StreamExt; async fn process() { let mut stream = tokio_stream::iter(1..=5); while let Some(item) = stream.next().await { println!("{}", item); } } ``` ### Spawn vs spawn_blocking ```rust // ใช้กับ async code tokio::task::spawn(async { /* async work */ }); // ใช้กับ CPU-bound หรือ sync I/O ที่ block thread tokio::task::spawn_blocking(|| { // heavy computation หรือ sync I/O }); ``` > **กฎทอง:** อย่ารัน blocking code (เช่น `std::thread::sleep`, blocking I/O) ใน async function — มันจะหยุด executor ทั้งตัว --- ## 24. Macros เบื้องต้น ### Declarative macro (macro_rules!) ```rust macro_rules! say_hello { () => { println!("Hello!"); }; ($name:expr) => { println!("Hello, {}!", $name); }; } say_hello!(); say_hello!("World"); ``` ### Macro ใน std ที่ใช้บ่อย ```rust println!("{}", x); eprintln!("error"); format!("{} + {} = {}", a, b, a + b); vec![1, 2, 3]; assert_eq!(a, b); todo!(); // panic แต่ compile ผ่าน — ใช้ตอนเขียน code ไว้ก่อน unimplemented!(); unreachable!(); dbg!(my_variable); // print + return value ``` ### Procedural macro ใช้สร้าง derive และ attribute macro — ซับซ้อนกว่า declarative ขอข้ามไปก่อน แต่นี่คือสิ่งที่ทำให้ libraries อย่าง serde, tokio เขียนได้สะดวก ```rust #[derive(Debug, Serialize, Deserialize)] // ทั้งสามคือ proc macro struct User { name: String } #[tokio::main] // attribute macro async fn main() { } ``` --- ## 25. Unsafe Rust `unsafe` เป็นช่องทางหนีกฎ borrow checker — ใช้ทำสิ่งที่ Rust ปกติไม่ให้ทำ 5 อย่างที่ทำได้ใน unsafe block: 1. Dereference raw pointer 2. เรียก unsafe function 3. Access/modify mutable static variable 4. Implement unsafe trait 5. Access field ของ union ```rust let mut num = 5; let r1 = &num as *const i32; let r2 = &mut num as *mut i32; unsafe { println!("r1 = {}", *r1); *r2 = 10; } ``` > **กฎ:** ใช้ unsafe น้อยที่สุด ห่อด้วย safe API ดีๆ ส่วนใหญ่ของ codebase ไม่ควรเห็น unsafe เลย ยกเว้นคุณกำลังเขียน FFI หรือ low-level data structure --- ## 26. Testing Rust มี testing ในตัว ไม่ต้องลง dependency ### Unit test ```rust // src/lib.rs หรือไฟล์ใดๆ pub fn add(a: i32, b: i32) -> i32 { a + b } #[cfg(test)] mod tests { use super::*; #[test] fn test_add() { assert_eq!(add(2, 3), 5); } #[test] fn test_negative() { assert_eq!(add(-1, -1), -2); } #[test] #[should_panic(expected = "division by zero")] fn test_panic() { divide(10, 0); } #[test] fn test_result() -> Result<(), String> { if 2 + 2 == 4 { Ok(()) } else { Err("math broken".into()) } } } ``` ```bash cargo test cargo test test_add # รันเฉพาะ test ที่ match cargo test --release # รันแบบ optimized cargo test -- --nocapture # ให้ println! ใน test แสดง cargo test -- --test-threads=1 # serial execution ``` ### Integration test ``` my-project/ ├── src/ │ └── lib.rs └── tests/ └── api_test.rs ``` ```rust // tests/api_test.rs use my_project; #[test] fn test_full_flow() { let result = my_project::run(); assert!(result.is_ok()); } ``` ### Doc test — test ในเอกสาร ```rust /// Adds two numbers. /// /// # Examples /// /// ``` /// use my_project::add; /// assert_eq!(add(2, 3), 5); /// ``` pub fn add(a: i32, b: i32) -> i32 { a + b } ``` `cargo test` จะรัน code ใน `///` ทั้งหมดเป็น test ด้วย — ทำให้เอกสารไม่ outdated ### Mocking ใช้ `mockall` crate ```rust use mockall::*; #[automock] trait UserRepo { fn get(&self, id: u64) -> Option; } #[test] fn test_service() { let mut mock = MockUserRepo::new(); mock.expect_get() .with(eq(1)) .returning(|_| Some(User { id: 1, name: "test".into() })); // ใช้ mock... } ``` --- ## 27. Performance, Profiling, Benchmark ### Release build vs Debug build ความต่างมหาศาล — release ทำ optimization เต็มรูปแบบ ```bash cargo build --release cargo run --release ``` > หลายครั้งมือใหม่บ่นว่า "Rust ช้ากว่า Python!" เพราะลืม `--release` — debug build ช้าจริง ### Cargo flags ที่ควรรู้ ```toml [profile.release] opt-level = 3 # 0-3, default 3 lto = "fat" # link-time optimization (ช้ากว่าตอน compile แต่ binary เร็วกว่า) codegen-units = 1 # parallel codegen (1 = ช้ากว่า แต่ optimize ดีกว่า) strip = true # ลบ symbol — binary เล็กลง panic = "abort" # ไม่ unwind stack เมื่อ panic — binary เล็กลง ``` ### Benchmark ด้วย criterion ```toml [dev-dependencies] criterion = "0.5" [[bench]] name = "my_bench" harness = false ``` ```rust // benches/my_bench.rs use criterion::{black_box, criterion_group, criterion_main, Criterion}; fn fib(n: u64) -> u64 { if n < 2 { n } else { fib(n - 1) + fib(n - 2) } } fn benchmark(c: &mut Criterion) { c.bench_function("fib 20", |b| b.iter(|| fib(black_box(20)))); } criterion_group!(benches, benchmark); criterion_main!(benches); ``` ```bash cargo bench ``` Criterion จะ generate HTML report ใน `target/criterion/` พร้อม graph ### Profiling ```bash # Linux: perf perf record --call-graph dwarf ./target/release/myapp perf report # flamegraph cargo install flamegraph cargo flamegraph # samply (cross-platform, ดี) cargo install samply samply record ./target/release/myapp ``` ### Memory profiling ```bash # valgrind valgrind --tool=massif ./target/release/myapp # heaptrack (Linux) heaptrack ./target/release/myapp ``` ### หลักการ optimize ใน Rust 1. **เลือก data structure ที่ถูก** — `Vec` vs `LinkedList`, `HashMap` vs `BTreeMap` 2. **หลีกเลี่ยง allocation** — pre-allocate ด้วย `Vec::with_capacity` 3. **ใช้ `&str` แทน `String`** เมื่อทำได้ (ไม่ alloc) 4. **ใช้ iterator แทน loop** — Rust optimize ได้ดีมาก 5. **`#[inline]`** สำหรับ hot function เล็กๆ 6. **SIMD** — ผ่าน `std::simd` (nightly) หรือ crates เช่น `wide` 7. **Profile ก่อน optimize** — guess ผิดบ่อยกว่าถูก --- ## 28. Patterns ใน Production ### Newtype Pattern ```rust struct UserId(u64); struct EmailAddress(String); fn send_email(to: EmailAddress, user: UserId) { // compiler ป้องกันการสลับลำดับ argument } // vs ถ้าใช้ primitive ตรงๆ fn send_email_bad(to: String, user: u64) { // สลับได้ง่าย — เกิด bug } ``` ### Builder Pattern ```rust #[derive(Default)] pub struct ServerBuilder { host: Option, port: Option, timeout: Option, } impl ServerBuilder { pub fn new() -> Self { Self::default() } pub fn host(mut self, host: impl Into) -> Self { self.host = Some(host.into()); self } pub fn port(mut self, port: u16) -> Self { self.port = Some(port); self } pub fn timeout(mut self, timeout: Duration) -> Self { self.timeout = Some(timeout); self } pub fn build(self) -> Result { Ok(Server { host: self.host.ok_or(BuildError::MissingHost)?, port: self.port.unwrap_or(8080), timeout: self.timeout.unwrap_or(Duration::from_secs(30)), }) } } let server = ServerBuilder::new() .host("localhost") .port(9090) .build()?; ``` ### Typestate Pattern — บังคับลำดับการเรียกที่ compile-time ```rust pub struct Locked; pub struct Unlocked; pub struct Door { _state: std::marker::PhantomData, } impl Door { pub fn unlock(self, key: &str) -> Door { Door { _state: std::marker::PhantomData } } } impl Door { pub fn open(self) { println!("Door opened"); } pub fn lock(self) -> Door { Door { _state: std::marker::PhantomData } } } // compiler บังคับ: unlock ก่อน open ได้ let door: Door = Door { _state: std::marker::PhantomData }; let door = door.unlock("key"); door.open(); ``` ### Repository Pattern ```rust #[async_trait::async_trait] pub trait UserRepository: Send + Sync { async fn create(&self, user: &NewUser) -> Result; async fn get(&self, id: i64) -> Result, AppError>; async fn update(&self, user: &User) -> Result<(), AppError>; async fn delete(&self, id: i64) -> Result<(), AppError>; } pub struct PostgresUserRepository { pool: sqlx::PgPool, } #[async_trait::async_trait] impl UserRepository for PostgresUserRepository { async fn create(&self, user: &NewUser) -> Result { // ... } // ... } ``` ### Graceful Shutdown ```rust use tokio::signal; #[tokio::main] async fn main() -> anyhow::Result<()> { let app = build_app().await?; let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?; axum::serve(listener, app) .with_graceful_shutdown(shutdown_signal()) .await?; Ok(()) } async fn shutdown_signal() { let ctrl_c = async { signal::ctrl_c().await.expect("install Ctrl+C handler"); }; #[cfg(unix)] let terminate = async { signal::unix::signal(signal::unix::SignalKind::terminate()) .expect("install SIGTERM handler") .recv() .await; }; tokio::select! { _ = ctrl_c => tracing::info!("Ctrl+C received"), _ = terminate => tracing::info!("SIGTERM received"), } } ``` --- ## 29. REST API ด้วย Axum [Axum](https://github.com/tokio-rs/axum) เป็น web framework ที่ทีม Tokio พัฒนา — type-safe, ergonomic, performant ```toml [dependencies] axum = "0.7" tokio = { version = "1", features = ["full"] } serde = { version = "1", features = ["derive"] } serde_json = "1" tower = "0.4" tower-http = { version = "0.5", features = ["trace", "cors"] } tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } ``` ### Hello world ```rust use axum::{routing::get, Router, Json}; use serde_json::{json, Value}; #[tokio::main] async fn main() { let app = Router::new() .route("/", get(root)) .route("/health", get(health)); let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap(); axum::serve(listener, app).await.unwrap(); } async fn root() -> &'static str { "Hello, World!" } async fn health() -> Json { Json(json!({"status": "ok"})) } ``` ### Path / Query / Body extractors ```rust use axum::{ extract::{Path, Query, State}, Json, Router, routing::{get, post}, }; use serde::{Deserialize, Serialize}; #[derive(Deserialize)] struct Pagination { page: Option, per_page: Option, } #[derive(Deserialize)] struct CreateUser { email: String, name: String, } #[derive(Serialize)] struct User { id: u64, email: String, name: String, } async fn get_user(Path(id): Path) -> Json { Json(User { id, email: "x@example.com".into(), name: "test".into(), }) } async fn list_users(Query(p): Query) -> Json> { Json(vec![]) } async fn create_user(Json(payload): Json) -> Json { Json(User { id: 1, email: payload.email, name: payload.name, }) } let app = Router::new() .route("/users", get(list_users).post(create_user)) .route("/users/:id", get(get_user)); ``` ### Shared state ```rust use std::sync::Arc; use axum::extract::State; #[derive(Clone)] struct AppState { db: sqlx::PgPool, redis: redis::Client, } async fn handler(State(state): State) -> &'static str { // use state.db, state.redis "ok" } let state = AppState { /* ... */ }; let app = Router::new() .route("/", get(handler)) .with_state(state); ``` ### Middleware ```rust use tower_http::trace::TraceLayer; use tower_http::cors::CorsLayer; let app = Router::new() .route("/", get(handler)) .layer(TraceLayer::new_for_http()) .layer(CorsLayer::permissive()); ``` ### Custom middleware ด้วย tower ```rust use axum::{middleware::{self, Next}, response::Response, http::Request}; async fn auth_middleware( req: Request, next: Next, ) -> Result { let token = req.headers() .get("authorization") .and_then(|v| v.to_str().ok()) .ok_or(StatusCode::UNAUTHORIZED)?; // verify token... Ok(next.run(req).await) } let app = Router::new() .route("/protected", get(handler)) .layer(middleware::from_fn(auth_middleware)); ``` ### Error handling แบบสมบูรณ์ ```rust use axum::{ http::StatusCode, response::{IntoResponse, Response}, Json, }; use serde_json::json; use thiserror::Error; #[derive(Error, Debug)] pub enum AppError { #[error("not found")] NotFound, #[error("invalid input: {0}")] BadRequest(String), #[error("unauthorized")] Unauthorized, #[error(transparent)] Sqlx(#[from] sqlx::Error), #[error(transparent)] Other(#[from] anyhow::Error), } impl IntoResponse for AppError { fn into_response(self) -> Response { let (status, message) = match &self { AppError::NotFound => (StatusCode::NOT_FOUND, "not found".to_string()), AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg.clone()), AppError::Unauthorized => (StatusCode::UNAUTHORIZED, "unauthorized".to_string()), AppError::Sqlx(e) => { tracing::error!("database error: {:?}", e); (StatusCode::INTERNAL_SERVER_ERROR, "database error".to_string()) } AppError::Other(e) => { tracing::error!("unexpected error: {:?}", e); (StatusCode::INTERNAL_SERVER_ERROR, "internal error".to_string()) } }; (status, Json(json!({"error": message}))).into_response() } } async fn handler() -> Result, AppError> { let user = get_user_from_db().await?; Ok(Json(user)) } ``` --- ## 30. Database ด้วย sqlx `sqlx` คือ async SQL toolkit ที่ใช้กันมากที่สุด — type-safe + compile-time SQL checking ```toml [dependencies] sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "macros", "chrono", "uuid"] } ``` ### Connection pool ```rust use sqlx::postgres::PgPoolOptions; let pool = PgPoolOptions::new() .max_connections(10) .acquire_timeout(Duration::from_secs(5)) .connect("postgres://user:pass@localhost/mydb") .await?; ``` ### Query ```rust use sqlx::PgPool; use chrono::{DateTime, Utc}; use uuid::Uuid; #[derive(sqlx::FromRow)] struct User { id: i64, email: String, name: String, created_at: DateTime, } // query_as — return struct async fn get_user(pool: &PgPool, id: i64) -> Result, sqlx::Error> { sqlx::query_as::<_, User>( "SELECT id, email, name, created_at FROM users WHERE id = $1" ) .bind(id) .fetch_optional(pool) .await } // query! macro — compile-time check (ต้องมี DB ตอน compile) async fn get_user_macro(pool: &PgPool, id: i64) -> Result { sqlx::query_as!( User, "SELECT id, email, name, created_at FROM users WHERE id = $1", id ) .fetch_one(pool) .await } // fetch หลายแบบ .fetch_one(pool) // ต้องเจอ 1 record (error ถ้าไม่เจอ) .fetch_optional(pool) // 0 หรือ 1 (Option) .fetch_all(pool) // Vec .fetch(pool) // Stream ``` ### Insert / Update ```rust async fn create_user(pool: &PgPool, email: &str, name: &str) -> Result { let row = sqlx::query!( "INSERT INTO users (email, name) VALUES ($1, $2) RETURNING id", email, name ) .fetch_one(pool) .await?; Ok(row.id) } ``` ### Transaction ```rust async fn transfer( pool: &PgPool, from: i64, to: i64, amount: i64, ) -> Result<(), sqlx::Error> { let mut tx = pool.begin().await?; sqlx::query!("UPDATE accounts SET balance = balance - $1 WHERE id = $2", amount, from) .execute(&mut *tx) .await?; sqlx::query!("UPDATE accounts SET balance = balance + $1 WHERE id = $2", amount, to) .execute(&mut *tx) .await?; tx.commit().await?; Ok(()) } ``` ### Migration ```bash cargo install sqlx-cli --no-default-features --features postgres sqlx migrate add create_users # แก้ไฟล์ใน migrations/ sqlx migrate run sqlx migrate revert ``` ```rust // auto-migrate ตอน start sqlx::migrate!("./migrations").run(&pool).await?; ``` --- ## 31. Observability ### Tracing ```toml [dependencies] tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] } ``` ```rust use tracing::{info, warn, error, instrument}; use tracing_subscriber::{EnvFilter, fmt}; fn init_tracing() { fmt() .with_env_filter(EnvFilter::from_default_env()) .json() .init(); } #[instrument(skip(pool))] // auto trace ทั้ง function async fn create_user(pool: &PgPool, email: &str) -> Result { info!(email = %email, "creating user"); let user = sqlx::query_as!(/* ... */).fetch_one(pool).await?; info!(user_id = user.id, "user created"); Ok(user) } ``` ```bash RUST_LOG=info,sqlx=warn cargo run ``` ### Metrics — Prometheus ```toml [dependencies] metrics = "0.22" metrics-exporter-prometheus = "0.13" ``` ```rust use metrics::{counter, histogram}; let builder = metrics_exporter_prometheus::PrometheusBuilder::new(); builder.install().expect("failed to install metrics exporter"); // ใน handler counter!("http_requests_total", "method" => "GET", "path" => "/users").increment(1); histogram!("request_duration_seconds").record(elapsed.as_secs_f64()); ``` ### OpenTelemetry ```toml [dependencies] opentelemetry = "0.21" opentelemetry_sdk = { version = "0.21", features = ["rt-tokio"] } opentelemetry-otlp = "0.14" tracing-opentelemetry = "0.22" ``` ```rust use opentelemetry::trace::TracerProvider; use opentelemetry_sdk::Resource; use tracing_subscriber::layer::SubscriberExt; fn init_telemetry() -> anyhow::Result<()> { let tracer = opentelemetry_otlp::new_pipeline() .tracing() .with_exporter(opentelemetry_otlp::new_exporter().tonic()) .with_trace_config( opentelemetry_sdk::trace::config() .with_resource(Resource::new(vec![ opentelemetry::KeyValue::new("service.name", "my-api"), ])), ) .install_batch(opentelemetry_sdk::runtime::Tokio)?; let telemetry = tracing_opentelemetry::layer().with_tracer(tracer); let subscriber = tracing_subscriber::Registry::default() .with(EnvFilter::from_default_env()) .with(telemetry) .with(fmt::layer()); tracing::subscriber::set_global_default(subscriber)?; Ok(()) } ``` --- ## 32. Build, Deploy, Docker ### Optimized release build ```toml [profile.release] opt-level = 3 lto = "fat" codegen-units = 1 strip = true panic = "abort" ``` ### Cross-compile ```bash rustup target add x86_64-unknown-linux-musl # static binary cargo build --release --target x86_64-unknown-linux-musl ``` หรือใช้ `cross` (ใช้ Docker compile cross-platform) ```bash cargo install cross cross build --release --target aarch64-unknown-linux-gnu ``` ### Multi-stage Dockerfile ```dockerfile FROM rust:1.78 AS builder WORKDIR /app # Cache dependencies layer COPY Cargo.toml Cargo.lock ./ RUN mkdir src && echo "fn main() {}" > src/main.rs && \ cargo build --release && \ rm -rf src COPY . . # Touch main.rs to force rebuild with real source RUN touch src/main.rs && cargo build --release # Runtime stage FROM debian:bookworm-slim RUN apt-get update && \ apt-get install -y ca-certificates && \ rm -rf /var/lib/apt/lists/* && \ useradd -m -u 1000 app COPY --from=builder /app/target/release/myapp /usr/local/bin/myapp USER app EXPOSE 8080 ENTRYPOINT ["myapp"] ``` ### Distroless ```dockerfile FROM rust:1.78 AS builder # build with musl for static binary RUN rustup target add x86_64-unknown-linux-musl WORKDIR /app COPY . . RUN cargo build --release --target x86_64-unknown-linux-musl FROM gcr.io/distroless/static:nonroot COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/myapp / USER nonroot:nonroot ENTRYPOINT ["/myapp"] ``` ผล: image ขนาด ~5-15MB ### cargo-chef — speed up Docker build ```dockerfile FROM lukemathwalker/cargo-chef:latest-rust-1.78 AS chef WORKDIR /app FROM chef AS planner COPY . . RUN cargo chef prepare --recipe-path recipe.json FROM chef AS builder COPY --from=planner /app/recipe.json recipe.json RUN cargo chef cook --release --recipe-path recipe.json COPY . . RUN cargo build --release FROM debian:bookworm-slim AS runtime COPY --from=builder /app/target/release/myapp /usr/local/bin/ ENTRYPOINT ["myapp"] ``` cargo-chef cache dependency build แยก — re-build เร็วขึ้นเป็น 10 เท่าเมื่อแค่แก้ source --- ## 33. สรุปและเส้นทางต่อไป ### Checklist ของ Rust developer มืออาชีพ - [ ] เข้าใจ ownership, borrowing, lifetime อย่างลึกซึ้ง - [ ] เลือก `&str` vs `String`, `&[T]` vs `Vec` ได้ถูก - [ ] ใช้ `Option`/`Result` คล่อง — ไม่ใช้ `unwrap` ใน production - [ ] ออกแบบ trait ที่ดี เข้าใจ static vs dynamic dispatch - [ ] เขียน async/await โดยไม่ block executor - [ ] เลือกใช้ `Box`, `Rc`, `Arc`, `RefCell`, `Mutex` ได้ถูกสถานการณ์ - [ ] error handling ด้วย `thiserror` (lib) หรือ `anyhow` (app) - [ ] เขียน test และ benchmark ด้วย criterion - [ ] อ่าน flamegraph เป็น - [ ] รู้จัก clippy lint ที่สำคัญ - [ ] graceful shutdown - [ ] structured logging ด้วย tracing ### หนังสือและแหล่งเรียนรู้ - **The Rust Programming Language** ("The Book") — https://doc.rust-lang.org/book/ (ฟรี) - **Rust by Example** — https://doc.rust-lang.org/rust-by-example/ (ฟรี) - **Rustlings** — https://github.com/rust-lang/rustlings (interactive exercises) - **Programming Rust** — Jim Blandy (หนังสือลึกที่สุด) - **Zero To Production In Rust** — Luca Palmieri (สร้าง backend จริง) - **Rust Atomics and Locks** — Mara Bos (concurrency ขั้นสูง) - **Asynchronous Programming in Rust** — Carl Fredrik Samson - **Jon Gjengset's YouTube** — https://www.youtube.com/@jonhoo (Rust ขั้นสูงมาก) ### Crate ที่ใช้บ่อยใน production | Use case | Crate | |---|---| | Async runtime | tokio | | Web framework | axum, actix-web, rocket | | HTTP client | reqwest | | SQL | sqlx, sea-orm, diesel | | Serialization | serde + serde_json/serde_yaml/toml | | Error (lib) | thiserror | | Error (app) | anyhow | | Logging | tracing + tracing-subscriber | | Config | config, figment | | Validation | validator | | JWT | jsonwebtoken | | CLI | clap | | Datetime | chrono, time | | UUID | uuid | | Regex | regex | | Random | rand | | Test mock | mockall | | Benchmark | criterion | | Macros helpers | proc-macro2, quote, syn | | Async traits | async-trait | ### หัวข้อขั้นสูงที่ควรไปต่อ 1. **Pin และ Future internals** — เข้าใจว่า async/await ทำงานยังไง 2. **Zero-copy parsing** — `nom`, `winnow` สำหรับ high-performance parsing 3. **Custom proc macro** — สร้าง derive ของตัวเอง 4. **Unsafe Rust ขั้นสูง** — Send, Sync, Pin, Drop, MaybeUninit 5. **WebAssembly** — `wasm-bindgen`, `wasmer`, `wasmtime` 6. **Embedded** — `embassy`, `embedded-hal` 7. **FFI** — เรียก C จาก Rust และกลับกัน (`bindgen`, `cbindgen`) 8. **GAT (Generic Associated Types)** — feature ใหม่ที่เปิดทางให้ design pattern หลายอย่าง ### Tips ส่งท้าย - **อย่าสู้กับ borrow checker** — ถ้ามันไม่ยอมให้ผ่าน 99% เป็นเพราะมีปัญหาจริงในการออกแบบ ไม่ใช่ compiler ผิด - **clone() ก่อน optimize ทีหลัง** — ตอนเรียนใหม่ๆ clone ไปก่อน อย่าจมอยู่กับ lifetime นาน - **อ่าน std library code** — เป็นแหล่งเรียน idiomatic Rust ที่ดีที่สุด - **`cargo expand`** — ดูว่า macro ขยายเป็นอะไร (ลง `cargo-expand`) - **`cargo audit`** — ตรวจ vulnerability ใน dependency - **`cargo machete`** — หา dependency ที่ไม่ใช้ --- ## ปิดท้าย Rust ไม่ใช่ภาษาที่จะให้คุณเขียนเร็วในวันแรก — แต่เป็นภาษาที่ลงทุนเรียนแล้วได้กลับมามาก: - โค้ดที่ผ่าน compile แล้วมักทำงานได้ถูกต้องเป็นส่วนใหญ่ — bug ที่เหลือมักเป็น logic ไม่ใช่ memory/concurrency - การ refactor ระดับใหญ่กลายเป็นเรื่องน่ายินดี — compiler บอกทุกที่ที่ต้องแก้ - Performance ดีโดยไม่ต้องคิดเยอะ — `Vec`, `HashMap`, iterator มักเร็วเทียบเท่า hand-written C - ไม่ต้องกลัวเขียน concurrent code — compiler จับ data race ให้ > "Rust empowers everyone to build reliable and efficient software." — สโลแกนของภาษา ที่บอกปรัชญาทั้งหมดในประโยคเดียว ใครที่เคยเขียน Go มาก่อนแล้วจะรู้สึกว่า Rust "พูดมาก" ตอนแรก — แต่นั่นคือ compiler กำลังช่วยให้คุณคิดให้รอบคอบ พอเขียนคล่องแล้วจะเสพติดความรู้สึกว่า "ถ้า compile ผ่านก็มักจะรันได้" Happy hacking! 🦀

SECURE_ACCESS

Rust — คู่มือฉบับสมบูรณ์

CONFIRM_DELETE