บทนำ

หมายเหตุ: หนังสือฉบับแปลนี้อิงตามเนื้อหาเดียวกันกับหนังสือ The Rust Programming Language ซึ่งจัดพิมพ์ในรูปแบบสื่อสิ่งพิมพ์และหนังสืออิเล็กทรอนิกส์ (ebook) โดยสำนักพิมพ์ No Starch Press

ยินดีต้อนรับสู่หนังสือ The Rust Programming Language ซึ่งเป็นหนังสือแนะนำเบื้องต้นเกี่ยวกับภาษา Rust ภาษาโปรแกรม Rust จะช่วยให้คุณเขียนซอฟต์แวร์ได้รวดเร็วและมีความน่าเชื่อถือยิ่งขึ้น การออกแบบภาษาโปรแกรมมักมีความขัดแย้งกันระหว่างความสะดวกสบายในการใช้งานระดับสูง (high-level ergonomics) และความสามารถในการควบคุมระดับต่ำ (low-level control) แต่ภาษา Rust ได้ท้าทายข้อจำกัดความขัดแย้งนั้น ด้วยการสร้างความสมดุลระหว่างความสามารถทางเทคนิคที่ทรงพลังและประสบการณ์การพัฒนาที่ยอดเยี่ยม Rust จึงมอบทางเลือกให้คุณควบคุมรายละเอียดในระดับต่ำ (เช่น การใช้งานหน่วยความจำ) ได้โดยไม่สร้างความยุ่งยากเหมือนการควบคุมในรูปแบบเดิมๆ

ภาษา Rust เหมาะสำหรับใคร

ภาษา Rust เหมาะสมสำหรับผู้คนจำนวนมากด้วยเหตุผลที่หลากหลาย เรามาลองดูกลุ่มบุคคลที่สำคัญที่สุดบางส่วนกัน

ทีมงานนักพัฒนาโปรแกรม

ภาษา Rust กำลังพิสูจน์ให้เห็นว่าเป็นเครื่องมือที่มีประสิทธิภาพสำหรับการทำงานร่วมกันในทีมนักพัฒนาขนาดใหญ่ซึ่งมีระดับความรู้ด้านการเขียนโปรแกรมระบบ (systems programming) ที่แตกต่างกัน โค้ดในระดับต่ำมีแนวโน้มที่จะเกิดข้อผิดพลาดที่ซับซ้อนและตรวจหาได้ยาก ซึ่งในภาษาอื่นๆ ส่วนใหญ่มักจะตรวจพบได้ก็ต่อเมื่อผ่านการทดสอบอย่างละเอียดถี่ถ้วนและการตรวจสอบโค้ดอย่างระมัดระวังโดยนักพัฒนาที่มีประสบการณ์สูงเท่านั้น แต่สำหรับใน Rust คอมไพเลอร์จะทำหน้าที่เสมือนเป็นผู้เฝ้าประตูโดยปฏิเสธการคอมไพล์โค้ดที่มีข้อผิดพลาดแฝงเหล่านั้น ซึ่งรวมถึงข้อผิดพลาดในการทำงานพร้อมกัน (concurrency bugs) ด้วยการทำงานประสานร่วมกับคอมไพเลอร์ ทีมงานจึงสามารถใช้เวลาไปกับการมุ่งเน้นที่ตรรกะการทำงานของโปรแกรมแทนการคอยไล่ตามแก้จุดบกพร่อง

นอกจากนี้ Rust ยังได้นำเครื่องมือพัฒนาร่วมสมัยมาสู่โลกของการเขียนโปรแกรมระบบอีกด้วย:

• Cargo ซึ่งเป็นเครื่องมือจัดการไลบรารีที่ต้องใช้ (dependency manager) และเครื่องมือสร้างระบบ (build tool) ที่รวมมาให้ ช่วยให้การเพิ่ม การคอมไพล์ และการจัดการส่วนที่ต้องพึ่งพาทำได้อย่างราบรื่นและสอดคล้องกันทั่วทั้งระบบนิเวศของ Rust
• เครื่องมือจัดรูปแบบโค้ด rustfmt ช่วยรับประกันว่ารูปแบบการเขียนโค้ดของนักพัฒนาทุกคนจะเป็นไปในแนวทางเดียวกัน
• Rust Language Server ช่วยรองรับการเชื่อมต่อกับสภาพแวดล้อมการพัฒนาแบบรวม (IDE) เพื่อช่วยเติมโค้ดอัตโนมัติและการแสดงข้อความแจ้งข้อผิดพลาดในบรรทัดพิมพ์โค้ด

