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

ภาษาที่มีอิทธิพลมากที่สุดบางภาษา ได้แก่ C หรือที่รู้จักกันในชื่อแม่ของภาษาสมัยใหม่ทั้งหมด อนุพันธ์ที่มีชื่อเสียงที่สุดของภาษา C++, Java, C# และอื่นๆ อีกมากมาย การเปิดตัว C ในปี 1972 ได้ปฏิวัติวิธีที่เราสามารถเขียนโปรแกรมคอมพิวเตอร์ได้ C++ ได้เพิ่มประสบการณ์นี้ด้วยการแนะนำ Object Oriented Paradigms ใน C แต่ทุกอย่างก็มาถึงจุดสิ้นสุดใช่ไหม

ฉันไม่ได้บอกเป็นนัยว่าฐานผู้ใช้สำหรับ C++ กำลังลดลง แต่การขาดการอัปเดตในภาษาและบางครั้ง “ลักษณะเฉพาะ” ของภาษาได้บังคับให้หลายบริษัทเปลี่ยนฐานโค้ดจาก C++ ไปเป็นภาษาสมัยใหม่อื่นๆ ตัวอย่างเช่น Go และ Carbon-Lang ได้รับการพัฒนาโดย Google โดยมีวัตถุประสงค์เพื่อแทนที่ฐานโค้ด C++ ที่มีอยู่

หนึ่งในตัวเลือกที่มีแนวโน้มมากที่สุดในภาษาเหล่านี้ ได้แก่ "Rust" Rust เริ่มต้นจากโครงการส่วนตัวโดยพนักงานชื่อ Graydon Hoare ที่ Mozilla ซึ่งต่อมาได้รับการสนับสนุนจากบริษัทในปี 2009 และ ณ ตอนนี้ Linus Torvalds บิดาแห่ง Linux ได้ประกาศในการประชุมสุดยอด Open Source Summit ปี 2022 ซึ่งจัดขึ้นที่เมืองออสติน รัฐเท็กซัส ว่าเขา "มองโลกในแง่ดีอย่างระมัดระวัง" เกี่ยวกับการนำสนิมมาสู่รุ่นหลักถัดไปของ "Linux Kernel" (อาจเป็น 5.20)

ทำไมต้องเป็นสนิม?

มีภาษาการเขียนโปรแกรมมากมายที่สามารถพิจารณาได้สำหรับงานเดียวกับที่สนิมทำ แต่มีคุณลักษณะบางอย่างที่ทำให้แตกต่าง:

1. ประสิทธิภาพ

Rust เป็นหนึ่งในภาษาที่เร็วที่สุดจนถึงปัจจุบัน โดยมี Go-lang เป็นคู่แข่งเพียงรายเดียว Rust ทำงานรวดเร็วและมีประสิทธิภาพหน่วยความจำ ไม่รวมตัวรวบรวมขยะซึ่งช่วยลดต้นทุนการประมวลผลค่าใช้จ่ายในการดำเนินการเหล่านี้

<แข็งแกร่ง>2. ความน่าเชื่อถือ

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

3. อเนกประสงค์และข้ามแพลตฟอร์ม

Rust สามารถใช้เขียนแอปพลิเคชันประเภทต่างๆ ที่สามารถทำงานบนอุปกรณ์หลายประเภท บางฟิลด์รวมถึงการเขียนโปรแกรมระดับล่าง (“เช่นการเขียนไดรเวอร์ ฯลฯ .. ”), WebAssembly, การพัฒนาแบ็กเอนด์ ฯลฯ เนื่องจาก Rust ขับเคลื่อนโดยโครงสร้างพื้นฐานคอมไพเลอร์ LLVM จึงสามารถทำงานบนอุปกรณ์ฝังตัวได้อย่างง่ายดายเช่นกัน

การเดินทางของฉัน

ฉันเริ่มต้นด้วย Rust เมื่อเดือนที่แล้วและรู้อย่างรวดเร็วว่า Rust เป็นภาษาที่ทรงพลังจริงๆ

แม้ว่าแนวคิดบางอย่างจะค่อนข้างแปลก ตัวอย่างเช่น คุณลักษณะบางอย่างที่เรามองข้ามในภาษาระดับสูงอื่นๆ เช่น python และ javascript หายไป

กรรมสิทธิ์และการยืม

ก่อนอื่นเรามาพูดถึงแนวคิดเรื่องการเป็นเจ้าของและการกู้ยืมกันก่อน ลองใช้โค้ด Rust ชิ้นนี้เป็นตัวอย่าง:

