ภาษาโปรแกรม Rust

📚 สรุปเนื้อหา

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

จัดการศิลปะการเขียนโปรแกรมระบบที่ปลอดภัย รวดเร็ว และทำงานพร้อมกันได้อย่างมีประสิทธิภาพ ด้วยคู่มือฉบับสมบูรณ์สำหรับภาษา Rust

ผู้เขียน: สตีฟ แคลบ์นิก และ คารอล นิโคลส์ พร้อมการสนับสนุนจากชุมชน Rust

คำขอบคุณ: การสนับสนุนจากชุมชน Rust; ตีพิมพ์ในรูปแบบกระดาษและอีบุ๊กโดยสำนักพิมพ์ No Starch Press

🎯 เป้าหมายการเรียนรู้

1. ติดตั้งและจัดการชุดเครื่องมือ (toolchain) ของภาษา Rust ผ่าน rustup บนระบบปฏิบัติการต่างๆ ได้อย่างสำเร็จ
2. เขียน คอมไพล์ และรันโปรแกรม Rust พื้นฐาน พร้อมระบุองค์ประกอบหลักของโค้ด
3. ใช้ Cargo เพื่อสร้างโครงสร้างโปรเจกต์มาตรฐาน จัดการกระบวนการสร้าง และผลิตไฟล์ไบนารีที่เหมาะสมสำหรับการเผยแพร่
4. รับและจัดเก็บข้อมูลจากผู้ใช้ พร้อมจัดการความเป็นไปได้ในการเปลี่ยนแปลงตัวแปรและข้อผิดพลาดจากการอ่าน/เขียนข้อมูล (I/O)
5. รวมการพึ่งพาภายนอกผ่าน Cargo และจัดการการสร้างที่สามารถทำซ้ำได้ผ่าน Cargo.lock
6. ประยุกต์ใช้ตรรกะเกมโดยใช้การอนุมานประเภท วิเคราะห์สตริง ลูป และตัวดำเนินการควบคุมการไหลแบบ match
7. แยกแยะระหว่างค่าคงที่กับการซ้อนทับตัวแปรเพื่อจัดการความไม่สามารถเปลี่ยนแปลงข้อมูลและความครอบคลุมของตัวแปร
8. ใช้งานประเภทข้อมูลเชิงสเกลาร์ (จำนวนเต็ม ทศนิยม ตรรกะ ตัวอักษร) และประเภทข้อมูลเชิงโครงสร้าง (tuple, array) ได้อย่างถูกต้อง
9. แยกแยะระหว่างคำสั่ง (statement) กับข้อความ (expression) เพื่อกำหนดฟังก์ชันที่มีค่าคืนที่เฉพาะเจาะจง
10. แยกแยะระหว่างหน่วยความจำแบบสแต็กกับฮีพ และอธิบายวิธีที่ภาษา Rust จัดการข้อมูลในฮีพ

🔹 บทเรียนที่ 1: เริ่มต้นกับภาษา Rust

ภาพรวม: บทเรียนนี้นำเสนอการแนะนำอย่างครบถ้วนเกี่ยวกับระบบนิเวศของภาษา Rust โดยเน้นการตั้งค่าสภาพแวดล้อมและการทำงานพื้นฐานของนักพัฒนา Rust นักเรียนจะเริ่มจากการติดตั้งภาษาผ่าน rustup ไปจนถึงการเขียนโปรแกรม "สวัสดีโลก!" ด้วยตนเอง และสุดท้ายก็มีทักษะในการใช้ Cargo ซึ่งเป็นระบบสร้างและจัดการแพ็กเกจอย่างเป็นทางการของภาษา Rust เพื่อจัดการโปรเจกต์อย่างมืออาชีพและเพิ่มประสิทธิภาพการเผยแพร่

ผลลัพธ์การเรียนรู้:

• ติดตั้งและจัดการชุดเครื่องมือ (toolchain) ของภาษา Rust ผ่าน rustup บนระบบปฏิบัติการต่างๆ ได้อย่างสำเร็จ
• เขียน คอมไพล์ และรันโปรแกรม Rust พื้นฐาน พร้อมระบุองค์ประกอบหลักของโค้ด
• ใช้ Cargo เพื่อสร้างโครงสร้างโปรเจกต์มาตรฐาน จัดการกระบวนการสร้าง และผลิตไฟล์ไบนารีที่เหมาะสมสำหรับการเผยแพร่

🔹 บทเรียนที่ 2: ฝึกปฏิบัติ: สร้างเกมเดาตัวเลข

