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:
- Rust มีการจัดการหน่วยความจำแบบละเอียด แต่จะได้รับการจัดการโดยอัตโนมัติเมื่อสร้างขึ้น
- ใน Rust เมื่อคุณจัดสรรหน่วยความจำ คุณจะไม่ต้องปล่อยหน่วยความจำจริงๆ คุณสามารถตัดสินใจได้ว่าจะปล่อยหน่วยความจำเมื่อใด แต่ไม่ต้องเรียกใช้ สนิมจะดูแลโดยอัตโนมัติ
- ตัวแปรแต่ละตัวมีขอบเขตที่ถูกต้อง และจะถูกจัดสรรคืนโดยอัตโนมัติเมื่ออยู่นอกขอบเขต
- ในสนิม แต่ละโปรแกรมจะได้รับการจัดสรรหน่วยความจำจากระบบปฏิบัติการ
- 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 ยูเนี่ยน |
| ประเภทฟังก์ชัน | ฟังก์ชั่น, การปิด |
| ประเภทตัวชี้ | การอ้างอิง พอยน์เตอร์ดิบ พอยน์เตอร์ฟังก์ชัน |
| ประเภทลักษณะ | วัตถุลักษณะ, ลักษณะนัยน์ตา |
ข้อดีและข้อเสียของสนิม:
ข้อดี:
- การดีบักและการทดสอบอย่างรวดเร็ว: Rust เป็นภาษาที่เร็วมากและรองรับการดีบักอย่างรวดเร็วและมีประสิทธิภาพ
- Rust รองรับโค้ดที่ซับซ้อนกว่าเมื่อเทียบกับภาษาอื่นๆ ดังนั้นเราจึงประสบความสำเร็จได้มากขึ้นด้วยโค้ดที่น้อยลง
- ช่วยให้สามารถพัฒนาข้ามแพลตฟอร์มได้
- ง่ายต่อการรวม: Rust สามารถรวมเข้ากับ C และภาษาโปรแกรมที่มีชื่อเสียงอื่น ๆ ได้อย่างง่ายดาย
- สนิมปลอดภัยกว่าภาษาโปรแกรมอื่นๆ
- มีชุมชนนักพัฒนามากมายที่สนับสนุน Rust
ข้อเสีย:
- เนื่องจากความซับซ้อน อาจใช้เวลานานขึ้นในการเรียนรู้เรื่องสนิม
- ในสนิม โค้ดอาจมีประสิทธิภาพน้อยลงและใช้เวลาในการคอมไพล์นานขึ้น
- เนื่องจากมีความซับซ้อนมากขึ้น ดังนั้นอาจใช้เวลามากขึ้นในการเขียนแอปที่เขียนด้วย Rust ให้เสร็จ
- เป็นภาษาใหม่ ดังนั้นจะใช้เวลามากขึ้นในการแพร่กระจาย และงานในสนิมก็อาจไม่มากเท่ากับภาษาโปรแกรมยอดนิยมอื่น ๆ
- ในบางกรณี สนิมอาจทำให้หน่วยความจำรั่วและช้ากว่าภาษาโปรแกรมยอดนิยม
- ดูแลรักษายากเนื่องจากฐานรหัสขนาดใหญ่
บันทึกส่วนตัวของฉันarrow_drop_up
ปรับปรุงครั้งล่าสุด :17 พฤษภาคม 2566
ถูกใจบทความ
บันทึกบทความ