ทุกสิ่งที่คุณต้องรู้เพื่อเริ่มเขียนสนิม (2023)

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

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

เริ่มต้นด้วยสนิม

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

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

ตัวแปรและค่าคงที่ในสนิม

สนิมมีการแสดงออกสูงและมีหลายวิธีในการประกาศตัวแปร คุณสามารถใช้อนุญาตคำหลักในการประกาศตัวแปร

นี่คือวิธีที่คุณสามารถประกาศตัวแปรใน Rust:

 อนุญาตก:สตริง;
อนุญาตข:i32;
อนุญาตค: () = ();
 

เดอะกและขตัวแปรคือสตริงและจำนวนเต็มตามลำดับ เดอะคตัวแปรเป็นประเภทหน่วยสนิมที่ทำหน้าที่เป็นตัวยึดสำหรับฟังก์ชันและนิพจน์

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

 ฉ หลัก(){
    อนุญาตอายุ:สตริง=สตริง::จาก("ห้าขวบ");
    อนุญาตอายุ =5;// เทียบเท่ากับอายุ: i32 = 5;
    ปริ๊นท์!("{}", อายุ);
}
See Also
[แปล] เข้าใจความเป็นเจ้าของในสนิมรู้เบื้องต้นเกี่ยวกับภาษาการเขียนโปรแกรมสนิม - GeeksforGeeks
 

โปรแกรมประกาศสองอายุตัวแปรก่อนพิมพ์ด้วยตัวปริ๊นท์!มาโคร ครั้งแรกอายุตัวแปรระบุประเภทข้อมูล และตัวแปรที่สองไม่ระบุ

คุณไม่จำเป็นต้องระบุประเภทข้อมูลของตัวแปรเมื่อคุณประกาศ คอมไพเลอร์ Rust อนุมานประเภทจากประเภทข้อมูลของค่า ณ เวลาคอมไพล์

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

 คอสต์อายุ: &สตริง="ห้าขวบ";
 

คุณไม่สามารถแก้ไขค่าของตัวแปรที่คุณประกาศเป็นค่าคงที่ได้