ภาพรวม: บทเรียนนี้นำนักพัฒนาไปสู่การสร้างเกมเดาตัวเลขที่ใช้งานได้จริงในภาษา Rust ผ่านไลน์อินเทอร์เฟซ (CLI) โดยครอบคลุมแนวคิดพื้นฐานของการเขียนโปรแกรมระบบ เช่น การประมวลผลข้อมูลจากผู้ใช้ การรวมแพ็กเกจภายนอกเพื่อจัดการการสุ่มตัวเลข และแนวทางเฉพาะของภาษา Rust ในการจัดการความปลอดภัยของหน่วยความจำและการจัดการข้อผิดพลาดผ่าน Result และการจับคู่รูปแบบ (pattern matching) หลังจบบทเรียน นักเรียนจะมีแอปพลิเคชันที่แข็งแรง รองรับการจัดการข้อมูลที่ผิดพลาด และมีการสร้างที่สามารถทำซ้ำได้

ผลลัพธ์การเรียนรู้:

• รับและจัดเก็บข้อมูลจากผู้ใช้ พร้อมจัดการความเป็นไปได้ในการเปลี่ยนแปลงตัวแปรและข้อผิดพลาดจากการอ่าน/เขียนข้อมูล (I/O)
• รวมการพึ่งพาภายนอกผ่าน Cargo และจัดการการสร้างที่สามารถทำซ้ำได้ผ่าน Cargo.lock
• ประยุกต์ใช้ตรรกะเกมโดยใช้การอนุมานประเภท วิเคราะห์สตริง ลูป และตัวดำเนินการควบคุมการไหลแบบ match

🔹 บทเรียนที่ 3: แนวคิดการเขียนโปรแกรมพื้นฐาน

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

ผลลัพธ์การเรียนรู้:

• แยกแยะระหว่างค่าคงที่กับการซ้อนทับตัวแปรเพื่อจัดการความไม่สามารถเปลี่ยนแปลงข้อมูลและความครอบคลุมของตัวแปร
• ใช้งานประเภทข้อมูลเชิงสเกลาร์ (จำนวนเต็ม ทศนิยม ตรรกะ ตัวอักษร) และประเภทข้อมูลเชิงโครงสร้าง (tuple, array) ได้อย่างถูกต้อง
• แยกแยะระหว่างคำสั่ง (statement) กับข้อความ (expression) เพื่อกำหนดฟังก์ชันที่มีค่าคืนที่เฉพาะเจาะจง

🔹 บทเรียนที่ 4: ความเข้าใจเกี่ยวกับการถือครองและหน่วยความจำ

ภาพรวม: บทเรียนนี้สำรวจแนวทางพิเศษของภาษา Rust ในการจัดการหน่วยความจำผ่านระบบการถือครอง (Ownership system) แทนการพึ่งพาระบบรวบรวมขยะ (garbage collector) หรือการจัดการหน่วยความจำด้วยตนเอง ภาษา Rust ใช้กฎสามข้อที่ตรวจสอบในขณะคอมไพล์เพื่อให้มั่นใจในความปลอดภัยของหน่วยความจำ บทนี้ครอบคลุมกลไกของสแต็กและฮีพ วงจรชีวิตของข้อมูล และวิธีที่การอ้างอิง (references) และสไลซ์ (slices) ให้การเข้าถึงหน่วยความจำอย่างปลอดภัยและมีประสิทธิภาพ โดยไม่ต้องโอนการถือครอง

ผลลัพธ์การเรียนรู้:

• แยกแยะระหว่างหน่วยความจำแบบสแต็กกับฮีพ และอธิบายวิธีที่ภาษา Rust จัดการข้อมูลในฮีพ
• ประยุกต์ใช้กฎสามข้อของการถือครองเพื่อคาดการณ์สถานะและขอบเขตของตัวแปร
• แสดงความแตกต่างระหว่างการย้าย (Move), การคัดลอก (Clone), และการถ่ายโอน (Copy)

🔹 บทเรียนที่ 5: โครงสร้างข้อมูล (Structs): การจัดการข้อมูลที่เกี่ยวข้องกัน

