Learn Rust Coding · Ders

Skaler Türler

Tamsayılar, kayan noktalılar, bool, char

Skaler Türler, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 2. 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.

What Are Scalar Types?

Bir skaler tip, tek bir değeri temsil eder. Rust'ın dört ana skaler tipi vardır:

Tam sayılar
Kayan noktalı sayılar
Boolean'lar
Karakterler

fn main() {
    let i = 10;       // integer
    let f = 2.5;      // float
    let b = true;     // bool
    let c = 'R';      // char
    println!("{} {} {} {}", i, f, b, c);
}

Tamsayı Türleri

Tamsayıların sabit boyutlu işaretli (i) ve işaretsiz (u) çeşitleri vardır: i8, i16, i32, i64, i128 ve u için aynı türler.

Varsayılan tamsayı türü i32'dir.

fn main() {
    let small: i8 = -120;
    let big: u64 = 18_000_000_000;
    println!("{} {}", small, big);
}

İşaretli ve İşaretsiz Türler

İşaretli tamsayılar negatif olabilir; işaretsiz tamsayılar olamaz.

i8, -128 ile 127 arasındadır.
u8, 0 ile 255 arasındadır.

Bir değer hiçbir zaman negatif olamıyorsa, örneğin bir sayım değeriyse, işaretsiz türü seçin.

fn main() {
    let temperature: i32 = -15;
    let people: u32 = 250;
    println!("temp {} people {}", temperature, people);
}

Tamsayı Sabitleri

Tamsayıları farklı tabanlarda yazabilir ve okunabilirlik için alt çizgi kullanabilirsiniz.

Ondalık: 1_000_000
Onaltılık: 0xff
Sekizlik: 0o77
İkilik: 0b1010

fn main() {
    let dec = 1_000;
    let hex = 0xff;
    let bin = 0b1010;
    println!("{} {} {}", dec, hex, bin);
}

Kayan Noktalı Türler

Rust'ta iki kayan noktalı tür vardır: f32 ve f64. Daha fazla kesinlik sunduğu için varsayılan tür f64'tür.

Kayan noktalı sayılar IEEE-754 standardını izler.

fn main() {
    let pi: f64 = 3.141592;
    let e: f32 = 2.718;
    println!("pi {} e {}", pi, e);
}

Sayısal İşlemler

Rust, alışılmış matematik işleçlerini destekler: +, -, *, / ve % (kalan).

Tamsayı bölmesi sıfıra doğru kesme yapar.

fn main() {
    let sum = 5 + 10;
    let quotient = 7 / 2;     // 3 (integer)
    let remainder = 7 % 2;    // 1
    let float_div = 7.0 / 2.0; // 3.5
    println!("{} {} {} {}", sum, quotient, remainder, float_div);
}

Boolean Türü

bool türünün tam olarak iki değeri vardır: true ve false.

Boolean değerler karşılaştırmalarla üretilir ve if koşullarında kullanılır.

fn main() {
    let is_active = true;
    let is_bigger = 10 > 3;
    println!("{} {}", is_active, is_bigger);
}

Karakter Türü

Bir char, tek bir Unicode skaler değerini temsil eder ve tek tırnaklarla yazılır.

Rust'ta bir char 4 bayttır ve ASCII'den çok daha fazlasını, emojiler ve aksanlı harfler dâhil, barındırabilir.

fn main() {
    let letter = 'A';
    let symbol = '@';
    let heart = '\u{2764}';
    println!("{} {} {}", letter, symbol, heart);
}

char ve String Karşılaştırması

Tek tırnaklar bir char, çift tırnaklar ise bir dize dilimi (&str) oluşturur.

'a' tek bir karakterdir.
"a" tek karakterli bir dizedir.

fn main() {
    let c = 'x';
    let s = "x";
    println!("char {} string {}", c, s);
}

as ile Tür Dönüştürme

Rust, sayısal türleri otomatik olarak dönüştürmez. Açık tür dönüşümleri için as anahtar sözcüğünü kullanın.

Dikkatli olun: daha küçük bir türe dönüştürmek veri kaybına yol açabilir.

fn main() {
    let x: i32 = 65;
    let y: f64 = x as f64;
    let c = x as u8 as char;
    println!("{} {} {}", x, y, c);
}

Skaler Türleri Bir Araya Getirme

Programlar skaler türleri sürekli olarak birleştirir. Burada bir karar vermek için tamsayıları, kayan noktalı sayıları ve boolean değerleri bir arada kullanıyoruz.

fn main() {
    let price: f64 = 19.99;
    let quantity: u32 = 3;
    let total = price * quantity as f64;
    let is_expensive = total > 50.0;
    println!("total {} expensive {}", total, is_expensive);
}

Hızlı Kontrol

Rust skaler sabitleri hakkındaki bilginizi sınayın.

Özet

Rust'ın dört skaler türü:

Tamsayılar — işaretli (i32) ve işaretsiz (u32), çeşitli boyutlarda.
Kayan noktalı sayılar — f32 ve f64; varsayılan f64.
bool — true veya false.
char — tek tırnaklar içindeki tek bir Unicode değeri.

Açık sayısal dönüşümler için as kullanın.

fn main() {
    let count: u32 = 42;
    let ratio: f64 = count as f64 / 7.0;
    let ok: bool = ratio > 5.0;
    let grade: char = 'B';
    println!("{} {} {} {}", count, ratio, ok, grade);
}

Sıkça Sorulan Sorular

“Skaler Türler” dersi ücretsiz mi?

Evet — “Skaler Türler” 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.

“Skaler Türler” dersinde ne öğreneceğim?

Tamsayılar, kayan noktalılar, bool, char 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 2. dersidir.

“Skaler Türler” 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