รู้เบื้องต้นเกี่ยวกับภาษาการเขียนโปรแกรมสนิม - 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!” ในคอนโซล:

สนิม

หลัก() {

พิมพ์!("สวัสดีชาวโลก!");

}

เอาท์พุต:

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

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

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

สนิม

ผู้ช่วยเหลือ () -> กล่อง <นานาชาติ> {

อนุญาต สาม = กล่อง 3;

กลับ สาม;//โอนกรรมสิทธิ์

}

หลัก() {

// รับความเป็นเจ้าของของค่าส่งคืน

อนุญาต my_three = ผู้ช่วยเหลือ ();

}

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

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

สนิม

อนุญาต ตอบ: ∫

{

อนุญาต ข = 3;//b อายุการใช้งานไม่เหมือนกับ a

ก =&b;

}//

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

สนิม

อนุญาต ตอบ: ∫

อนุญาต ข=3;// a และ b มีอายุเท่ากัน

ก = &b;

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

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

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

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

กอง:

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

ซ้อนกัน:

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

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

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

ตัวอย่าง:

สนิม

อนุญาต x = 2;

x = 9;// มันจะแสดงข้อผิดพลาด

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

สนิม

อนุญาต ปิดเสียง x = 2;

x = 9;//ทำงานอย่างถูกต้อง

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

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

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

ไวยากรณ์:

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

ตัวอย่าง:

สนิม

โครงสร้าง พนักงาน {

ชื่อ: สตริง,

บริษัท: สตริง,

รหัสพนักงาน: u32,

โปรไฟล์: สตริง

}

หลัก() {

อนุญาต ค่า = พนักงาน {

ชื่อ: สตริง::จาก("เกินบรรยาย"),

บริษัท: สตริง::จาก("Geeksforgeeks.org"),

รหัสพนักงาน: 007,

โปรไฟล์:สตริง::จาก("ผู้จัดการ"),

};

พิมพ์!("พนักงาน: {} จาก {} บริษัทที่มีรหัสพนักงาน {} อยู่ในระดับ {}",

ค่า.ชื่อ,

ค่า.บริษัท,

ค่า.employee_id,

ค่า.โปรไฟล์);

}

เอาท์พุต:

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

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

ทูเพิล:

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

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

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

ตัวอย่าง:

สนิม

// โปรแกรม Rust รับค่าจากทูเพิล

// ใช้ดัชนี

หลัก() {

อนุญาต gfg = ("ซีพี","บางสิ่งบางอย่าง","จับ","โครงสร้างข้อมูล");

// ทูเพิลสมบูรณ์

พิมพ์!("ทูเพิลที่สมบูรณ์ = {:?}", gfg );

// ค่าแรก

พิมพ์!("ที่ 0 ดัชนี = {} ", gfg.0 );

// ค่าที่สอง

พิมพ์!("ที่ 0 ดัชนี = {} ", gfg.1 );

// ค่าที่สาม

พิมพ์!("ที่ 0 ดัชนี = {} ", gfg.2 );

// ค่าที่สี่

พิมพ์!("ที่ 0 ดัชนี = {} ", gfg.3 );

}

เอาท์พุต:

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

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

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

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

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

ข้อดี:

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

ข้อเสีย:

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

บันทึกส่วนตัวของฉันarrow_drop_up

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

ถูกใจบทความ

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

References

Top Articles
Latest Posts
Article information

Author: Dr. Pierre Goyette

Last Updated: 02/11/2023

Views: 5245

Rating: 5 / 5 (50 voted)

Reviews: 89% of readers found this page helpful

Author information

Name: Dr. Pierre Goyette

Birthday: 1998-01-29

Address: Apt. 611 3357 Yong Plain, West Audra, IL 70053

Phone: +5819954278378

Job: Construction Director

Hobby: Embroidery, Creative writing, Shopping, Driving, Stand-up comedy, Coffee roasting, Scrapbooking

Introduction: My name is Dr. Pierre Goyette, I am a enchanting, powerful, jolly, rich, graceful, colorful, zany person who loves writing and wants to share my knowledge and understanding with you.