ภาพรวม: บทเรียนนี้สำรวจวิธีการจัดกลุ่มข้อมูลที่เกี่ยวข้องกันเป็นประเภทที่กำหนดเองโดยใช้โครงสร้างข้อมูล (structs) เพื่อสร้างโค้ดที่มีความหมายและจัดระเบียบได้ดีขึ้น มีการครอบคลุมการกำหนดและสร้างตัวอย่างของรูปแบบโครงสร้างข้อมูลต่าง ๆ (แบบคลาสสิก แบบทูเพิล และแบบหน่วย) การจัดการการถือครองข้อมูลภายในโครงสร้างเหล่านี้ และการเสริมความสามารถของโครงสร้างข้อมูลผ่านคุณสมบัติที่สืบทอดมา เช่น Debug และเมธอดที่กำหนดเองผ่านบล็อก impl

ผลลัพธ์การเรียนรู้:

• กำหนดและสร้างโครงสร้างข้อมูลโดยใช้ฟิลด์ชื่อ รูปแบบย่อ และรูปแบบอัปเดต
• แยกแยะระหว่างโครงสร้างแบบคลาสสิก โครงสร้างแบบทูเพิล และโครงสร้างแบบหน่วย และระบุกรณีการใช้งาน
• ใช้คุณสมบัติ Debug และใช้แมโคร dbg! เพื่อตรวจสอบข้อมูลในโครงสร้างข้อมูล

🔹 บทเรียนที่ 6: ตัวเลือก (Enums) และการจับคู่รูปแบบ

ภาพรวม: บทเรียนนี้สำรวจวิธีที่ภาษา Rust ใช้การกำหนดประเภทข้อมูล (enums) โดยการระบุตัวเลือกที่เป็นไปได้ ซึ่งช่วยให้สามารถจัดกลุ่มค่าคงที่และข้อมูลที่เกี่ยวข้องได้อย่างยืดหยุ่นกว่าการใช้โครงสร้างข้อมูลเพียงอย่างเดียว บทเรียนนี้ครอบคลุมบทบาทสำคัญของ Option ในการกำจัดข้อผิดพลาดจากค่า null และแสดงให้เห็นว่า match และ if let ช่วยให้ควบคุมการทำงานได้อย่างปลอดภัยและครอบคลุมเมื่อจัดการกับรูปแบบข้อมูลที่ซับซ้อน

ผลลัพธ์การเรียนรู้:

• กำหนดตัวเลือก (enum) ที่มีประเภทข้อมูลต่าง ๆ และนำไปใช้กับเมธอดผ่านบล็อก impl
• อธิบายข้อดีด้านความปลอดภัยของ Option<T> เมื่อเทียบกับค่า null แบบดั้งเดิม
• สร้างคำสั่ง match ที่ครอบคลุมทุกกรณี สามารถผูกกับค่าภายในตัวเลือกได้ และใช้ตัวแทนทั่วไป (placeholder) สำหรับกรณีที่ไม่ตรง

🔹 บทเรียนที่ 7: โมดูล แพ็กเกจ และคราส

ภาพรวม: บทเรียนนี้สำรวจวิธีที่ภาษา Rust จัดระเบียบโค้ดเพื่อให้อ่านง่ายและใช้ซ้ำได้ผ่านระบบโมดูล มีการครอบคลุมการสร้างต้นไม้โมดูล การใช้กฎการซ่อน (privacy rules) เพื่อควบคุมความเห็นของไอเท็ม และการใช้เส้นทาง (path) และคำสำคัญเช่น use และ pub เพื่อจัดการขอบเขตและสร้างอินเทอร์เฟซที่สะอาด

ผลลัพธ์การเรียนรู้:

• จัดระเบียบโค้ดเป็นโครงสร้างแบบลำดับชั้นโดยใช้โมดูลและต้นไม้โมดูล
• อ้างอิงไอเท็มในโค้ดโดยใช้เส้นทางแบบสัมบูรณ์หรือสัมพัทธ์
• ควบคุมการมองเห็นของฟังก์ชัน โมดูล และฟิลด์โดยใช้คำสำคัญ pub และกฎการซ่อน

🔹 บทเรียนที่ 8: คอลเลกชันทั่วไป

ภาพรวม: บทเรียนนี้สำรวจคอลเลกชันในไลบรารีมาตรฐานของภาษา Rust โดยเน้นที่เวกเตอร์ (Vectors), สตริง (Strings), และแฮชแมป (Hash Maps) โครงสร้างข้อมูลเหล่านี้ถูกจัดเก็บในฮีพ ทำให้สามารถขยายหรือหดขนาดได้ทันที และบทเรียนนี้อธิบายวิธีที่กฎการถือครองและการยืม (ownership and borrowing) ของภาษา Rust รับประกันความปลอดภัยของหน่วยความจำและประสิทธิภาพเมื่อจัดการรายการข้อมูล ข้อความที่เข้ารหัสเป็น UTF-8 และการจับคู่คีย์-ค่า

