รู้เบื้องต้นเกี่ยวกับภาษาการเขียนโปรแกรมสนิม - GeeksforGeeks (2023)

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

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

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

สนิม กำลังใช้ สนิมซึ่งหมายความว่าไลบรารีคอมไพเลอร์มาตรฐานทั้งหมดเขียนด้วยสนิม มีการใช้โปรแกรมภาษาซีบ้างเล็กน้อย แต่ส่วนใหญ่เป็นภาษาสนิม โครงการใหญ่ของสนิมคือ“เซอร์โว”เป็นโครงการที่จะเขียนเอนจิ้นเลย์เอาต์แบบขนานทั้งหมดเช่น Gecko ใน Firefox หรือ WebKit ใน Safari

Servo สร้างเอ็นจิ้นเลย์เอาต์ซึ่งเป็นสิ่งที่แสดง HTML จากล่างขึ้นบน

มาเป็นผู้เชี่ยวชาญด้านสนิม
เรียนรู้พื้นฐานของการเขียนโปรแกรม Rust ฝึกฝนแอปพลิเคชันในการพัฒนาเว็บและเกม และเตรียมพร้อมสำหรับการสัมภาษณ์การเขียนโปรแกรมด้วยเส้นทางทักษะแบบโต้ตอบของ Educativeมาเป็นผู้เชี่ยวชาญด้านสนิมลงทะเบียนที่ Educative.io ด้วยรหัสGEEKS10เพื่อรับส่วนลด 10% ในการสมัครสมาชิกของคุณ

ฟังก์ชั่นในสนิม:

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

ไวยากรณ์:

fn ชื่อฟังก์ชัน (อาร์กิวเมนต์){ รหัส}

• ในการสร้างฟังก์ชั่นเราต้องใช้คีย์เวิร์ด fn
• ชื่อฟังก์ชันเขียนตามหลังคีย์เวิร์ด fn
• อาร์กิวเมนต์จะถูกส่งต่อจากชื่อฟังก์ชันภายในวงเล็บ
• คุณสามารถเขียนโค้ดฟังก์ชันในบล็อกฟังก์ชันได้

ตัวอย่าง:ฟังก์ชันด้านล่างเพียงพิมพ์ “Hello, World!” ในคอนโซล:

เอาท์พุต:

สวัสดีชาวโลก!

แนวคิดของการเป็นเจ้าของ:

แนวคิดของการเป็นเจ้าของคือเมื่อคุณเป็นเจ้าของบางสิ่ง คุณสามารถตัดสินใจส่งต่อให้คนอื่นได้ หากคุณมีหนังสือและคุณอ่านจบแล้ว คุณสามารถมอบให้ผู้อื่นได้อย่างถาวรโดยไม่ต้องกังวลกับมัน

แนวคิดของการกู้ยืม:

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

ที่นี่ "a" และ "b" มีอายุการใช้งานต่างกัน ดังนั้นจึงใช้ไม่ได้

ที่นี่ "a" และ "b" มีชีวิตเหมือนกัน ดังนั้นมันจะใช้ได้ ยืมซ้อนกันได้ ผ่านการโคลนค่าที่ยืมมาสามารถเป็นเจ้าของได้

การจัดการหน่วยความจำใน Rust:

1. Rust มีการจัดการหน่วยความจำแบบละเอียด แต่จะได้รับการจัดการโดยอัตโนมัติเมื่อสร้างขึ้น
2. ใน Rust เมื่อคุณจัดสรรหน่วยความจำ คุณจะไม่ต้องปล่อยหน่วยความจำจริงๆ คุณสามารถตัดสินใจได้ว่าจะปล่อยหน่วยความจำเมื่อใด แต่ไม่ต้องเรียกใช้ สนิมจะดูแลโดยอัตโนมัติ
3. ตัวแปรแต่ละตัวมีขอบเขตที่ถูกต้อง และจะถูกจัดสรรคืนโดยอัตโนมัติเมื่ออยู่นอกขอบเขต
4. ในสนิม แต่ละโปรแกรมจะได้รับการจัดสรรหน่วยความจำจากระบบปฏิบัติการ
5. Rust ยังมีหน่วยความจำที่ใช้ร่วมกันซึ่งเราสามารถมีข้อมูลอ้างอิง เราสามารถใช้ความเป็นเจ้าของเพื่อติดตามจำนวนการอ้างอิง

หน่วยความจำที่แตกต่างกัน:

กอง:

