Banka kartındaki bakiye her gün değişir, doğum tarihin ise asla. Birçok dilde bu iki değer aynı şekilde saklanır ve doğum tarihini yanlışlıkla “değiştirmek” mümkündür. Rust seni önceden karar vermeye zorlar: bir değişken varsayılan olarak değiştirilemez; değişebilmesi için bunu açıkça yazmalısın.
let, mut ve const
Değişken let anahtar kelimesiyle oluşturulur. Türünü yazmak çoğu zaman gerekmez: derleyici onu değerden kendisi çıkarır. Değer daha sonra değişecekse addan önce mut (İngilizce mutable, değiştirilebilir) yaz. Rust'ta değişken adları snake_case biçiminde yazılır: total_score, user_name.
fn main() {
let city = "Baku";
let mut score = 10;
println!("{city}: {score}");
score += 5;
println!("{city}: {score}");
}Beklenen çıktı
Baku: 10 Baku: 15
E0384 hatası
fn main() {
let score = 10;
println!("{score}");
score = 15;
println!("{score}");
}`mut` ile doğru
fn main() {
let mut score = 10;
println!("{score}");
score = 15;
println!("{score}");
}10 ve 15 yazdırır.error[E0384]: cannot assign twice to immutable variable `score`
--> src/main.rs:4:5
|
2 | let score = 10;
| ----- first assignment to `score`
3 | println!("{score}");
4 | score = 15;
| ^^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
2 | let mut score = 10;
| ++++++, eklenmesi gereken metni işaretler).Sabitler const ile bildirilir. Türleri her zaman yazılmalıdır, adları BÜYÜK_HARFLERLE yazılır ve değerleri derleme sırasında bilinmelidir. Bir sabit main dışında, dosyanın başında da bildirilebilir.
const MAX_PLAYERS: u32 = 4;
const SECONDS_PER_HOUR: u32 = 60 * 60;
fn main() {
println!("Players: {}", MAX_PLAYERS);
println!("Seconds in 2 hours: {}", 2 * SECONDS_PER_HOUR);
}Beklenen çıktı
Players: 4 Seconds in 2 hours: 7200
Gölgeleme
Aynı adla yeniden let yazarsan eskisini örten yeni bir değişken oluşur; buna gölgeleme (shadowing) denir. Gölgelemeyle değerin türünü bile değiştirebilirsin. İç bir blokta ({ }) yapılan gölgeleme ise blok bitince ortadan kalkar.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("spaces = {spaces}");
let x = 5;
let x = x + 1;
{
let x = x * 2;
println!("inner x = {x}");
}
println!("outer x = {x}");
}Beklenen çıktı
spaces = 3 inner x = 12 outer x = 6
spaces önce metindi, sonra sayı oldu. mut ile bu mümkün olmazdı: mut değişkenin değerini değiştirmeye izin verir, türünü değil.Skaler türler
Skaler bir tür tek bir değer tutar. Rust'ta dört çeşidi vardır: tam sayılar, kayan noktalı sayılar, mantıksal bool (true/false) ve karakter char. Tam sayı türünün adı işaretini ve boyutunu gösterir: i işaretli (negatif olabilir), u işaretsiz demektir, sayı ise bit sayısıdır. Tür belirtilmezse tam sayı i32, ondalıklı sayı f64 olur.
| Tür | Aralık veya içerik | Tipik kullanım |
|---|---|---|
u8 | 0 … 255 | baytlar, renk bileşenleri, yaş |
i32 | −2 147 483 648 … 2 147 483 647 | sıradan tam sayılar (varsayılan tür) |
i64, u64 | yaklaşık ±9,2 · 10¹⁸ | büyük sayaçlar, zaman damgaları |
usize | 64 bit sistemde 64 bit | indeksler ve uzunluklar |
f64 | yaklaşık 15–16 kesin basamak | ondalıklı sayılar (varsayılan tür) |
bool | true, false | koşullar |
char | herhangi bir Unicode karakteri, 4 bayt | tek harfler ve simgeler |
fn main() {
let age: u8 = 14;
let temperature: i32 = -3;
let price: f64 = 2.5;
let whole: f64 = 10.0;
let is_open = true;
let currency = '₼';
println!("{age} {temperature} {price} {whole} {is_open} {currency}");
println!("{:?} {:.2}", whole, price);
println!("{} {} {}", 7 / 2, 7 % 2, 7.0 / 2.0);
println!("{} {}", 3.9_f64 as i32, u8::MAX);
}Beklenen çıktı
14 -3 2.5 10 true ₼ 10.0 2.50 3 1 3.5 3 255
{}, 10.0 değerini 10 olarak, {:?} ise 10.0 olarak yazdırır. {:.2} noktadan sonra iki basamak bırakır. Tam sayı bölmesi kesirli kısmı atar, as ise türü dönüştürür.fn main() {
let level: u8 = 250;
println!("{:?}", level.checked_add(10));
println!("{:?}", level.checked_add(5));
println!("{}", level.saturating_add(10));
println!("{}", level.wrapping_add(10));
}Beklenen çıktı
None Some(255) 255 4
Some ve None, “değer var” ve “değer yok” demektir; bu Option türüyle 5. derste tanışacaksın. 250 + 10 = 260, 260 − 256 = 4.Bileşik türler: demetler ve diziler
Demet (tuple), farklı türlerdeki birkaç değeri bir arada tutar: ("Murad", 15, 4.5). Elemanlarına nokta ve indeksle (student.0) erişilir ya da demet let (a, b, c) = ... ile ayrı değişkenlere açılır. Dizi ise aynı türde, boyutu sabit elemanlardan oluşan bir dizidir: türü [i32; 5] gibi yazılır, elemanlara days[0] ile erişilir.
fn main() {
let student: (&str, u8, f64) = ("Murad", 15, 4.5);
let (name, age, grade) = student;
println!("{name} is {age}, average grade {grade}");
println!("First field: {}", student.0);
let days = ["Mon", "Tue", "Wed", "Thu", "Fri"];
let zeros = [0; 3];
println!("{} days, first: {}", days.len(), days[0]);
println!("{:?}", zeros);
println!("{:?}", student);
}Beklenen çıktı
Murad is 15, average grade 4.5
First field: Murad
5 days, first: Mon
[0, 0, 0]
("Murad", 15, 4.5)[0; 3], “üç sıfır” demektir. Diziler ve demetler {:?} ile yazdırılmalıdır; {:?} metinleri tırnak içinde gösterir.Unutma
- Rust'ta değişkenler varsayılan olarak değiştirilemez; değiştirmek için
let mutyazılır. - Bir
constsabitinin türü mutlaka yazılır ve değeri derleme sırasında bilinmelidir. - Gölgeleme aynı adla yeni bir değişken oluşturur ve türü değiştirmeye izin verir.
- Varsayılan türler: tam sayılar için
i32, ondalıklılar içinf64;charherhangi bir Unicode karakteridir. - Taşmayı
checked_add,saturating_addveyawrapping_addile açıkça yönet. - Demet farklı türde değerler, dizi ise sabit sayıda aynı türde eleman tutar.