การใช้งาน Class and object ในภาษา Rust แบบง่ายๆ พร้อมตัวอย่าง

# การใช้งาน Class และ Object ในภาษา Rust พร้อมตัวอย่างโค้ดและการนำไปใช้

หากคุณกำลังมองหาภาษาโปรแกรมมิ่งที่ปลอดภัยและมีประสิทธิภาพสูง ภาษา Rust คือคำตอบของคุณ ในบทความนี้ เราจะพูดถึง "Class" และ "Object" ซึ่งเป็นหัวใจของการเขียนโปรแกรมแบบเชิงวัตถุ (OOP) แม้ว่า Rust เองจะไม่มี class ในแบบที่เราคุ้นเคยจากภาษาอื่น ๆ แต่เราสามารถใช้สิ่งที่เรียกว่า "Structs" และ "Enums" เพื่อสร้างโครงสร้างที่คล้ายคลึงกับ class ได้ พร้อมด้วย "traits" เพื่อกำหนดพฤติกรรมหรือ interface ที่เฉพาะเจาะจง

ตัวอย่างที่ 1: Structs เบื้องต้น

 struct Person {
    name: String,
    age: u8,
}

impl Person {
    fn new(name: String, age: u8) -> Person {
        Person { name, age }
    }

    fn greet(&self) {
        println!("สวัสดี, ฉันชื่อ {} และฉันอายุ {} ปี", self.name, self.age);
    }
}

fn main() {
    let person = Person::new(String::from("สมชาย"), 30);
    person.greet();
}

ในโค้ดข้างต้น `Person` เป็น `struct` ที่แทนคลาสใน OOP โดยมี fields `name` และ `age` และใช้ `impl` เพื่อกำหนด methods ให้กับ struct ด้วยการใช้ `impl` เราสามารถเพิ่ม method `new` และ `greet` เพื่อปฏิสัมพันธ์กับ `Person` object ได้

ตัวอย่างที่ 2: Traits เพื่อกำหนดพฤติกรรมขั้นพื้นฐาน

 trait Animal {
    fn make_noise(&self) -> String;
}

struct Dog {
    name: String,
}

impl Animal for Dog {
    fn make_noise(&self) -> String {
        format!("{}, บ๊องๆ!", self.name)
    }
}

fn main() {
    let my_dog = Dog { name: String::from("หมาน้อย") };
    println!("{}", my_dog.make_noise());
}

ในตัวอย่างที่สองนี้ `Animal` เป็น `trait` ที่กำหนด interface `make_noise` สำหรับ struct `Dog` และเมื่อเรานำ `trait` มาใช้กับ `Dog` เราจึงสามารถ call `make_noise` method และที่สำคัญ Rust บังคับให้เราต้องสร้าง implementation สำหรับ method ที่ถูกกำหนดใน `trait` เพื่อให้สามารถใช้ struct นั้นอย่างเป็นรูปธรรม

ตัวอย่างที่ 3: Enum และ Pattern Matching

 enum Vehicle {
    Bicycle(String),
    Car(String, String),
}

impl Vehicle {
    fn print_details(&self) {
        match self {
            Vehicle::Bicycle(model) => {
                println!("Bicycle model: {}", model);
            }
            Vehicle::Car(make, model) => {
                println!("Car make: {}, model: {}", make, model);
            }
        }
    }
}

fn main() {
    let bike = Vehicle::Bicycle(String::from("SpeedX"));
    let car = Vehicle::Car(String::from("Toyota"), String::from("Corolla"));
    bike.print_details();
    car.print_details();
}

ในตัวอย่างนี้ `Vehicle` เป็น `enum` ที่สามารถเป็นได้ทั้ง `Bicycle` และ `Car` และเราใช้ `match` ซึ่งเป็นคุณสมบัติของ Rust ในการจัดการแบบ pattern matching เพื่อตัดสินใจว่าจะประมวลผลข้อมูลอย่างไรให้ถูกต้องตาม type ของ `enum`

Usecase ในโลกจริง

หนึ่งใน usecase ที่น่าสนใจในการใช้งาน struct และ trait ใน Rust คือการสร้าง library สำหรับการจัดการกับ connection ที่หลากหลายในการพัฒนา web service โดยแต่ละ connection type (เช่น, HTTP, TCP, WebSocket) สามารถถูกกำหนดไว้เป็น structs ของตัวเองที่ implement trait ที่มีชื่อว่า `Connection` เพื่อพัฒนาโค้ดที่ยืดหยุ่นและมีการจัดการทรัพยากรได้อย่างมีประสิทธิภาพ

ผ่านบทความนี้ คุณจะได้เห็นว่า Rust สามารถเสนอแนวทางในการโปรแกรมแบบเชิงวัตถุได้ในรูปแบบที่แตกต่างแต่ก็เปี่ยมด้วยประสิทธิภาพ หากคุณอยากรู้เรื่อง Rust มากขึ้นหรือต้องการพัฒนาทักษะการเขียนโค้ด ที่ EPT (Expert-Programming-Tutor) เราพร้อมที่จะพาคุณไปสัมผัสประสบการณ์การเรียนรู้ที่ไม่เหมือนใครและเติบโตไปด้วยกันกับเทคโนโลยียุคใหม่ ไม่รอช้า มาเริ่มต้นการเรียนรู้กับเราวันนี้!

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