ด้วยการใช้เครื่องมือเหล่านี้และเครื่องมืออื่นๆ ในระบบนิเวศของ Rust นักพัฒนาจึงสามารถทำงานได้อย่างมีประสิทธิภาพในขณะที่เขียนโค้ดในระดับระบบ (systems-level code)

นักเรียนและนักศึกษา

ภาษา Rust เหมาะสำหรับนักเรียน นักศึกษา และผู้ที่สนใจเรียนรู้เกี่ยวกับแนวคิดการเขียนโปรแกรมระบบ ผู้คนจำนวนมากได้เรียนรู้เกี่ยวกับหัวข้อต่างๆ เช่น การพัฒนาโครงสร้างระบบปฏิบัติการผ่านการใช้ Rust ชุมชนผู้ใช้ของเรามีความเป็นกันเองและยินดีตอบคำถามของผู้เรียนเสมอ ด้วยความมุ่งมั่นผ่านหนังสือเล่มนี้ ทีมงาน Rust ต้องการช่วยให้แนวคิดการเขียนโปรแกรมระบบเป็นเรื่องที่เข้าใจได้ง่ายและเข้าถึงได้สำหรับผู้คนจำนวนมากขึ้น โดยเฉพาะผู้ที่เป็นมือใหม่ในการเขียนโปรแกรม

บริษัทและองค์กรธุรกิจ

บริษัทหลายร้อยแห่งทั้งขนาดใหญ่และขนาดเล็กเลือกใช้ Rust ในระบบงานจริงสำหรับงานประเภทต่างๆ รวมถึงเครื่องมือบรรทัดคำสั่ง (command line tools), บริการเว็บ (web services), เครื่องมือ DevOps, อุปกรณ์ฝังตัว (embedded devices), การวิเคราะห์และแปลงรหัสไฟล์เสียงและวิดีโอ (audio and video analysis and transcoding), คริปโทเคอร์เรนซี (cryptocurrencies), ชีวสารสนเทศศาสตร์ (bioinformatics), โปรแกรมค้นหา (search engines), แอปพลิเคชันอินเทอร์เน็ตของสรรพสิ่ง (Internet of Things applications), การเรียนรู้ของเครื่อง (machine learning) และแม้กระทั่งส่วนประกอบหลักของเว็บเบราว์เซอร์ Firefox

นักพัฒนาโอเพนซอร์ส

ภาษา Rust เหมาะสำหรับผู้ที่ต้องการร่วมสร้างภาษาโปรแกรม Rust, ชุมชน, เครื่องมือสำหรับนักพัฒนา และไลบรารีต่างๆ พวกเรายินดีต้อนรับการเข้ามามีส่วนร่วมช่วยเหลือปรับปรุงพัฒนาภาษา Rust จากคุณเสมอ

ผู้ที่ให้ความสำคัญกับความเร็วและเสถียรภาพ

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

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

หนังสือเล่มนี้เหมาะสำหรับใคร

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

วิธีการใช้งานหนังสือเล่มนี้

โดยทั่วไป หนังสือเล่มนี้คาดหวังว่าคุณจะอ่านเนื้อหาเรียงตามลำดับตั้งแต่หน้าแรกไปจนถึงหน้าสุดท้าย บทเรียนหลังๆ จะต่อยอดแนวคิดจากบทแรกๆ และบทแรกๆ อาจไม่ได้ลงรายละเอียดลึกในบางหัวข้อแต่จะกลับมาอธิบายซ้ำอีกครั้งในบทต่อๆ ไป

คุณจะพบบทเรียนสองประเภทในหนังสือเล่มนี้ ได้แก่ บทเชิงแนวคิด (concept chapters) และบทเชิงโครงการ (project chapters) ในบทเชิงแนวคิด คุณจะได้เรียนรู้เกี่ยวกับแง่มุมต่างๆ ของ Rust ส่วนในบทเชิงโครงการ เราจะลงมือสร้างโปรแกรมขนาดเล็กไปด้วยกันเพื่อประยุกต์ใช้สิ่งที่คุณได้เรียนรู้มาทั้งหมด โดยบทที่ 2, บทที่ 12 และบทที่ 21 จะเป็นบทเรียนเชิงโครงการ ส่วนบทที่เหลือจะเป็นบทเรียนเชิงแนวคิด

