Learn Rust Coding · บทเรียน

struct และ enum แบบ泛用

สร้างชนิดข้อมูลที่ยืดหยุ่น

บทเรียน 2 จาก 413 ขั้นตอน

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

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

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

ไลบรารีมาตรฐานสร้างขึ้นในลักษณะนี้: Vec<T> Option<T> และ Result<T, E> ล้วนเป็นเจเนอริก

สตรักต์เจเนอริก

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

คำจำกัดความเดียวนี้จึงใช้ได้กับจุดที่เป็นจำนวนเต็ม จุดที่เป็นจำนวนทศนิยม และชนิดอื่น ๆ

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

การสร้างสตรักต์เจเนอริก

เมื่อสร้างอินสแตนซ์ คอมไพเลอร์จะอนุมาน T จากค่าของฟิลด์ ฟิลด์ทั้งสองต้องมีชนิดข้อมูลเดียวกัน

โปรแกรมนี้สร้างจุดจำนวนเต็มและจุดจำนวนทศนิยมจากสตรักต์เดียวกัน

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

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 1.5, y: 4.0 };
    println!("{} {}", a.x, b.y);
}

พารามิเตอร์ชนิดข้อมูลแบบผสม

การใช้พารามิเตอร์สองตัวทำให้ฟิลด์มีชนิดข้อมูลต่างกันได้ Pair<T, U> สามารถเก็บจำนวนเต็มและสตริงได้พร้อมกัน

เลือกใช้พารามิเตอร์เดียวเมื่อฟิลด์ต้องมีชนิดเดียวกัน และใช้หลายพารามิเตอร์เมื่อชนิดข้อมูลอาจแตกต่างกัน

struct Pair<T, U> {
    first: T,
    second: U,
}

เมธอดบนสตรักต์เจเนอริก

หากต้องการเพิ่มเมธอด ให้เขียนพารามิเตอร์ชนิดข้อมูลซ้ำในบล็อก impl: impl<T> Point<T> พารามิเตอร์หลัง impl เป็นการประกาศพารามิเตอร์ ส่วนพารามิเตอร์หลังชื่อชนิดข้อมูลเป็นการนำไปใช้

ในที่นี้ getter จะคืนค่ารีเฟอเรนซ์ไปยังฟิลด์ x

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

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

เมธอดที่มีข้อจำกัด

คุณสามารถเขียนเมธอดสำหรับชนิดข้อมูลจริงบางชนิดเท่านั้น หรือสำหรับชนิดข้อมูลที่ตรงตามข้อจำกัดได้ impl นี้ใช้เฉพาะกับ Point<f64>

ดังนั้น dist_from_origin จึงมีอยู่ในจุดจำนวนทศนิยม แต่ไม่มีในจุดจำนวนเต็ม

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

impl Point<f64> {
    fn dist_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

Enum เจเนอริก

Enum ก็เป็นเจเนอริกได้เช่นกัน แต่ละ variant สามารถเก็บข้อมูลเจเนอริกได้ ลักษณะนี้เหมือนกับ Option มาตรฐาน ซึ่งเป็นได้ทั้ง Some(T) หรือ None

การกำหนดชนิดข้อมูลของคุณเองช่วยให้เห็นวิธีทำงานของชนิดข้อมูลในไลบรารี

enum Maybe<T> {
    Just(T),
    Nothing,
}

พารามิเตอร์สองตัวใน Enum

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

พารามิเตอร์ชนิดข้อมูลหลายตัวใน enum ช่วยให้การจัดการข้อผิดพลาดมีความยืดหยุ่นในระบบนิเวศทั้งหมด

enum Either<L, R> {
    Left(L),
    Right(R),
}

การจับคู่รูปแบบกับ Enum เจเนอริก

คุณจับคู่รูปแบบกับ enum เจเนอริกได้เหมือนกับ enum ที่มีชนิดข้อมูลแน่นอน ข้อมูลที่อยู่ภายในข้อจำกัดจะกลายเป็น binding ภายในแขนงนั้น

โปรแกรมนี้แกะค่าจาก Maybe ที่กำหนดขึ้นเอง แล้วพิมพ์ค่าที่อยู่ภายในหรือค่า fallback

enum Maybe<T> { Just(T), Nothing }

fn main() {
    let m: Maybe<i32> = Maybe::Just(5);
    match m {
        Maybe::Just(n) => println!("got {}", n),
        Maybe::Nothing => println!("empty"),
    }
}

การห่อค่า

รูปแบบที่พบได้บ่อยคือสตรักต์ wrapper ที่มีฟิลด์ชนิด T หนึ่งฟิลด์ พร้อมเมธอดช่วย ในที่นี้ Wrapper เก็บและคืนค่าใด ๆ

นี่คือพื้นฐานของรูปแบบ newtype และชนิดข้อมูลคล้ายพอยน์เตอร์อัจฉริยะ

struct Wrapper<T> { inner: T }

impl<T> Wrapper<T> {
    fn new(v: T) -> Self {
        Wrapper { inner: v }
    }
}

fn main() {
    let w = Wrapper::new("hi");
    println!("{}", w.inner);
}

ไม่มีค่าใช้จ่ายขณะรันไทม์

สตรักต์และ enum เจเนอริกก็ถูกทำให้เป็นชนิดเดียวเช่นกัน หลังคอมไพล์ Point<i32> และ Point<f64> จะกลายเป็นชนิดข้อมูลเฉพาะที่แตกต่างกันสองชนิด

ไม่มีการอ้อมผ่านตัวกลางหรือแท็กที่ซ่อนอยู่สำหรับชนิดข้อมูลเจเนอริกเอง

ตรวจสอบอย่างรวดเร็ว

ทดสอบความเข้าใจเกี่ยวกับสตรักต์และ enum เจเนอริก

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

สตรักต์และ enum ประกาศพารามิเตอร์ชนิดข้อมูลหลังชื่อ แล้วนำไปใช้ในฟิลด์และ variant ทำให้สร้างคอนเทนเนอร์ที่นำกลับมาใช้ได้ เช่น Option และ Result

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

เริ่มต้นได้ฟรี

เรียนรู้ Rust ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 144

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “struct และ enum แบบ泛用” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “struct และ enum แบบ泛用”

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

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

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

บทเรียน “struct และ enum แบบ泛用” ใช้เวลานานแค่ไหน

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

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

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

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

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