0Pricing
Learn Rust Coding · บทเรียน

การใช้ Trait ขั้นสูง: ชนิดข้อมูลที่เกี่ยวข้อง

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

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

ชนิดข้อมูลที่เกี่ยวข้องคืออะไร

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

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

เหตุใดจึงใช้ชนิดข้อมูลที่เกี่ยวข้อง

ชนิดข้อมูลที่เกี่ยวข้องช่วยให้เทรตดูเป็นระเบียบและใช้งานง่ายขึ้น โดยเฉพาะเมื่อเทรตกำหนดหลายเมธอดที่ทำงานกับชนิดข้อมูลที่เกี่ยวข้องชนิดเดียวกัน

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

การกำหนดเทรตที่มีชนิดข้อมูลที่เกี่ยวข้อง

มาดูไวยากรณ์พื้นฐานสำหรับการกำหนดเทรตที่มีชนิดข้อมูลที่เกี่ยวข้องกัน เราใช้คีย์เวิร์ด type ภายในคำจำกัดความของเทรต

ในที่นี้ เทรต Container จำเป็นต้องทราบว่าจะเก็บชนิดข้อมูล Item ใด เทรตเองไม่ได้ระบุชนิดข้อมูลนั้น เพียงระบุว่ามีชนิดข้อมูลดังกล่าวอยู่

trait Container {
    type Item; // Associated type declaration
    fn add(&mut self, item: Self::Item);
    fn contains(&self, item: &Self::Item) -> bool;
}

การนำเทรตไปใช้

เมื่อนำเทรตที่มีชนิดข้อมูลที่เกี่ยวข้องไปใช้กับชนิดข้อมูลเฉพาะ เช่น struct คุณต้องระบุอย่างชัดเจนว่าชนิดข้อมูลรูปธรรมของชนิดข้อมูลที่เกี่ยวข้องนั้นคืออะไร

ในตัวอย่างของเรา MyVec นำ Container ไปใช้ และเราประกาศว่าชนิดข้อมูล Item ของมันคือ i32

trait Container {
    type Item;
    fn add(&mut self, item: Self::Item);
    fn contains(&self, item: &Self::Item) -> bool;
}

struct MyVec {
    elements: Vec<i32>,
}

impl Container for MyVec {
    type Item = i32; // Specify the concrete type for Item

    fn add(&mut self, item: Self::Item) {
        self.elements.push(item);
    }

    fn contains(&self, item: &Self::Item) -> bool {
        self.elements.contains(item)
    }
}

fn main() {
    let mut my_vec = MyVec { elements: vec![] };
    my_vec.add(10);
    my_vec.add(20);
    println!("Contains 10: {}", my_vec.contains(&10));
    println!("Contains 30: {}", my_vec.contains(&30));
}

ชนิดข้อมูลที่เกี่ยวข้องกับชนิดข้อมูลทั่วไป

นี่เป็นความแตกต่างที่สำคัญมาก หาก Container เป็นชนิดข้อมูลทั่วไป เช่น trait Container คุณจะสามารถนำ Container for MyVec และ Container for MyVec ไปใช้ได้

แต่เมื่อใช้ชนิดข้อมูลที่เกี่ยวข้อง สำหรับ impl Container for MyVec แต่ละครั้ง ชนิดข้อมูล Item จะเป็น ชนิดข้อมูลเฉพาะเพียงชนิดเดียว เช่น i32 คุณไม่สามารถนำ Container ไปใช้กับ MyVec ซ้ำสองครั้งโดยกำหนดชนิดข้อมูล Item ต่างกันได้

ตัวอย่างในโลกจริง: เทรต `Iterator`

หนึ่งในตัวอย่างชนิดข้อมูลที่เกี่ยวข้องซึ่งพบได้บ่อยและเข้าใจง่ายที่สุดในไลบรารีมาตรฐานของ Rust คือเทรต Iterator