บทที่ 1 อธิบายวิธีการติดตั้ง Rust, วิธีการเขียนโปรแกรมแรกอย่าง “Hello, world!” และวิธีการใช้งาน Cargo ซึ่งเป็นระบบจัดการแพ็กเกจและเครื่องมือสร้างระบบของ Rust บทที่ 2 เป็นการแนะนำภาคปฏิบัติในการเริ่มเขียนโปรแกรมในภาษา Rust โดยคุณจะได้สร้างเกมทายตัวเลข ในบทนี้เราจะอธิบายแนวคิดในภาพรวมระดับสูงก่อน แล้วบทต่อๆ ไปจะลงลึกรายละเอียดเพิ่มเติม หากคุณต้องการทดลองลงมือเขียนโค้ดในทันที บทที่ 2 คือจุดเริ่มต้นที่เหมาะสมสำหรับคุณ แต่หากคุณเป็นผู้เรียนที่ใส่ใจในรายละเอียดเป็นพิเศษและต้องการเรียนรู้รายละเอียดทั้งหมดก่อนที่จะก้าวไปสู่ขั้นถัดไป คุณอาจข้ามบทที่ 2 และตรงไปยัง บทที่ 3 ซึ่งครอบคลุมคุณลักษณะต่างๆ ของ Rust ที่มีความคล้ายคลึงกับภาษาโปรแกรมอื่นๆ จากนั้นคุณค่อยย้อนกลับมาทำบทที่ 2 เมื่อต้องการลงมือทำโครงการเพื่อประยุกต์ใช้รายละเอียดต่างๆ ที่ได้เรียนรู้มา

ใน บทที่ 4 คุณจะได้เรียนรู้เกี่ยวกับระบบการเป็นเจ้าของข้อมูล (ownership system) ของ Rust บทที่ 5 อธิบายเกี่ยวกับโครงสร้างข้อมูล (structs) และเมธอด (methods) บทที่ 6 ครอบคลุมเรื่องเอ็นัม (enums), นิพจน์ match และโครงสร้างควบคุมทิศทาง if let และ let...else คุณจะได้ใช้โครงสร้างข้อมูลและเอ็นัมเพื่อสร้างชนิดข้อมูลกำหนดเอง (custom types) ของคุณ

ใน บทที่ 7 คุณจะได้เรียนรู้เกี่ยวกับระบบโมดูลของ Rust และกฎความเป็นส่วนตัว (privacy rules) สำหรับจัดระเบียบโค้ดของคุณ รวมถึงอินเตอร์เฟซการเขียนโปรแกรมประยุกต์ (API) สาธารณะของโค้ดนั้น บทที่ 8 อธิบายโครงสร้างข้อมูลคอลเลกชันทั่วไปบางส่วนที่ไลบรารีมาตรฐานเตรียมไว้ให้ เช่น เวกเตอร์ (vectors), ข้อความ (strings) และแฮชแมป (hash maps) บทที่ 9 จะเจาะลึกแนวคิดและเทคนิคการจัดการข้อผิดพลาด (error-handling) ของ Rust

บทที่ 10 เจาะลึกเรื่องเจเนอริก (generics), เทรต (traits) และอายุขัย (lifetimes) ซึ่งช่วยให้คุณสามารถนิยามโค้ดที่สามารถนำไปใช้กับชนิดข้อมูลหลายประเภทได้ บทที่ 11 เป็นเรื่องเกี่ยวกับการทดสอบโปรแกรม (testing) ทั้งหมด ซึ่งแม้ว่า Rust จะมีการรับประกันความปลอดภัยของระบบแล้วก็ตาม แต่การทดสอบก็ยังคงจำเป็นเพื่อให้มั่นใจว่าตรรกะของโปรแกรมคุณถูกต้อง ใน บทที่ 12 เราจะสร้างโปรแกรมจำลองฟังก์ชันการทำงานบางส่วนของเครื่องมือบรรทัดคำสั่ง grep เพื่อค้นหาข้อความภายในไฟล์ด้วยตนเอง สำหรับโครงการนี้ เราจะใช้แนวคิดจำนวนมากที่ได้อธิบายไปในบทก่อนหน้านี้

บทที่ 13 สำรวจเกี่ยวกับโคลเชอร์ (closures) และตัววนซ้ำ (iterators) ซึ่งเป็นคุณลักษณะของ Rust ที่หยิบยกมาจากภาษาโปรแกรมเชิงฟังก์ชัน (functional programming languages) ใน บทที่ 14 เราจะเจาะลึกการใช้ Cargo เพิ่มเติมและพูดคุยเกี่ยวกับวิธีปฏิบัติที่ดีที่สุดในการแบ่งปันไลบรารีของคุณให้กับผู้อื่น บทที่ 15 อธิบายเกี่ยวกับสมาร์ตพอยน์เตอร์ (smart pointers) ที่ไลบรารีมาตรฐานจัดเตรียมไว้ให้ รวมถึงเทรตที่ช่วยเปิดใช้งานความสามารถของสมาร์ตพอยน์เตอร์เหล่านั้น

