Yapılar, metotlar, enum'lar ve match

Kendi türlerini oluştur: alanları olan yapılar, `impl` bloğunda metotlar, varyantları olan `enum`'lar, onları `match` ile işlemek ve `null` yerine `Option`.

  • Orta
  • 20 dk
  • 10 soru
  • Ders 5 / 10

Bu derste öğreneceklerin

  • Bir yapı bildirmek, örneğini oluşturmak ve #[derive(Debug)] ile yazdırmak
  • impl bloğunda &self ve &mut self metotları ile ilişkili fonksiyonlar yazmak
  • Veri taşıyan varyantları olan bir enum oluşturmak ve onu eksiksiz bir match ile işlemek
  • Olmayabilecek bir değeri Option, if let ve unwrap_or ile güvenle yönetmek

Elektronik sınıf defterinde her öğrencinin adı, sınıfı ve not ortalaması vardır; bu üç değeri ayrı değişkenlerde tutmak zahmetlidir, bir arada durmaları gerekir. Trafik ışığı ise aynı anda yalnızca tek bir durumdadır: kırmızı, sarı ya da yeşil. Rust'ta ilk durum için yapılar (struct), ikincisi için numaralandırmalar (enum) vardır.

Yapılar

Yapı, adlandırılmış alanları olan bir türdür. Tür adı PascalCase, alanlar ise snake_case biçiminde yazılır. Örnek oluşturulurken tüm alanlara değer verilmelidir; bir alana nokta ile erişilir: aysel.score. Bir alanı değiştirmek için örneğin tamamı mut olmalıdır; Rust'ta tek bir alan mut yapılamaz.

Rust
#[derive(Debug)]
struct Student {
    name: String,
    grade: u8,
    score: f64,
}

fn main() {
    let mut aysel = Student {
        name: String::from("Aysel"),
        grade: 9,
        score: 91.5,
    };
    aysel.score += 2.0;
    println!("{} is in grade {}", aysel.name, aysel.grade);
    println!("{:?}", aysel);
    println!("{:#?}", aysel);
}

Beklenen çıktı

Aysel is in grade 9
Student { name: "Aysel", grade: 9, score: 93.5 }
Student {
    name: "Aysel",
    grade: 9,
    score: 93.5,
}
#[derive(Debug)] özniteliği derleyiciye yapıyı {:?} ile yazdırmayı öğretir. {:#?} ise her alanı ayrı bir satırda, düzenli biçimde gösterir.

Okumaya devam etmek için ücretsiz kaydol

Dersin geri kalan bölümleri, test ve notlar Educora hesabıyla açılır. Kayıt bir dakika sürer; ilerlemen tüm cihazlarında saklanır.

Metotlar ve impl

Bir türe ait fonksiyonlar impl bloğunda yazılır. İlk parametresi self olan fonksiyon bir metottur ve nokta ile çağrılır: room.area(). self parametresi olmayan fonksiyon ise ilişkili fonksiyondur ve :: ile çağrılır: Rectangle::new(4, 3); String::from da tam olarak böyledir. impl içinde Self, türün kendi adının yerini tutar.

Rust
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn new(width: u32, height: u32) -> Self {
        Self { width, height }
    }

    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn scale(&mut self, factor: u32) {
        self.width *= factor;
        self.height *= factor;
    }
}

fn main() {
    let mut room = Rectangle::new(4, 3);
    println!("Area: {}", room.area());
    room.scale(2);
    println!("Scaled: {}x{}, area {}", room.width, room.height, room.area());
}

Beklenen çıktı

Area: 12
Scaled: 8x6, area 48
İlk parametreAnlamıÇağrı
&selförneği yalnızca okurroom.area()
&mut selförneği değiştirirroom.scale(2)
selfsahipliği alır; örnek sonra kullanılamaztext.into_bytes()
self yokilişkili fonksiyon, çoğu zaman kurucuRectangle::new(4, 3)

Enum ve match