Rust มีฟังก์ชันการทำงานสำหรับความคิดเห็นแบบบรรทัดเดียวและแบบบล็อก คุณสามารถใช้เครื่องหมายทับสองครั้ง (//) สำหรับความคิดเห็นบรรทัดเดียว:

 ฉ หลัก() {
    // นี่คือความคิดเห็นในบรรทัด
    อนุญาตx =5;// ความคิดเห็นนี้อธิบายจุดประสงค์ของตัวแปร `x`
}
 

สำหรับความคิดเห็นหลายบรรทัด (บล็อกความคิดเห็น) ให้ใช้เครื่องหมายทับตามด้วยเครื่องหมายดอกจัน (/*) และปิดบล็อกด้วยเครื่องหมายดอกจันตามด้วยเครื่องหมายทับ (*/):

 ฉ หลัก() {
    /*
นี่คือบล็อกความคิดเห็นที่ครอบคลุมหลายบรรทัด
มักใช้เพื่ออธิบายกลุ่มรหัสที่ใหญ่ขึ้น
*/
    อนุญาตx =5;
}
 

ความคิดเห็นของคุณควรกระชับและตรงไปตรงมา

อาร์เรย์ในสนิม

อาร์เรย์เป็นคอลเล็กชันขนาดคงที่ขององค์ประกอบประเภทข้อมูลเดียวกัน Rust จัดสรรอาร์เรย์บนสแต็กตามค่าเริ่มต้น

นี่คือวิธีที่คุณสามารถประกาศอาร์เรย์ใน Rust:

 ฉ หลัก() {
    อนุญาตตัวเลข = [1,2,3,4,5];
}
 

เดอะตัวเลขอาร์เรย์มีห้ารายการ คุณสามารถเข้าถึงค่าที่ตำแหน่งในอาร์เรย์โดยใช้ดัชนี:

 ฉ หลัก() {
    อนุญาตตัวเลข = [1,2,3,4,5];
    อนุญาตx = ตัวเลข[3];
    ปริ๊นท์!("{}", x)
}
 

เดอะหลักฟังก์ชั่นพิมพ์xตัวแปรที่เข้าถึงองค์ประกอบที่สี่ของอาร์เรย์

เวกเตอร์ในสนิม

สนิมให้เวกเตอร์เพื่อปกปิดข้อ จำกัด ของอาร์เรย์ เวกเตอร์มีขนาดแบบไดนามิก พวกมันสามารถเติบโตและหดตัวได้ตามต้องการ

นี่คือวิธีที่คุณสามารถประกาศเวกเตอร์ใน Rust:

 ฉ หลัก() {
    อนุญาตmy_thing:เวค<i32> =ผัก![1,2,3,4,5];
    อนุญาตx = my_vec[3];
    ปริ๊นท์!("{}", x)
}
 

เดอะของฉัน_สิ่งเวกเตอร์เป็นเวกเตอร์ของจำนวนเต็ม 32 บิต เดอะxตัวแปรเข้าถึงองค์ประกอบที่สี่ของเวกเตอร์และหลักฟังก์ชันพิมพ์ค่าไปยังคอนโซล

ข้อความตามเงื่อนไขของ Rust

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

นี่คือถ้าคำสั่งที่พิมพ์สตริงไปยังคอนโซลตามความเท่าเทียมกันของจำนวนเต็มสองตัว

 ฉ หลัก() {
    อนุญาตก:i32=12;
    ถ้า==12{
        ปริ๊นท์!("a เท่ากับ 12");
}
}
(Video) ບໍ່ສະໜິດຢ່າຄິດແທນ (ไม่สนิทอย่าคิดแทน) - STS73【Official Music Video】Prod: pipoderni
 

เดอะหลักฟังก์ชันพิมพ์สตริงที่มีปริ๊นท์!มาโครเนื่องจากตัวแปรเท่ากับ 12

คุณสามารถใช้อื่นคำหลักในการจัดการกรณีที่ถ้าคำสั่งประเมินเท็จ:

 ฉ หลัก() {
    อนุญาตก:i32=12;
    ถ้า==123{
        ปริ๊นท์!("a เท่ากับ 12");
}อื่น{
        ปริ๊นท์!("a ไม่เท่ากับสิบสอง");
}
} 

ในตัวอย่างนี้อื่นคำสั่งทำงานเนื่องจากค่าของ a ไม่เท่ากับ 123

คุณสามารถประกาศคำสั่งจับคู่กับจับคู่คำหลักสำหรับเงื่อนไขที่ซับซ้อน:

 ฉ หลัก() {
    อนุญาตอายุ:i32=7;
    จับคู่อายุ {
        1=>ปริ๊นท์!("หนึ่ง"),
        2=>ปริ๊นท์!("สอง"),
        3=>ปริ๊นท์!("สาม"),
_ =>ปริ๊นท์!("ศูนย์"),
}
} 

เดอะหลักฟังก์ชั่นตรงกับอายุแปรผันตามกรณีในจับคู่คำสั่งและดำเนินการนิพจน์ที่ตรงกับค่า เครื่องหมายขีดล่าง (_) คือคำสั่งเริ่มต้นที่ทำงานหากมีค่าตรงกัน

ลูปในสนิม

สนิมให้ลูปสำหรับงานซ้ำ ๆ สนิมมีลูปหลักสามประเภท:ห่วง,ในขณะที่, และสำหรับลูป

เดอะห่วงคำหลักสร้างการวนซ้ำไม่สิ้นสุดที่ทำงานจนกว่าจะพบคำหลักตัวแบ่ง:

 ฉ หลัก() {
    ห่วง{
        ปริ๊นท์!("พิมพ์ซ้ำๆ จนกว่าจะเจอคำสั่ง break");
        หยุดพัก;
}
}
 

เดอะในขณะที่การวนซ้ำมีประโยชน์เมื่อคุณต้องการทำซ้ำบล็อกของโค้ดตราบเท่าที่เงื่อนไขประเมินเป็นจริง:

 ฉ หลัก() {
    อนุญาต ปิดเสียงนับ =0;
    ในขณะที่นับ <5{
        ปริ๊นท์!("จำนวนคือ {}", นับ);
นับ +=1;
}
} 

กสำหรับการวนซ้ำนั้นดีสำหรับการวนซ้ำของรายการเช่นอาร์เรย์:

 ฉ หลัก() {
    อนุญาตตัวเลข = [1,2,3,4,5];
    สำหรับรายการในตัวเลข.iter() {
        ปริ๊นท์!("รายการปัจจุบันคือ {}", รายการ);
}
}
(Video) มดส้มล้มช้าง ร่วมสร้างอนาคต โดย ดร. เพียงดิน รักไทย 29 พฤษภาคม 2566
 

นี้สำหรับวนซ้ำผ่านตัวเลขอาร์เรย์และพิมพ์แต่ละรายการไปยังคอนโซล

การประกาศและการเรียกใช้ฟังก์ชัน Rust

ใช้ฉคำหลักถึงประกาศฟังก์ชั่น Rustตามด้วยชื่อฟังก์ชัน รายการพารามิเตอร์ และประเภทการส่งคืน (ถ้ามี)

ต่อไปนี้คือวิธีที่คุณสามารถประกาศฟังก์ชันด้วยพารามิเตอร์และประเภทการส่งคืน:

 ฉ เพิ่ม(ก:i32, ข:i32) ->i32{
    กลับก + ข;
}
 

เดอะเพิ่มฟังก์ชันรับจำนวนเต็ม 32 บิตสองตัวและส่งกลับจำนวนเต็ม 32 บิต ซึ่งเป็นผลรวมของพารามิเตอร์สองตัว

หากต้องการเรียกใช้ฟังก์ชันจากที่อื่นในโค้ดของคุณ เพียงระบุชื่อและอาร์กิวเมนต์ (ถ้ามี):

 ฉ หลัก() {
    อนุญาตผลลัพธ์ = เพิ่ม (2,3);
    ปริ๊นท์!("2 + 3 = {}", ผลลัพธ์);
}
 

เดอะผลลัพธ์ตัวแปรเก็บผลลัพธ์จากการเรียกใช้เพิ่มการทำงาน. เดอะหลักฟังก์ชันพิมพ์ผลลัพธ์ไปยังคอนโซลโดยใช้ปริ๊นท์!มาโคร

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

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

นี่คือวิธีที่คุณสามารถประกาศโครงสร้าง:

 โครงสร้าง บุคคล{
ชื่อ:สตริง,
อายุ:ยู32,
is_male:บูล,
}
 

เดอะบุคคลstruct มีสามฟิลด์: สตริง, จำนวนเต็ม 32 บิตที่ไม่ได้ลงนามและบูลีน

หลังจากกำหนดโครงสร้างแล้ว คุณสามารถสร้างอินสแตนซ์ของมันในส่วนอื่นๆ ของโปรแกรมของคุณ:

 ฉ หลัก() {
    อนุญาตคนที่ 1 = คน {
ชื่อ:สตริง::จาก("แคนเดซ ฟลินน์"),
อายุ:16,
is_male:เท็จ,
};
}
 

เดอะคนที่ 1ตัวแปรเป็นตัวอย่างของบุคคลโครงสร้าง ในการสร้างอินสแตนซ์ คุณสามารถกำหนดค่าให้กับฟิลด์ struct ได้ คุณสามารถสร้างอินสแตนซ์ของโครงสร้างได้มากเท่าที่คุณต้องการ

คุณสามารถใช้แนวคิด OOP ใน Rust

Rust มีความยืดหยุ่น และคุณสามารถใช้แนวคิด OOP ใน Rust ด้วยโครงสร้างข้อมูลในตัว เช่น structs

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