Rust Hile Sayfası
Son güncelleme
Hello World ve yapı
Bir Rust programı fn main'de başlar; ifadeler noktalı virgülle biter.
| İşlem | Söz dizimi |
|---|---|
| Giriş noktası | fn main() { ... } |
| Bir satır yazdır | println!("Hello, World!"); |
| Değerlerle yazdır | println!("{} is {}", name, age); |
| Debug biçiminde yazdır | println!("{:?}", value); |
| Satır yorumu | // comment |
| Bir modülden bir öğe kullan | use std::collections::HashMap; |
| Derle ve çalıştır | cargo run |
| Bir release ikili dosyası derle | cargo build --release |
Değişkenler ve tipler (let / mut)
Bağlamalar varsayılan olarak değiştirilemezdir; yeniden atamaya izin vermek için mut ekleyin.
| İşlem | Söz dizimi |
|---|---|
| Değiştirilemez bağlama | let x = 5; |
| Değiştirilebilir bağlama | let mut count = 0; |
| Açık tip | let age: u32 = 30; |
| Sabit | const MAX: u32 = 100; |
| Gölgeleme (shadowing) | let x = x + 1; |
| Tam sayı tipleri | i32, u32, i64, usize |
| Diğer skalerler | f64, bool, char |
| Demet (tuple) | let pair: (i32, &str) = (1, "a"); |
| Tip dönüşümü | let f = x as f64; |
Kontrol akışı
if bir ifadedir ve Rust'ın üç döngü biçimi vardır.
| İşlem | Söz dizimi |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| İfade olarak if | let y = if x > 0 { 1 } else { -1 }; |
| Sonsuz döngü | loop { ... } |
| Değer döndüren döngü | let v = loop { break 5; }; |
| While döngüsü | while x < 100 { ... } |
| Bir aralık üzerinde for | for i in 0..10 { ... } |
| Bir koleksiyon üzerinde for | for item in &items { ... } |
| Break / continue | break;, continue; |
Fonksiyonlar
Son ifade (noktalı virgül olmadan) geri dönüş değeridir.
| İşlem | Söz dizimi |
|---|---|
| Temel fonksiyon | fn add(a: i32, b: i32) -> i32 { a + b } |
| Açık return | fn f() -> i32 { return 5; } |
| Geri dönüş değeri yok | fn log(msg: &str) { ... } |
| Bir referans al | fn len(s: &String) -> usize { s.len() } |
| Closure | let add = |a, b| a + b; |
| Tipli closure | let sq = |x: i32| -> i32 { x * x }; |
| Argüman olarak fonksiyon | fn apply(f: impl Fn(i32) -> i32) { ... } |
Sahiplik ve borrowing
Her değerin bir sahibi vardır; referanslar sahipliği almadan onu ödünç alır.
| İşlem | Söz dizimi |
|---|---|
| Move (sahiplik aktarılır) | let b = a; (a artık geçerli değil) |
| Clone (derin kopya) | let b = a.clone(); |
| Değiştirilemez borrow | let r = &x; |
| Değiştirilebilir borrow | let r = &mut x; |
| Bir fonksiyonda borrow | fn read(s: &String) { ... } |
| Değerine eriş (dereference) | *r |
| Borrowing kuralı | Aynı anda birden çok & VEYA tek bir &mut, ikisi birden değil |
| Slice (bir aralığı ödünç alır) | let part = &arr[1..3]; |
Struct'lar ve enum'lar
Struct'lar ilgili veriyi gruplar; enum'lar birkaç varyanttan biri olan bir değeri modeller.
| İşlem | Söz dizimi |
|---|---|
| Bir struct tanımla | struct Point { x: i32, y: i32 } |
| Bir örnek oluştur | let p = Point { x: 1, y: 2 }; |
| Bir alana eriş | p.x |
| Tuple struct | struct Pair(i32, i32); |
| Metot (impl bloğu) | impl Point { fn dist(&self) -> f64 { ... } } |
| İlişkili fonksiyon | impl Point { fn new() -> Self { ... } } |
| Bir enum tanımla | enum Shape { Circle(f64), Rect(f64, f64) } |
| Adlandırılmış alanlı enum | enum Msg { Move { x: i32, y: i32 } } |
| Trait'leri türet (derive) | #[derive(Debug, Clone)] |
Desen eşleştirme (match)
match bir değeri desenlerle karşılaştırır ve kapsamlı (exhaustive) olmalıdır.
| İşlem | Söz dizimi |
|---|---|
| Değerlerde eşleştir | match x { 1 => "one", _ => "other" } |
| Bir enum'ı eşleştir | match shape { Shape::Circle(r) => ... } |
| Bir aralığı eşleştir | match n { 1..=5 => ..., _ => ... } |
| Koşulla (guard) bağla | match x { n if n > 0 => ... } |
| Bir demeti eşleştir | match point { (0, y) => ..., (x, _) => ... } |
| if let (tek desen) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Bir struct'ı ayrıştır | let Point { x, y } = p; |
Trait'ler ve generic'ler
Trait'ler ortak davranışı tanımlar; generic'ler kodun birçok tip üzerinde çalışmasını sağlar.
| İşlem | Söz dizimi |
|---|---|
| Bir trait tanımla | trait Area { fn area(&self) -> f64; } |
| Bir trait uygula | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Varsayılan metot | trait Greet { fn hi(&self) { ... } } |
| Generic fonksiyon | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Generic struct | struct Wrapper<T> { value: T } |
| Trait sınırı (where) | fn f<T>(x: T) where T: Display { ... } |
| impl Trait argümanı | fn print(item: impl Display) { ... } |
| Trait nesnesi | let shapes: Vec<Box<dyn Area>> = ...; |
Hata yönetimi (Result / Option)
Rust yokluğu Option ile, kurtarılabilir hataları Result ile modeller.
| İşlem | Söz dizimi |
|---|---|
| İsteğe bağlı değer | Option<T>: Some(v) veya None |
| Result tipi | Result<T, E>: Ok(v) veya Err(e) |
| Bir Result döndür | fn read() -> Result<String, Error> { ... } |
| ? ile yay (propagate) | let data = read()?; |
| Unwrap (None/Err'de panik yapar) | opt.unwrap() |
| Varsayılan değer | opt.unwrap_or(0) |
| Bir değeri dönüştür (map) | opt.map(|v| v + 1) |
| Her iki kolu da işle | match res { Ok(v) => ..., Err(e) => ... } |
| Option'ı Result'a dönüştür | opt.ok_or("missing")? |
Yaygın koleksiyonlar (Vec / HashMap)
Vec büyüyebilen bir dizidir; HashMap bir anahtar-değer deposudur.
| İşlem | Söz dizimi |
|---|---|
| Bir vektör oluştur | let mut v: Vec<i32> = Vec::new(); |
| Vektör değişmezi | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| İndeksle erişim | v[0] |
| Güvenli erişim | v.get(0), Option<&T> döndürür |
| Dolaş | for x in &v { ... } |
| Uzunluk | v.len() |
| Bir map oluştur | let mut m: HashMap<String, i32> = HashMap::new(); |
| Ekle / al | m.insert(k, v);, m.get(&k) |
| Entry API | *m.entry(k).or_insert(0) += 1; |
En çok başvurduğunuz Rust söz dizimi tek sayfada. Bu Rust hile sayfası, temel dil için hızlı bir başvurudur - değişkenler ve değiştirilebilirlik, sahiplik ve borrowing, struct'lar ve enum'lar, desen eşleştirme, trait'ler ve generic'ler ve Rust'ın hata yönetiminin arkasındaki Result ve Option tipleri.
Buradaki her şey güncel bir kararlı araç zincirinde derlenen standart Rust'tır. İhtiyacınız olanı kopyalayın ya da her kod parçasını Rust playground'da canlı deneyin - cargo kurulumu gerekmez.
Rust hile sayfası SSS
Bu Rust hile sayfası ücretsiz mi?
Evet. Bu Rust hile sayfası tamamen ücretsizdir ve kayıt gerektirmez. Yer imlerinize ekleyin ve bir match desenine, trait sınırına ya da koleksiyon metoduna bakmanız gerektiğinde geri dönün.
Rust'ta sahiplik ve borrowing nedir?
Sahiplik, Rust'ın bellek modelidir: her değerin tam olarak bir sahibi vardır ve o sahip kapsam dışına çıktığında değer serbest bırakılır. Borrowing, bir referans kullanarak sahipliği almadan bir değere erişmenizi sağlar - değiştirilemez bir borrow için
&x veya değiştirilebilir bir borrow için &mut x. Derleyici tek bir kuralı uygular: aynı anda birden çok değiştirilemez borrow'a veya tam olarak bir değiştirilebilir borrow'a sahip olabilirsiniz; bu da veri yarışlarını derleme zamanında önler.Rust'ta Result ile Option arasındaki fark nedir?
Option<T> yok olabilen bir değeri temsil eder - ya Some(v) ya da None'dır ve raporlanacak bir hata olmadığında, yalnızca eksik bir değer olduğunda kullanırsınız. Result<T, E> başarısız olabilen bir işlemi temsil eder - ya Ok(v) ya da Err(e)'dir ve bir şeyler ters gittiğinde bir hata değeri taşır. "Belki orada" için Option, "bu başarısız olabilir" için Result kullanın; ? operatörü her ikisini de yayar.Rust'ı çevrimiçi olarak deneyebilir miyim?
Evet. Rust playground'u açarak bu hile sayfasındaki herhangi bir kod parçasını tarayıcınızda derleyip çalıştırabilirsiniz - kurmanız gereken cargo veya araç zinciri yok. Yapı istediğinizde, Coddy'nin ücretsiz etkileşimli Rust kursu sizi değişkenler ve sahiplikten trait'lere ve hata yönetimine adım adım götürür.
Bu hile sayfası yeni başlayanlar için uygun mu?
Evet. En yaygın konulardan (değişkenler, kontrol akışı, fonksiyonlar) gelişmiş olanlara (trait'ler, generic'ler, hata yönetimi) doğru düzenlenmiştir, böylece üstteki bölümleri ilk günden kullanabilir ve zamanla sahipliğe ve geri kalanına geçebilirsiniz.
İlgili kaynaklar
Daha fazla kopya kağıdı