ผลลัพธ์การเรียนรู้:

• ใช้ Vec<T> เพื่อสร้างรายการที่มีขนาดเปลี่ยนแปลงได้ และจัดการวงจรชีวิตโดยใช้ตัวตรวจสอบยืม (borrow checker)
• จัดการข้อความที่เข้ารหัสเป็น UTF-8 ด้วย String พร้อมทำความเข้าใจความซับซ้อนของโครงสร้างภายในและการต่อสตริง
• ใช้ HashMap<K, V> เพื่อจัดเก็บและอัปเดตข้อมูลที่เกี่ยวข้องได้อย่างมีประสิทธิภาพ โดยใช้ API ของ Entry และพิจารณาเรื่องแฮชที่กำหนดเอง

🔹 บทเรียนที่ 9: กลยุทธ์การจัดการข้อผิดพลาด

ภาพรวม: บทเรียนนี้สำรวจปรัชญาการจัดการข้อผิดพลาดที่แข็งแกร่งของภาษา Rust ซึ่งแบ่งข้อผิดพลาดออกเป็นสองประเภท: ข้อผิดพลาดที่แก้ไขได้และข้อผิดพลาดที่แก้ไขไม่ได้ นักเรียนจะเรียนรู้วิธีใช้แมโคร panic! สำหรับข้อผิดพลาดร้ายแรง ใช้ Result สำหรับข้อผิดพลาดที่จัดการได้ และใช้เครื่องหมาย ? เพื่อให้การส่งต่อข้อผิดพลาดเป็นไปอย่างราบรื่น นอกจากนี้ ยังครอบคลุมวิธีใช้ระบบประเภทของภาษา Rust เพื่อตรวจสอบความถูกต้องของข้อมูลและรักษาความสมบูรณ์ของโปรแกรม

ผลลัพธ์การเรียนรู้:

• ระบุเวลาที่ควรใช้ panic! ที่แก้ไขไม่ได้ หรือ Result ที่แก้ไขได้ ตามเกณฑ์ของ "สถานะผิดปกติ"
• ใช้การเรียกกลับ (backtraces) เพื่อตรวจสอบต้นตอของข้อผิดพลาดที่แก้ไขไม่ได้
• ประยุกต์ใช้การส่งต่อข้อผิดพลาดด้วยเครื่องหมาย ? และปรับ main ให้รองรับการคืนข้อผิดพลาด

🔹 บทเรียนที่ 10: ตัวแปรทั่วไป คุณสมบัติ และอายุการใช้งาน

ภาพรวม: บทเรียนนี้สำรวจเครื่องมือของภาษา Rust สำหรับการสร้างการสร้างภาพรวมที่มีประสิทธิภาพ: ตัวแปรทั่วไป (Generics) เพื่อลดการซ้ำซ้อนของโค้ดในหลายประเภท คุณสมบัติ (Traits) เพื่อกำหนดพฤติกรรมที่แชร์ (เหมือนอินเทอร์เฟซ) และอายุการใช้งาน (Lifetimes) เพื่อให้มั่นใจในความปลอดภัยของหน่วยความจำโดยไม่ต้องจัดการด้วยตนเอง ทั้งสามคุณสมบัตินี้ช่วยให้นักพัฒนาสามารถเขียนโค้ดที่มีประสิทธิภาพสูง ใช้ซ้ำได้ และได้รับการตรวจสอบโดยคอมไพเลอร์เพื่อป้องกันการอ้างอิงที่ล้าสมัยและข้อผิดพลาดด้านประเภท

ผลลัพธ์การเรียนรู้:

• กำหนดและใช้พารามิเตอร์ประเภททั่วไปในฟังก์ชัน โครงสร้างข้อมูล และตัวเลือกเพื่อจัดการหลายประเภทข้อมูล
• ใช้คุณสมบัติ (Traits) และข้อจำกัดของคุณสมบัติ (Trait Bounds) เพื่อกำหนดพฤติกรรมที่แชร์และจำกัดประเภททั่วไป
• ใช้การระบุอายุการใช้งาน (Lifetime annotations) และกฎการละเลย (Elision rules) เพื่อจัดการความถูกต้องของตัวอ้างอิงและผ่านการตรวจสอบยืม

🔹 บทเรียนที่ 11: เขียนการทดสอบอัตโนมัติ