ใน บทที่ 16 เราจะแนะนำโมเดลรูปแบบต่างๆ ของการเขียนโปรแกรมประมวลผลพร้อมกัน (concurrent programming) และพูดคุยถึงวิธีที่ Rust ช่วยให้คุณเขียนโปรแกรมแบบแยกการทำงานหลายเธรด (multiple threads) ได้อย่างปราศจากความกังวล ใน บทที่ 17 เราจะต่อยอดเรื่องนี้โดยสำรวจไวยากรณ์ async และ await ของ Rust ร่วมกับงาน (tasks), ฟิวเจอร์ส (futures), สตรีมส์ (streams) และรูปแบบการประมวลผลพร้อมกันแบบน้ำหนักเบา (lightweight concurrency model) ที่ทำงานด้วยกลไกเหล่านี้

บทที่ 18 สำรวจวิธีการเปรียบเทียบสำนวนภาษาของ Rust กับหลักการเขียนโปรแกรมเชิงวัตถุ (object-oriented programming) ที่คุณอาจคุ้นเคยอยู่แล้ว บทที่ 19 เป็นคู่มืออ้างอิงเกี่ยวกับรูปแบบและการจับคู่รูปแบบ (patterns and pattern matching) ซึ่งเป็นวิธีที่มีประสิทธิภาพในการอธิบายเป้าหมายการทำงานภายในโปรแกรม Rust บทที่ 20 รวบรวมหัวข้อขั้นสูงต่างๆ ที่น่าสนใจไว้มากมาย รวมถึงการใช้งาน Unsafe Rust, มาโคร (macros) และรายละเอียดเพิ่มเติมเกี่ยวกับอายุขัย, เทรต, ชนิดข้อมูล, ฟังก์ชัน และโคลเชอร์

ใน บทที่ 21 เราจะมาทำโครงการสุดท้ายร่วมกันด้วยการสร้างเว็บเซิร์ฟเวอร์แบบมัลติเธรด (multithreaded web server) ในระดับต่ำ!

สุดท้าย ภาคผนวกต่างๆ จะมีข้อมูลที่เป็นประโยชน์เกี่ยวกับภาษาในรูปแบบคู่มืออ้างอิง ภาคผนวก A ครอบคลุมเรื่องคำสงวนของ Rust, ภาคผนวก B ครอบคลุมตัวดำเนินการและสัญลักษณ์ต่างๆ ของ Rust, ภาคผนวก C ครอบคลุมเทรตที่สามารถจัดทำอนุพันธ์ได้ที่ไลบรารีมาตรฐานเตรียมไว้ให้, ภาคผนวก D ครอบคลุมเครื่องมือพัฒนาที่เป็นประโยชน์ และ ภาคผนวก E อธิบายเกี่ยวกับรุ่น (editions) ต่างๆ ของ Rust ใน ภาคผนวก F คุณสามารถดูข้อมูลโครงการแปลหนังสือเล่มนี้ในภาษาต่างๆ ได้ และใน ภาคผนวก G เราจะพูดถึงวิธีการพัฒนาภาษา Rust และข้อมูลว่า nightly Rust คืออะไร

ไม่มีวิธีการอ่านหนังสือเล่มนี้ที่ผิด: หากคุณต้องการอ่านข้ามไปศึกษาข้างหน้าก่อน ก็สามารถทำได้เลย! คุณอาจเพียงต้องย้อนกลับมาอ่านบทแรกๆ หากพบข้อสงสัยหรือความสับสนในบางจุด แต่คุณสามารถเลือกวิธีใดก็ได้ที่เหมาะสมกับตัวคุณเองมากที่สุด

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

Ferris	Meaning
	โค้ดนี้ไม่สามารถคอมไพล์ได้!
	โค้ดนี้จะเกิดการตื่นตระหนก (panics)!
	โค้ดนี้ไม่มีพฤติกรรมตามที่คาดหวังไว้

ในกรณีส่วนใหญ่ เราจะนำเสนอโค้ดเวอร์ชันที่ถูกต้องของโค้ดต่างๆ ที่คอมไพล์ไม่ผ่านเหล่านั้นให้แก่คุณ

ซอร์สโค้ด (Source Code)

ไฟล์ซอร์สโค้ดที่ใช้สำหรับสร้างหนังสือเล่มนี้สามารถดาวน์โหลดศึกษาเพิ่มเติมได้ที่ GitHub