อย่างที่คุณเห็นด้านบน ถ้าเราพยายามเข้าถึงตัวแปร x หลังจากส่งมันไปยังฟังก์ชันการพิมพ์ โปรแกรมจะ “ตื่นตระหนก” ซึ่งเหมือนกับข้อยกเว้นใน Python และ Java สิ่งนี้เกิดขึ้นเพราะในสนิมประเภทข้อมูล "ซับซ้อน" ทั้งหมดเช่นสตริงจะถูกจัดเก็บในลักษณะที่แตกต่างกันมากเมื่อเทียบกับภาษาอื่น

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

สิ่งนี้ทำให้เกิดปัญหามากมายในขณะรันไทม์ ดังนั้นเพื่อแก้ไขปัญหานี้จึงมีการตั้งค่าระบบความเป็นเจ้าของซึ่งส่งต่อความเป็นเจ้าของค่าทั้งหมดเข้าด้วยกัน ตัวอย่างเช่น:

เพื่อหลีกเลี่ยงปัญหาเช่นนี้ เรา "ยืม" ค่าโดยการกำหนดหรือส่งการอ้างอิงไปยังตัวแปรนั้นแทนการโอนความเป็นเจ้าของ ตัวอย่างเช่น:

ตัวอย่างนี้แสดงให้เห็นอย่างชัดเจนว่าเราสามารถส่งการอ้างอิงไปยังตัวแปรได้อย่างไรโดยใช้ตัวดำเนินการเครื่องหมายแอมเปอร์แซนด์(&) (เหมือนกับ C ใช่ไหม แต่ก็ไม่มากขนาดนั้น)

คุณยังสามารถส่งการอ้างอิงที่ไม่แน่นอนได้ ซึ่งหมายความว่าคุณสามารถเปลี่ยนค่าของการอ้างอิงที่ส่งผ่านได้ แต่คุณต้องจำไว้ว่าคุณสามารถส่งการอ้างอิงที่ไม่เปลี่ยนรูปได้เพียงรายการเดียวหรือหลายรายการเท่านั้น

ชั้นเรียนของฉันอยู่ที่ไหน🤯?

ใช่ นั่นคือปฏิกิริยาของฉันเมื่อรู้ว่าไม่มีคลาสใน Rust แม้ว่า Rust จะสนับสนุน abstraction ในระดับสูง แต่นั่นไม่ได้หมายความว่ามันมีแนวคิดของคลาสในตัว(เมื่อก่อน แต่ตอนนี้ไม่มีแล้ว) แต่จริงๆ แล้วหลังจากดำดิ่งลึกลงไปอีกเล็กน้อย ฉันก็ตระหนักว่าเรา ไม่จำเป็นต้องใช้มันที่นี่ เพราะว่าเรามี structs และ traits อยู่แล้วในการแก้ปัญหาทั้งหมดของเรา

โครงสร้าง

โครงสร้างที่เป็นสนิมมีสามประเภท:

  1. โครงสร้างที่มีชื่อ (โครงสร้างประเภท C มาตรฐาน)
  2. โครงสร้างทูเพิล (struct จุด (i32, i32, i32);)
  3. โครงสร้างหน่วย (struct Test;)

สำหรับเช่น:

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

ด้วยเหตุนี้เราจึงมีคุณลักษณะ

ลักษณะ

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

เราสามารถกำหนดลักษณะได้อย่างง่ายดายโดยใช้คำหลัก trait

ดังที่คุณเห็นว่าเราใช้คีย์เวิร์ด impl(ซึ่งย่อมาจาก Apply) เพื่อเชื่อมโยงคุณลักษณะกับประเภทข้อมูลที่ผู้ใช้กำหนด

หมายเหตุ:คำหลัก สำหรับ ที่ใช้ในที่นี้มีฟังก์ชันการทำงานที่แตกต่างจากคำหลักที่เราใช้ในการวนซ้ำ แม้ว่าคำหลักจะยังคงเหมือนเดิมก็ตาม

บทสรุป

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

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

ชำระเงินอย่างเป็นทางการ Rust-Lang Book คุณยังสามารถตรวจสอบพื้นที่เก็บข้อมูล Github ของฉันซึ่งมีชุดโปรแกรม Rust พื้นฐาน ซึ่งบางโปรแกรมใช้เป็นตัวอย่างในบล็อกโพสต์นี้

บทความเพิ่มเติมเกี่ยวกับ Rust และเทคโนโลยีสนุกๆ อื่นๆ จะตามมาเร็วๆ นี้ โปรดคอยติดตาม!