Learn Rust Coding · Ders

let ve Değişebilirlik

Bağlamalar ve mut

let ve Değişebilirlik, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 4 dersten oluşur.

Binding Values with let

Rust'ta bir değişkeni let anahtar kelimesiyle oluşturursunuz. Bu işlem, bir isme bir değer bağlar (binds).

Varsayılan olarak her bağlama imütabl (immutable) durumdadır — yani bir kez değer atadığınızda, onu değiştiremezsiniz.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Immutable by Default

Rust, değişkenleri özellikle immutable yapar. Bu, kazara yapılan değişiklikleri önler ve kodun mantığını kavramayı kolaylaştırır.

Immutable bir binding'e yeniden değer atamaya çalışmak, çalışma zamanı hatasına (runtime crash) değil, bir derleme hatasına (compile error) yol açar.

let x = 5; ve ardından x = 6; yazmak derlenmeyecektir (not compile).

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Making Variables Mutable

Bir değeri değiştirmeniz gerektiğinde mut anahtar kelimesini ekleyin. Bu, değişkenin mutable (değiştirilebilir) olmasını sağlar.

Artık değişkene dilediğiniz kadar yeni değer atayabilirsiniz.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Type Inference

Rust, genellikle bir değişkenin türünü değerinden anlar. Buna type inference denir.

let x = 5; ifadesi, x değişkenine otomatik olarak i32 türünü verir.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Type Annotations

İki nokta üst üste ve bir veri tipi adı kullanarak tipi açıkça belirtebilirsiniz. Buna type annotation denir.

Annotation'lar, derleyicinin tipi çıkaramadığı durumlarda veya kodun anlaşılırlığını artırmak için faydalıdır.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Constants

Bir const her zaman immutable'dır (değişmez) ve bir tür ek açıklaması (type annotation) almalıdır. Değeri derleme zamanında (compile time) bilinmelidir.

Genel bir kural olarak constant'lar SCREAMING_SNAKE_CASE formatında yazılır.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const vs let

const ve let arasındaki temel farklar:

const asla mut olamaz.
const bir tür bildirimi (type annotation) gerektirir.
const, derleme zamanında (compile-time) sabit bir ifade olmalıdır.
let değerleri çalışma zamanında (runtime) hesaplanabilir.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Mutating in a Loop

Değişkenlerin zamanla bir değer biriktirdiği döngülerde mutable değişkenler yaygın olarak kullanılır.

Burada, bir mut biriktirici (accumulator) kullanarak sayıları topluyoruz.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Underscore for Unused

Bir değere değişken atar ancak bunu hiç kullanmazsanız, Rust sizi uyarır. Bu uyarıyı susturmak için değişken adının başına bir alt çizgi ekleyin.

let _unused = 10; derleyiciye bunun bilinçli olduğunu söyler.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Multiple Bindings

Ayrı satırlarda, her biri kendi let ifadesine sahip birkaç değişken tanımlayabilirsiniz.

Her bağlama (binding) bağımsızdır ve mut ile işaretlenmediği sürece değiştirilemez (immutable) kalır.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Why Immutability Helps

Değiştirilemezlik (immutability) bir güvenlik özelliğidir. Derleyici bir değerin değişemeyeceğini bildiğinde daha güçlü garantiler sunabilir ve bütün bir hata (bug) sınıfını önleyebilir.

Yalnızca gerçekten ihtiyaç duyduğunuzda mut ile mutasyona izin verin.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Quick Check

Rust'ta bir değişkeni değiştirilebilir (mutable) yapan anahtar kelime hangisidir?

Recap

Rust'te binding (bağlama) işlemlerinin temellerini öğrendin:

let bir ismi bir değere bağlar ve varsayılan olarak immutableseldir.
mut bir binding'i mutable yapar.
Rust türleri (types) otomatik çıkarır, ancak : kullanarak tür belirtimi (annotation) yapabilirsin.
const derleme zamanlıdır (compile-time), her zaman immutable'dır ve bir tür gerektirir.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Sıkça Sorulan Sorular

“let ve Değişebilirlik” dersi ücretsiz mi?

Evet — “let ve Değişebilirlik” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 4 dersten oluşur.

“let ve Değişebilirlik” dersinde ne öğreneceğim?

Bağlamalar ve mut Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“let ve Değişebilirlik” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Learn Rust Coding Sayfasına Dön