Bir enum, değerin birkaç varyanttan biri olduğunu belirtir. Rust'ta varyantlar kendi verilerini de taşıyabilir: hiçbir şey, adlandırılmış alanlar ya da parantez içinde değerler. Enum'lar match ile işlenir: her kol desen => ifade biçimindedir. match eksiksiz olmalıdır; her olası varyant ele alınmalıdır, yoksa kod derlenmez.

Rust
enum Command {
    Quit,
    Move { x: i32, y: i32 },
    Say(String),
}

fn run(cmd: &Command) -> String {
    match cmd {
        Command::Quit => String::from("bye"),
        Command::Move { x, y } => format!("move to ({x}, {y})"),
        Command::Say(text) => format!("say: {text}"),
    }
}

fn main() {
    let commands = [
        Command::Say(String::from("hello")),
        Command::Move { x: 3, y: -1 },
        Command::Quit,
    ];
    for cmd in &commands {
        println!("{}", run(cmd));
    }
}

Beklenen çıktı

say: hello
move to (3, -1)
bye
format!, println! gibi çalışır ama metni yazdırmak yerine String olarak döndürür. match kollarında x, y ve text, varyantın içindeki verilere bağlanır.

E0004 hatası

fn day_type(day: u8) -> char {
    match day {
        1..=5 => 'W',
        6 | 7 => 'H',
    }
}

`_` ile eksiksiz

fn day_type(day: u8) -> char {
    match day {
        1..=5 => 'W',
        6 | 7 => 'H',
        _ => '?',
    }
}
Bir u8, 0'dan 255'e kadar herhangi bir değer olabilir; bu yüzden derleyici şunu yazar: non-exhaustive patterns: 0_u8 and 8_u8..=u8::MAX not covered. _, “geri kalan her şey” demektir. Desenlerde aralık (1..=5) ve “veya” (6 | 7) da kullanılabilir.

null yerine Option

Rust'ta null yoktur. Bir değer olabilir de olmayabilir de ise standart kütüphanedeki Option<T> enum'u kullanılır: Some(değer) ya da None. İçindeki değeri doğrudan kullanamazsın; derleyici seni None durumunu da ele almaya zorlar. Yalnızca bir varyant ilgini çekiyorsa, uzun bir match yerine kısa bir if let yazabilirsin.

Rust
fn find_index(names: &[&str], target: &str) -> Option<usize> {
    for (i, name) in names.iter().enumerate() {
        if *name == target {
            return Some(i);
        }
    }
    None
}

fn main() {
    let names = ["Elvin", "Leyla", "Murad"];
    match find_index(&names, "Leyla") {
        Some(i) => println!("Leyla is at {i}"),
        None => println!("Leyla not found"),
    }
    if let Some(i) = find_index(&names, "Nigar") {
        println!("Nigar is at {i}");
    } else {
        println!("Nigar not found");
    }
    let murad = find_index(&names, "Murad");
    println!("{:?} {}", murad, murad.unwrap_or(0));
}

Beklenen çıktı

Leyla is at 1
Nigar not found
Some(2) 2
unwrap_or(0), Some içindeki değeri, None olduğunda ise verilen yedek değeri döndürür. Standart kütüphanede aynı işi yapan hazır bir metot da vardır: names.iter().position(|n| *n == target).

Unutma

  • struct, adlandırılmış alanları tek bir türde toplar; #[derive(Debug)] onu {:?} ile yazdırmayı sağlar.
  • Metotlar impl bloğunda yazılır: &self okur, &mut self değiştirir; self içermeyen fonksiyon Tür::ad() biçiminde çağrılır.
  • enum varyantları veri taşıyabilir; match tüm varyantları kapsamalıdır, _ geri kalanları yakalar.
  • Rust'ta null yoktur: olmayabilecek bir değer Option<T> ile, yani Some(x) ya da None ile ifade edilir.
  • unwrap(), None durumunda panikler; match, if let ve unwrap_or daha güvenlidir.
Bu derste bir hata ya da yanlışlık mı gördün?

Kendini test et

10 soru. Her doğru cevap XP kazandırır.

Soru 1 / 10

Soru 1 / 10. Hangi metot imzası yapının alanlarını değiştirmeye izin verir?