• เป็นบล็อกหน่วยความจำที่ใหญ่ที่สุดและจัดการโดยโมเดลความเป็นเจ้าของสนิม
• ณ ที่แห่งนี้ ข้อมูลไดนามิกทั้งหมดจะถูกเก็บไว้

ซ้อนกัน:

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

ความไม่แน่นอน:

ค่าในสนิมจะไม่เปลี่ยนรูปตามค่าเริ่มต้นและต้องติดแท็กว่าไม่แน่นอน (ถ้าจำเป็น)

ตัวอย่าง:

ตัวอย่างข้างต้นจะแสดงข้อผิดพลาดเนื่องจากเราไม่ได้ติดแท็กว่าไม่แน่นอน

สิ่งนี้จะทำงานได้ดีเนื่องจากเราได้ติดแท็กว่าไม่แน่นอน ในกรณีนี้เรากำลังทำให้กลายพันธุ์อย่างชัดเจน

โครงสร้างในสนิม

โครงสร้างเป็นประเภทข้อมูลที่กำหนดโดยผู้ใช้ในสนิมซึ่งใช้ในการรวมรายการข้อมูลที่แตกต่างกันในประเภทต่างๆ โครงสร้างกำหนดข้อมูลเป็นคู่คีย์-ค่า เดอะโครงสร้างคำหลักใช้เพื่อกำหนดโครงสร้างในสนิม

ไวยากรณ์:

โครงสร้าง Name_of_structure { field1:data_type, field2:data_type, field3:data_type}

ตัวอย่าง:

เอาท์พุต:

พนักงาน: Geek ของ Geeksforgeeks.org บริษัทที่มีรหัสพนักงาน 7 เป็นระดับผู้จัดการ

นี่คือตัวอย่างวิธีที่เราสร้างโครงสร้างด้วยสนิม สิ่งนี้จะรวบรวมได้อย่างสมบูรณ์แบบ

ทูเพิล:

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

สิ่งอันดับในสนิมถูกกำหนดโดยใช้วงเล็บเล็ก ๆ ดังที่แสดงด้านล่าง :

ไวยากรณ์:("เกินบรรยาย", 1, 'เกินบรรยาย')

ตัวอย่าง:

เอาท์พุต:

ทูเพิลที่สมบูรณ์ = ("cp", "algo", "FAANG", "โครงสร้างข้อมูล") ที่ 0 ดัชนี = cp ที่ 0 ดัชนี = algo ที่ 0 ดัชนี = FAANG ที่ 0 ดัชนี = โครงสร้างข้อมูล

ระบบประเภทสนิม:

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

ข้อดีและข้อเสียของสนิม:

ข้อดี:

1. การดีบักและการทดสอบอย่างรวดเร็ว: Rust เป็นภาษาที่เร็วมากและรองรับการดีบักอย่างรวดเร็วและมีประสิทธิภาพ
2. Rust รองรับโค้ดที่ซับซ้อนกว่าเมื่อเทียบกับภาษาอื่นๆ ดังนั้นเราจึงประสบความสำเร็จได้มากขึ้นด้วยโค้ดที่น้อยลง
3. ช่วยให้สามารถพัฒนาข้ามแพลตฟอร์มได้
4. ง่ายต่อการรวม: Rust สามารถรวมเข้ากับ C และภาษาโปรแกรมที่มีชื่อเสียงอื่น ๆ ได้อย่างง่ายดาย
5. สนิมปลอดภัยกว่าภาษาโปรแกรมอื่นๆ
6. มีชุมชนนักพัฒนามากมายที่สนับสนุน Rust

ข้อเสีย:

1. เนื่องจากความซับซ้อน อาจใช้เวลานานขึ้นในการเรียนรู้เรื่องสนิม
2. ในสนิม โค้ดอาจมีประสิทธิภาพน้อยลงและใช้เวลาในการคอมไพล์นานขึ้น
3. เนื่องจากมีความซับซ้อนมากขึ้น ดังนั้นอาจใช้เวลามากขึ้นในการเขียนแอปที่เขียนด้วย Rust ให้เสร็จ
4. เป็นภาษาใหม่ ดังนั้นจะใช้เวลามากขึ้นในการแพร่กระจาย และงานในสนิมก็อาจไม่มากเท่ากับภาษาโปรแกรมยอดนิยมอื่น ๆ
5. ในบางกรณี สนิมอาจทำให้หน่วยความจำรั่วและช้ากว่าภาษาโปรแกรมยอดนิยม
6. ดูแลรักษายากเนื่องจากฐานรหัสขนาดใหญ่

ปรับปรุงครั้งล่าสุด :17 พฤษภาคม 2566

ถูกใจบทความ

บันทึกบทความ