Değişkenler, değiştirilebilirlik ve türler

Bu derste öğreneceklerin

Değiştirilemez ve mut ile değiştirilebilir değişkenler oluşturmak, sabitleri const ile bildirmek
Gölgelemenin mut'tan farkını açıklamak
Uygun tam sayı, ondalıklı sayı, bool ve char türünü seçmek ve taşmayı güvenle yönetmek
Demetler ve dizilerle çalışmak

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.

Rust

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}");
}

Değiştirilemez bir değişkene ikinci kez değer atanamaz. Sağdaki program 10 ve 15 yazdırır.

Text

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;
  |         +++

Rust'ın hata mesajları çok ayrıntılıdır: sorunlu satırı gösterir, hatta düzeltmeyi de önerir (+++, 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.

Rust

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.

Rust

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

Rust

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

Dikkat: {}, 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.

Rust

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.

Rust

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.

Önemli noktalar

Rust'ta değişkenler varsayılan olarak değiştirilemez; değiştirmek için let mut yazılır.
Bir const sabitinin 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çin f64; char herhangi bir Unicode karakteridir.
Taşmayı checked_add, saturating_add veya wrapping_add ile açıkça yönet.
Demet farklı türde değerler, dizi ise sabit sayıda aynı türde eleman tutar.

Kendini test et

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

1 / 10

let x = 5; x = 6; koduyla ne olur?