Enum Metotları

Coddy'nin Rust Journey'sinin Object Oriented Programming bölümünün bir parçası — ders 15 / 61.

Tıpkı struct'lar gibi, enum'lar da impl bloklarında tanımlanmış metotlara sahip olabilir. Bu, davranışı doğrudan enum türünüze eklemenize olanak tanıyarak birleşik bir arayüz aracılığıyla farklı varyantlarla çalışmayı kolaylaştırır.

Önceki dersteki Message enum'ına nasıl bir metot ekleneceği aşağıda gösterilmiştir:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn describe(&self) -> String {
        match self {
            Message::Quit => String::from("Quit signal"),
            Message::Move { x, y } => format!("Move to ({}, {})", x, y),
            Message::Write(text) => format!("Message: {}", text),
        }
    }
}

impl Message bloğu, tıpkı yapılar (structs) için olduğu gibi çalışır. Metot, enum örneğine erişmek için &self parametresini alır. Metodun içinde, hangi varyantla çalıştığınızı belirlemek ve uygun sonucu döndürmek için match kullanırsınız.

Hangi varyanta sahip olursanız olun, metodu çağırmak aynı görünür:

fn main() {
    let m1 = Message::Quit;
    let m2 = Message::Move { x: 10, y: 20 };
    
    println!("{}", m1.describe());  // Çıkış sinyali
    println!("{}", m2.describe());  // (10, 20) konumuna taşı
}

Bu desen güçlüdür çünkü çağıranın hangi varyanta sahip olduğunu bilmesine gerek yoktur; sadece metodu çağırırlar ve enum geri kalanını dahili olarak halleder. Davranış varyanta göre değişir, ancak arayüz tutarlı kalır.

Görev

Kolay

Mevcut sinyal durumunu açıklamak için metotlara sahip bir enum kullanan bir trafik ışığı sistemi oluşturalım. Her ışık rengi, ne kadar süreceği bilgisini taşıyacak ve bir metot insan tarafından okunabilir bir açıklama sağlayacaktır.

Kodunuzu düzenlemek için iki dosya oluşturacaksınız:

traffic.rs: Üç varyantı olan genel bir TrafficLight enum'ı tanımlayın:
- Red — beklenecek saniyeyi temsil eden bir u32 tutar
- Yellow — beklenecek saniyeyi temsil eden bir u32 tutar
- Green — geçilecek saniyeyi temsil eden bir u32 tutar
Ardından, ışığı açıklayan bir String döndüren bir status metodu uygulayın. Her varyantı işlemek için metodun içinde match kullanın ve süre bilgisini mesaja dahil edin.
main.rs: Trafik modülünüzü içeri aktarın, her ışık varyantının örneklerini oluşturun ve açıklamaları yazdırmak için her birinde status metodunu çağırın.

status metodu şu tam formatlarda mesajlar döndürmelidir:

Red için: Stop for {seconds} seconds
Yellow için: Caution for {seconds} seconds
Green için: Go for {seconds} seconds

Çıktınız, her ışığın durumunu kendi satırında görüntülemelidir:

Stop for {seconds} seconds
Caution for {seconds} seconds
Go for {seconds} seconds

Örneğin, 30 saniyelik bir kırmızı ışık, 5 saniyelik sarı ve 25 saniyelik yeşil ışık ile çıktı şöyle olacaktır:

Stop for 30 seconds
Caution for 5 seconds
Go for 25 seconds

Üç girdi alacaksınız: kırmızı ışık süresi, sarı ışık süresi ve yeşil ışık süresi.

Kopya kağıdı

Enum'lar, tıpkı struct'larda olduğu gibi impl blokları içinde tanımlanmış metotlara sahip olabilirler:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn describe(&self) -> String {
        match self {
            Message::Quit => String::from("Quit signal"),
            Message::Move { x, y } => format!("Move to ({}, {})", x, y),
            Message::Write(text) => format!("Message: {}", text),
        }
    }
}

Metotlar, enum örneğine erişmek için &self parametresini alır ve farklı varyantları işlemek için match kullanır:

let m1 = Message::Quit;
let m2 = Message::Move { x: 10, y: 20 };

println!("{}", m1.describe());  // Quit signal
println!("{}", m2.describe());  // Move to (10, 20)

Çağrıyı yapan taraf, hangi varyant olursa olsun aynı arayüzü kullanır; enum, hangi varyant olduğuna bağlı olarak davranışı dahili olarak yönetir.

Kendin dene

mod traffic;

use traffic::TrafficLight;

fn main() {
    // Süreler için girdiyi oku
    let mut red_input = String::new();
    std::io::stdin().read_line(&mut red_input).expect("Failed to read line");
    let red_duration: u32 = red_input.trim().parse().expect("Invalid number");

    let mut yellow_input = String::new();
    std::io::stdin().read_line(&mut yellow_input).expect("Failed to read line");
    let yellow_duration: u32 = yellow_input.trim().parse().expect("Invalid number");

    let mut green_input = String::new();
    std::io::stdin().read_line(&mut green_input).expect("Failed to read line");
    let green_duration: u32 = green_input.trim().parse().expect("Invalid number");

    // TODO: Giriş süreleri ile her bir TrafficLight varyantının örneklerini oluşturun

    // TODO: Her ışık için status metodunu çağırın ve sonucu yazdırın
}