ภาพรวม: บทเรียนนี้สำรวจการนำการทดสอบอัตโนมัติมาใช้ในภาษา Rust ครอบคลุมข้อกำหนดโครงสร้างของฟังก์ชันทดสอบ การใช้แมโครการตรวจสอบ (assertion macros) เพื่อยืนยันตรรกะ และความแตกต่างเชิงเทคนิคระหว่างการทดสอบย่อย (unit test) และการทดสอบรวม (integration test) นักเรียนยังจะเข้าใจวิธีควบคุมพฤติกรรมของตัวดำเนินการทดสอบ (test runner) เพื่อจัดการการดำเนินการและการแสดงผล

ผลลัพธ์การเรียนรู้:

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

🔹 บทเรียนที่ 12: โปรเจกต์ I/O: เครื่องมือบรรทัดคำสั่ง

ภาพรวม: บทเรียนนี้นำนักพัฒนาไปสู่การสร้างเครื่องมือบรรทัดคำสั่งที่ใช้งานได้จริง (แบบง่ายของ grep) ในภาษา Rust โดยเน้นการเปลี่ยนจากไฟล์เดียวไปสู่ไบนารีที่มีโครงสร้างดีและพร้อมใช้งานจริง โดยเน้นการวิเคราะห์อาร์กิวเมนต์อย่างปลอดภัยต่อหน่วยความจำ การอ่าน/เขียนไฟล์ และการแยกส่วนความรับผิดชอบระหว่างตรรกะไลบรารีกับอินเทอร์เฟซบรรทัดคำสั่ง นักเรียนจะต้องออกแบบการจัดการข้อผิดพลาดที่แข็งแรงและพัฒนาคุณสมบัติใหม่ด้วยวิธีทดสอบตามแนวทาง (TDD) โดยจัดการสถานะของแอปพลิเคชันผ่านตัวแปรสภาพแวดล้อม

ผลลัพธ์การเรียนรู้:

• รับและแปลงอาร์กิวเมนต์บรรทัดคำสั่งให้กลายเป็นวัตถุการตั้งค่าที่มีโครงสร้าง
• ปรับปรุงโค้ดให้สอดคล้องกับหลักการ "แยกความรับผิดชอบ" (Separation of Concerns) สำหรับโปรเจกต์ไบนารี
• ใช้วงจรการทดสอบตามแนวทาง (TDD) พร้อมการระบุอายุการใช้งาน (lifetime annotations) ในการสร้างตรรกะหลัก

🔹 บทเรียนที่ 13: คุณสมบัติเชิงฟังก์ชัน: อีเทอร์เรเตอร์และคลอเจอร์

ภาพรวม: บทเรียนนี้สำรวจคุณสมบัติการเขียนโปรแกรมเชิงฟังก์ชันของภาษา Rust โดยเน้นที่คลอเจอร์ (closures) และอีเทอร์เรเตอร์ (iterators) คลอเจอร์คือฟังก์ชันที่ไม่มีชื่อที่สามารถจับข้อมูลจากสภาพแวดล้อมของมันได้ ภายใต้กฎของทรีต Fn ส่วนอีเทอร์เรเตอร์ให้วิธีการประมวลผลลำดับข้อมูลแบบดีด (lazy) และมีประสิทธิภาพ ทั้งสองคุณสมบัตินี้ช่วยให้เขียนโค้ดที่มีเอกลักษณ์และสอดคล้องกับหลักการ "การสร้างภาพรวมที่ไม่ใช้ค่า" (zero-cost abstraction) ของภาษา Rust โดยมักมีประสิทธิภาพเท่าหรือดีกว่าลูปแบบดั้งเดิม

ผลลัพธ์การเรียนรู้:

• กำหนดฟังก์ชันที่ไม่มีชื่อ (คลอเจอร์) และอธิบายว่ามันจับตัวแปรจากสภาพแวดล้อมผ่านการยืม (borrowing) หรือการย้าย (moving) ได้อย่างไร
• แยกแยะระหว่างสามทรีต Fn (Fn, FnMut, และ FnOnce) และเข้าใจว่าคอมไพเลอร์อนุมานประเภทคลอเจอร์ได้อย่างไร
• ใช้ทรีต Iterator โดยใช้เมธอด next และแยกแยะระหว่างการปรับเปลี่ยนแบบบริโภค (consuming adaptors) กับการปรับเปลี่ยนแบบอีเทอร์เรเตอร์ (iterator adaptors)

🔹 บทเรียนที่ 14: ขั้นสูงของ Cargo และ Crates.io

