Learn Rust Coding · บทเรียน

การเขียนโค้ดทั่วไปใน Rust

เรียนรู้การเขียนฟังก์ชันและโครงสร้างข้อมูลที่ทำงานกับหลายชนิดข้อมูล ช่วยให้โค้ดนำกลับมาใช้ซ้ำได้โดยไม่ลดทอนความปลอดภัยของชนิดข้อมูล

การเขียนโค้ดทั่วไปใน Rust เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

เหตุใดจึงควรเขียนโค้ดทั่วไป

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

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

แนะนำเจเนอริก

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

ลองคิดว่าเจเนอริกเป็นแบบร่างที่ปรับใช้กับวัสดุชนิดต่าง ๆ ได้

ฟังก์ชันเจเนอริกแรกของคุณ

หากต้องการทำให้ฟังก์ชันเป็นเจเนอริก ให้ประกาศ พารามิเตอร์ชนิดข้อมูลไว้ในวงเล็บแหลม <> หลังชื่อฟังก์ชัน ชื่อพารามิเตอร์ชนิดข้อมูลที่ใช้กันทั่วไปคือ T (ย่อมาจาก Type)

ฟังก์ชัน print_anything นี้จึงสามารถพิมพ์ค่าชนิดใดก็ได้!

fn print_anything<T>(item: T) {
    println!("The item is: {}", item);
}

pub fn main() {
    print_anything(5);
    print_anything("hello");
    print_anything(true);
}

อธิบายพารามิเตอร์ชนิดข้อมูล

<T> ใน fn print_anything<T>(item: T) หมายความว่า T เป็นตัวแทนชั่วคราวของชนิดข้อมูล เมื่อคุณเรียกใช้ฟังก์ชันด้วย i32 ค่า T ก็จะกลายเป็น i32

พารามิเตอร์ชนิดข้อมูล: ชนิดข้อมูลเจเนอริกมักตั้งชื่อด้วยอักษรตัวพิมพ์ใหญ่ เช่น T, U, V
ความยืดหยุ่น: คอมไพเลอร์จะระบุชนิดข้อมูลจริงในเวลาคอมไพล์

เพิ่มพฤติกรรม: ขอบเขตของทรีต

บางครั้งฟังก์ชันเจเนอริกของคุณต้องการให้พารามิเตอร์ชนิดข้อมูล T มีพฤติกรรมเฉพาะ เช่น หากต้องการเปรียบเทียบค่า T สองค่า T ก็ต้องรองรับการเปรียบเทียบ

เราเพิ่ม ขอบเขตของทรีต เพื่อระบุข้อกำหนดเหล่านี้ ในที่นี้ T: PartialOrd + Copy หมายความว่า T ต้องนำทรีต PartialOrd (การจัดลำดับบางส่วนสำหรับการเปรียบเทียบ) และ Copy ไปใช้

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

pub fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    println!("Largest number: {}", largest(&number_list));

    let char_list = vec!['y', 'm', 'a', 'q'];
    println!("Largest char: {}", largest(&char_list));
}

ไวยากรณ์สำหรับขอบเขตของทรีตหลายรายการ

คุณสามารถกำหนดให้ชนิดข้อมูลเจเนอริกต้องใช้ทรีตหลายรายการได้โดยใช้ไวยากรณ์ + เช่น T: TraitA + TraitB

สำหรับขอบเขตที่ซับซ้อน คุณยังสามารถใช้ส่วนคำสั่ง where หลังลายเซ็นฟังก์ชัน ซึ่งอาจทำให้ลายเซ็นอ่านง่ายขึ้น:

fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }

โครงสร้างข้อมูลเจเนอริก

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

โครงสร้าง Point<T> สามารถเก็บพิกัดของชนิดข้อมูลใดก็ได้ T (เช่น i32, f64)

struct Point<T> {
    x: T,
    y: T,
}

pub fn main() {
    let integer_point = Point {
        x: 5,
        y: 10
    };
    let float_point = Point {
        x: 1.0,
        y: 4.0
    };

    println!("Int Point: ({}, {})", 
             integer_point.x, integer_point.y);
    println!("Float Point: ({}, {})", 
             float_point.x, float_point.y);
}

การนำเมธอดไปใช้กับโครงสร้างข้อมูลเจเนอริก

เมื่อนำเมธอดไปใช้กับโครงสร้างข้อมูลเจเนอริก คุณต้องระบุพารามิเตอร์ชนิดข้อมูลเจเนอริกหลัง impl

คุณยังสามารถเพิ่มขอบเขตของทรีตให้กับเมธอดได้ หากเมธอดนั้นต้องการพฤติกรรมบางอย่างจากชนิดข้อมูลเจเนอริกโดยเฉพาะ

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

pub fn main() {
    let p = Point {
        x: 5,
        y: 10
    };
    println!("p.x = {}", p.x());
}

เจเนอริกกับประสิทธิภาพ

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

Rust ทำเช่นนี้ผ่านการทำให้เป็นรูปแบบเฉพาะ: ในเวลาคอมไพล์ คอมไพเลอร์จะสร้างโค้ดเจเนอริกของคุณในรูปแบบเฉพาะสำหรับชนิดข้อมูลจริงแต่ละชนิดที่นำไปใช้ ดังนั้น largest<i32> และ largest<char> จึงกลายเป็นฟังก์ชันที่แตกต่างกันสองฟังก์ชันซึ่งได้รับการปรับให้เหมาะสม

ทดสอบความรู้ของคุณ

ข้อความใดต่อไปนี้เกี่ยวกับเจเนอริกของ Rust ที่เป็นจริง

สรุป: พลังของเจเนอริก

ในบทเรียนนี้ คุณได้เรียนรู้พื้นฐานของการเขียนโค้ดเจเนอริกใน Rust:

เจเนอริกคืออะไร: วิธีเขียนโค้ดที่ยืดหยุ่นและนำกลับมาใช้ซ้ำได้
ฟังก์ชันเจเนอริก: ใช้ <T> สำหรับพารามิเตอร์ชนิดข้อมูล
ขอบเขตของทรีต: ระบุพฤติกรรมที่จำเป็นด้วย T: Trait
โครงสร้างข้อมูลเจเนอริก: สร้างโครงสร้างข้อมูลที่เก็บชนิดข้อมูลเจเนอริกได้
ไม่มีต้นทุน: เจเนอริกของ Rust จะถูกคอมไพล์เป็นโค้ดเฉพาะ จึงไม่ทำให้ประสิทธิภาพขณะรันไทม์ลดลง

เจเนอริกเป็นรากฐานสำคัญของ Rust ที่เป็นไปตามแนวทางภาษา ช่วยให้สร้างนามธรรมที่ทรงพลังและปลอดภัยด้านชนิดข้อมูลได้!

คำถามที่พบบ่อย

บทเรียน “การเขียนโค้ดทั่วไปใน Rust” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การเขียนโค้ดทั่วไปใน Rust” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การเขียนโค้ดทั่วไปใน Rust”

เรียนรู้การเขียนฟังก์ชันและโครงสร้างข้อมูลที่ทำงานกับหลายชนิดข้อมูล ช่วยให้โค้ดนำกลับมาใช้ซ้ำได้โดยไม่ลดทอนความปลอดภัยของชนิดข้อมูล คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน

บทเรียน “การเขียนโค้ดทั่วไปใน Rust” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การเขียนโค้ดทั่วไปใน Rust
การกำหนดและนำ Traits ไปใช้
การใช้ Trait ขั้นสูง: ชนิดข้อมูลที่เกี่ยวข้อง

← กลับไปที่ Learn Rust Coding