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.
#[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.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.
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 parametre | Anlamı | Çağrı |
|---|---|---|
&self | örneği yalnızca okur | room.area() |
&mut self | örneği değiştirir | room.scale(2) |
self | sahipliği alır; örnek sonra kullanılamaz | text.into_bytes() |
self yok | ilişkili fonksiyon, çoğu zaman kurucu | Rectangle::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.
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',
_ => '?',
}
}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.
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
implbloğunda yazılır:&selfokur,&mut selfdeğiştirir;selfiçermeyen fonksiyonTür::ad()biçiminde çağrılır. enumvaryantları veri taşıyabilir;matchtüm varyantları kapsamalıdır,_geri kalanları yakalar.- Rust'ta
nullyoktur: olmayabilecek bir değerOption<T>ile, yaniSome(x)ya daNoneile ifade edilir. unwrap(),Nonedurumunda panikler;match,if letveunwrap_ordaha güvenlidir.