ภาพรวม: บทเรียนนี้สำรวจคุณสมบัติขั้นสูงของแพ็กเกจแมนีเจอร์ของภาษา Rust คือ Cargo และระบบนิเวศของเขาคือ Crates.io มุ่งเน้นการปรับปรุงการสร้างด้วยโปรไฟล์การปล่อย (release profiles) การสร้างเอกสารระดับมืออาชีพพร้อมการทดสอบที่ฝังอยู่ และการจัดโครงสร้างของอินเทอร์เฟซสาธารณะที่มีคุณภาพ บทเรียนนี้ยังครอบคลุมวงจรชีวิตของคราส — จากการเผยแพร่ การตั้งชื่อเวอร์ชัน ไปจนถึงการจัดการโปรเจกต์หลายแพ็กเกจผ่านเวิร์กสเปซ และการขยายความสามารถของ Cargo อย่างเป็นธรรมชาติ

ผลลัพธ์การเรียนรู้:

• ตั้งค่าโปรไฟล์การปล่อยเพื่อสมดุลระหว่างความเร็วในการคอมไพล์และประสิทธิภาพการรัน
• สร้างและตรวจสอบคำอธิบายเอกสาร (documentation comments) ที่ใช้ทั้งเป็นคู่มือผู้ใช้และเป็นการทดสอบอัตโนมัติ
• ออกแบบอินเทอร์เฟซสาธารณะที่สะดวกโดยใช้ pub use เพื่อแยกโครงสร้างภายในออกจากโครงสร้างภายนอก

🔹 บทเรียนที่ 15: โป인터ฉลาด (Smart Pointers)

ภาพรวม: บทเรียนนี้สำรวจโปинтерฉลาดของภาษา Rust ซึ่งเป็นโครงสร้างข้อมูลที่ทำงานเหมือนโป인터แต่มีข้อมูลเพิ่มเติมและคุณสมบัติเพิ่มเติม เราโฟกัสที่การจัดการการจัดสรรหน่วยความจำในฮีพผ่าน Box<T> การสนับสนุนการถือครองร่วมกันผ่าน Rc<T> และการหลีกเลี่ยงกฎการยืมอย่างเข้มงวดผ่านรูปแบบการเปลี่ยนแปลงภายใน (Interior Mutability) ด้วย RefCell<T> นอกจากนี้ ยังครอบคลุมทรีต Deref และ Drop ซึ่งเป็นพื้นฐานของพฤติกรรมของโป인터ฉลาดและการทำความสะอาดทรัพยากร

ผลลัพธ์การเรียนรู้:

• สร้างโครงสร้างข้อมูลแบบเรียกซ้ำ (recursive) โดยใช้ Box<T> เพื่อให้เกิดการชี้ไปยังตำแหน่งที่แน่นอนในหน่วยความจำ
• ปรับแต่งพฤติกรรมของโป인터และจัดการทรัพยากรโดยใช้ทรีต Deref และ Drop
• จัดการผู้ถือครองหลายคนและสถานะการเปลี่ยนแปลงที่ตรวจสอบในเวลาทำงานโดยการรวม Rc<T> และ RefCell<T>

🔹 บทเรียนที่ 16: การทำงานพร้อมกันอย่างกล้าหาญ

ภาพรวม: บทเรียนนี้สำรวจปรัชญา "การจัดการการทำงานพร้อมกันอย่างกล้าหาญ" (Fearless Concurrency) ของภาษา Rust ซึ่งแสดงให้เห็นว่าภาษาสามารถเปลี่ยนการเขียนโปรแกรมแบบพร้อมกันจากสนามรบที่เต็มไปด้วยข้อผิดพลาดในเวลาทำงานให้กลายเป็นความแน่นอนในเวลาคอมไพล์ บทเรียนนี้ครอบคลุมการสร้างเธรด การสื่อสารอย่างปลอดภัยผ่านการส่งข้อความ (message passing) การจัดการสถานะร่วมกันด้วยเม็กซ์ (mutex) และทรีตพื้นฐานที่กำหนดความปลอดภัยของเธรด

ผลลัพธ์การเรียนรู้:

• สร้างและจัดการเธรดโดยใช้ spawn และ join โดยแก้ไขข้อขัดแย้งการถือครองด้วยคำสำคัญ move
• ใช้ช่องส่งข้อความแบบ mpsc เพื่อส่งข้อมูลอย่างปลอดภัยระหว่างเธรด
• จัดการสถานะร่วมกันระหว่างหลายเธรดโดยใช้ Mutex<T> เพื่อการป้องกันการเข้าถึงพร้อมกัน และ Arc<T> เพื่อการนับอ้างอิงที่ปลอดภัยต่อเธรด