เทรต Iterator มีชนิดข้อมูลที่เกี่ยวข้องชื่อ Item ซึ่งแทนชนิดข้อมูลของค่าที่ตัววนซ้ำจะส่งออกมา ผู้ที่นำ Iterator ไปใช้แต่ละรายจะกำหนดอย่างชัดเจนว่าชนิดข้อมูลของ Item ที่สร้างขึ้นคืออะไร

// Simplified Iterator trait
trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32; // This iterator yields u32 values

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let mut counter = Counter { count: 0 };
    // Using the iterator directly
    while let Some(num) = counter.next() {
        println!("Current count: {}", num);
    }
}

การจำกัดชนิดข้อมูลที่เกี่ยวข้อง

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

ในที่นี้ Item: std::fmt::Debug หมายความว่าชนิดข้อมูลที่เกี่ยวข้องต้องนำเทรต Debug ไปใช้ จึงทำให้เราสามารถพิมพ์ค่าออกมาได้

trait PrintableContainer {
    type Item: std::fmt::Debug; // Item must implement Debug
    fn add(&mut self, item: Self::Item);
    fn print_all(&self);
}

struct DebugVec {
    elements: Vec<String>,
}

impl PrintableContainer for DebugVec {
    type Item = String; // String implements Debug

    fn add(&mut self, item: Self::Item) {
        self.elements.push(item);
    }

    fn print_all(&self) {
        for item in &self.elements {
            println!("Item: {:?}", item); // Uses Debug formatting
        }
    }
}

fn main() {
    let mut debug_vec = DebugVec { elements: vec![] };
    debug_vec.add(String::from("Hello"));
    debug_vec.add(String::from("World"));
    debug_vec.print_all();
}

ชนิดข้อมูลที่เกี่ยวข้องพร้อมค่าเริ่มต้น

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

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

trait Processor {
    type Input = String; // Default input type
    type Output = String; // Default output type

    fn process(&self, input: Self::Input) -> Self::Output;
}

struct SimpleProcessor;

impl Processor for SimpleProcessor {
    // Here, we use the default Input and Output types (String)
    fn process(&self, input: String) -> String {
        format!("Processed: {}", input.to_uppercase())
    }
}

struct CustomIntProcessor;

impl Processor for CustomIntProcessor {
    type Input = i32; // Override default Input
    type Output = i32; // Override default Output

    fn process(&self, input: i32) -> i32 {
        input * 2
    }
}

fn main() {
    let simple = SimpleProcessor;
    println!("Simple processor: {}", simple.process(String::from("hello rust")));

    let custom = CustomIntProcessor;
    println!("Custom int processor: {}", custom.process(10));
}

เมื่อใดควรเลือกใช้ชนิดข้อมูลที่เกี่ยวข้อง

คุณควรเลือกใช้ชนิดข้อมูลที่เกี่ยวข้องแทนพารามิเตอร์ชนิดข้อมูลทั่วไปบนตัวเทรตเองเมื่อใด

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

ตรวจสอบความเข้าใจ

มาทดสอบความเข้าใจของคุณเกี่ยวกับชนิดข้อมูลที่เกี่ยวข้องอย่างรวดเร็ว

ทบทวน: ชนิดข้อมูลที่เกี่ยวข้อง

ทำได้ดีมาก ในบทเรียนนี้ คุณได้สำรวจ ชนิดข้อมูลที่เกี่ยวข้อง ในเทรตของ Rust และได้เรียนรู้ว่า

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

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

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

บทเรียน “การใช้ Trait ขั้นสูง: ชนิดข้อมูลที่เกี่ยวข้อง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การใช้ Trait ขั้นสูง: ชนิดข้อมูลที่เกี่ยวข้อง”

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

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

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

บทเรียน “การใช้ Trait ขั้นสูง: ชนิดข้อมูลที่เกี่ยวข้อง” ใช้เวลานานแค่ไหน

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

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

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

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

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