🔹 บทเรียนที่ 17: การเขียนโปรแกรมเชิงวัตถุในภาษา Rust

ภาพรวม: บทเรียนนี้สำรวจวิธีที่ภาษา Rust ประยุกต์ใช้หลักการหลักของการเขียนโปรแกรมเชิงวัตถุ (OOP) โดยเน้นที่การซ่อนข้อมูล (encapsulation) และพหุรูป (polymorphism) มีการอธิบายกลไกของวัตถุทรีต (trait objects) สำหรับจัดการกลุ่มข้อมูลที่หลากหลาย และข้อเสียเปรียบระหว่างการส่งผ่านแบบคงที่กับแบบไดนามิก บทเรียนสุดท้ายเปรียบเทียบการใช้รูปแบบสถานะ (State Pattern) ดั้งเดิมกับแนวทางที่เหมาะกับภาษา Rust ซึ่งคือการเข้ารหัสสถานะและพฤติกรรมโดยตรงลงในระบบประเภท

ผลลัพธ์การเรียนรู้:

• ประยุกต์ใช้การซ่อนข้อมูลในภาษา Rust โดยใช้โมดูลและตัวบ่งชี้การเข้าถึงเพื่อซ่อนสถานะภายใน
• ใช้วัตถุทรีตเพื่อให้เกิดพหุรูป และเข้าใจผลกระทบด้านประสิทธิภาพระหว่างการส่งผ่านแบบคงที่กับแบบไดนามิก
• ใช้รูปแบบสถานะ (State Pattern) เพื่อจัดการพฤติกรรมของวัตถุที่ซับซ้อนและเปลี่ยนสถานะได้

🔹 บทเรียนที่ 18: รูปแบบและจับคู่ขั้นสูง

ภาพรวม: บทเรียนนี้สำรวจความลึกซึ้งของระบบการจับคู่รูปแบบ (pattern matching) ของภาษา Rust โดยย้ายจาก match ง่าย ๆ ไปสู่การดึงข้อมูลที่ซับซ้อนและควบคุมการไหลที่ซับซ้อน นักเรียนจะเรียนรู้การแยกแยะระหว่างรูปแบบที่ไม่สามารถปฏิเสธได้ (irrefutable) กับรูปแบบที่สามารถปฏิเสธได้ (refutable) เรียนรู้การแยกโครงสร้างที่ซ้อนกัน และใช้ไวยากรณ์ขั้นสูงเช่น ข้อจำกัด (match guards) และการผูก (bindings) เพื่อเขียนโค้ดที่มีความหมายมากขึ้นและปลอดภัยยิ่งขึ้น

ผลลัพธ์การเรียนรู้:

• แยกแยะระหว่างรูปแบบที่ไม่สามารถปฏิเสธได้ (irrefutable) กับรูปแบบที่สามารถปฏิเสธได้ (refutable) และนำไปใช้กับโครงสร้างที่เหมาะสมของภาษา Rust (เช่น let กับ if let)
• แยกโครงสร้างข้อมูล ตัวเลือก และทูเพิลเพื่อดึงข้อมูลเฉพาะไปยังตัวแปรท้องถิ่น
• ใช้ไวยากรณ์รูปแบบขั้นสูง รวมถึงช่วง (ranges) รูปแบบหลายแบบ ข้ามค่า และการผูกด้วย @ สำหรับการจับคู่เงื่อนไขที่ซับซ้อน

🔹 บทเรียนที่ 19: คุณสมบัติขั้นสูงและภาษา Rust แบบไม่ปลอดภัย

ภาพรวม: บทเรียนนี้สำรวจ "พลังพิเศษ" ของภาษา Rust ที่ทำให้นักพัฒนาสามารถละเลยข้อจำกัดบางประการของคอมไพเลอร์และสร้างโครงสร้างที่ยืดหยุ่นสูง ครอบคลุมการใช้ภาษา Rust แบบไม่ปลอดภัย (Unsafe Rust) สำหรับการจัดการหน่วยความจำระดับล่าง วิธีการใช้ทรีตขั้นสูงเพื่อจัดการความสัมพันธ์ระหว่างประเภทที่ซับซ้อน และความสามารถด้านการเขียนโปรแกรมเชิงโครงสร้าง (metaprogramming) ที่ทรงพลังของแมโครแบบอธิบาย (Declarative) และแมโครแบบเชิงกระบวนการ (Procedural)

ผลลัพธ์การเรียนรู้:

• แยกแยะระหว่างภาษา Rust แบบปลอดภัยกับ "พลังพิเศษ" ที่จำเป็นสำหรับการจัดการตัวชี้ตรง (raw pointer) และการเรียกฟังก์ชันที่ไม่ปลอดภัย
• ใช้รูปแบบทรีตขั้นสูง เช่น ประเภทที่เกี่ยวข้อง (Associated Types), การโอเวอร์โหลดเครื่องหมาย (Operator Overloading), ทรีตย่อย (Supertraits), และรูปแบบใหม่ (Newtype)
• แยกแยะการเรียกเมธอดโดยใช้ไวยากรณ์ที่ระบุอย่างครบถ้วน และจัดการประเภทที่ซับซ้อน เช่น ประเภทที่ไม่ทราบขนาด (DST) และชื่อประเภท (Type Aliases)

🔹 บทเรียนที่ 20: โปรเจกต์สุดท้าย: เซิร์ฟเวอร์เว็บแบบหลายเธรด

ภาพรวม: บทเรียนนี้นำนักเรียนไปสู่การพัฒนาเซิร์ฟเวอร์เว็บประสิทธิภาพสูงโดยใช้เครื่องมือการเชื่อมต่อและฟีเจอร์การจัดการหลายเธรดของภาษา Rust ครอบคลุมการเปลี่ยนจากตัวรับข้อมูลแบบพื้นฐาน (TCP) ไปสู่ระบบหลายเธรดที่ซับซ้อน โดยใช้สแต็คเธรดที่สร้างเอง นักเรียนจะเรียนรู้การจัดการสตรีมระดับล่าง การประยุกต์ใช้การส่งข้อมูลแบบทำงานโดยผู้ทำงาน (worker-based message passing) เพื่อกระจายงาน และรักษาความมั่นคงของระบบผ่านกลไกการปิดเซิร์ฟเวอร์อย่างเป็นระเบียบ

ผลลัพธ์การเรียนรู้:

• ตั้งค่าและจัดการการเชื่อมต่อแบบ TCP: ผูกเซิร์ฟเวอร์กับพอร์ตในเครื่องและจัดการสตรีมข้อมูลที่เข้ามา
• วิเคราะห์และตอบสนองต่อคำขอ HTTP: รับข้อมูลคำขอแบบดิจิทัลและสร้างคำตอบ HTTP ที่ถูกต้องพร้อมบรรทัดสถานะและเนื้อหา HTML
• ออกแบบสแต็คเธรดที่กำหนดเอง: ใช้ช่องส่งข้อความ mpsc และตัวช่วยสังเกตการณ์ (สัญลักษณ์ Arc, Mutex) เพื่อกระจายงานไปยังจำนวนเธรดที่จำกัด

🔹 บทเรียนที่ 21: ภาคผนวกภาษา Rust: เครื่องมือและแหล่งอ้างอิง

ภาพรวม: บทเรียนนี้ให้แหล่งอ้างอิงทางเทคนิคที่ครอบคลุมสำหรับภาษา Rust โดยเน้นไวยากรณ์ที่หนาแน่น เครื่องมือพัฒนาอัตโนมัติ และกระบวนการอัปเดตเวอร์ชันที่พัฒนาอย่างต่อเนื่อง นักเรียนจะเรียนรู้วิธีใช้ไวยากรณ์ที่มีสัญลักษณ์จำนวนมากของภาษา Rust ใช้ทรีตที่สามารถสืบทอดได้เพื่อจัดการพฤติกรรมมาตรฐาน และใช้เครื่องมือในระบบนิเวศเพื่อรักษาคุณภาพโค้ดสูงและปฏิบัติตามปรัชญา "ความมั่นคงโดยไม่หยุดนิ่ง"

ผลลัพธ์การเรียนรู้:

• ระบุและตีความไวยากรณ์: ถอดรหัสเครื่องหมาย ตัวดำเนินการที่เกี่ยวข้องกับเส้นทาง และข้อจำกัดแบบทั่วไปโดยใช้ตารางอ้างอิงมาตรฐาน
• ใช้การสืบทอดทรีตเพื่อจัดการพฤติกรรมมาตรฐาน เช่น Debug, Clone, Eq, Ord, และ Hash โดยใช้แอตทริบิวต์ derive
• ปรับปรุงกระบวนการทำงาน: ใช้ rustfmt, rustfix, และ Clippy เพื่อจัดรูป แก้ไข และตรวจสอบโค้ดตามมาตรฐานของชุมชน