Learn Rust Coding · Ders

Güçlü Örüntü Eşleştirme

Veri varyantlarını özlü ve eksiksiz biçimde ele almak için `match` ifadelerinde ve diğer örüntü eşleştirme yapılarında ustalaşın.

Güçlü Örüntü Eşleştirme, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 dersinin 3. 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 3 dersten oluşur.

Örüntü Eşlemenin Gücünü Keşfedin

Rust'ta örüntü eşleme dünyasına hoş geldiniz! Bu güçlü özellik, program akışını verilerin yapısına göre denetlemenizi sağlar.

Yalnızca eşitliği denetlemek yerine değerlerin yapısını çözebilir, bileşenleri çıkarabilir ve farklı veri biçimleri için belirli kodları çalıştırabilirsiniz.

Bu, güçlendirilmiş bir if/else veya switch ifadesi gibidir.
Kapsamlılık sağlar: olası tüm örüntüleri ele almalısınız.
Kodu daha okunabilir ve sağlam hâle getirir.

`match` İfadesinin Temelleri

Örüntü eşlemenin temeli match ifadesidir. Bir değer alır ve bunu bir dizi örüntüyle karşılaştırır. Eşleşen ilk örüntü kazanır!

Bir match ifadesinin her 'kolu', bir örüntüden ve bu örüntü eşleşirse çalıştırılacak koddan oluşur.

enum Direction {
  North,
  East,
  South,
  West,
}

fn main() {
  let my_direction = Direction::North;

  match my_direction {
    Direction::North => println!("Going up!"),
    Direction::East => println!("Going right!"),
    Direction::South => println!("Going down!"),
    Direction::West => println!("Going left!"),
  }
}

Değişmez Değerleri ve Aralıkları Eşleme

Belirli değişmez değerlerle (sayılar, karakterler, boolean değerler) eşleştirme yapabilir veya ..= kullanarak aralıklar tanımlayabilirsiniz. | işleci, tek bir kolla birden çok örüntüyü eşlemenizi sağlar.

Örüntülerin sırayla denetlendiğini ve ilk eşleşmenin kullanıldığını unutmayın.

fn main() {
  let x = 7;

  match x {
    1 => println!("It's one!"),
    2 | 3 => println!("It's two or three!"),
    4..=8 => println!("It's between four and eight!"),
    _ => println!("It's something else!"), // Catch-all
  }

  let character = 'b';
  match character {
    'a'..='e' => println!("Early letter"),
    _ => println!("Other letter"),
  }
}

Yapıların Yapısını Çözme

Örüntü eşleme; yapılar gibi karmaşık veri türlerinin yapısını çözerken gerçekten öne çıkar. Tek tek alanları doğrudan match kolu içindeki değişkenlere çıkarabilirsiniz.

Bu, özellikle belirli alan değerlerini eşlerken yapı verilerine erişimi temiz ve kısa hâle getirir.

struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let p = Point { x: 0, y: 7 };

  match p {
    Point { x, y: 0 } => println!("On the X axis at {}", x),
    Point { x: 0, y } => println!("On the Y axis at {}", y),
    Point { x, y } => println!("Not on an axis: ({}, {})", x, y),
  }
}

Veri İçeren Numaralandırmaların Yapısını Çözme

Rust'taki numaralandırmalar ilişkili veri taşıyabilir. Örüntü eşleme, bu veriyi bir numaralandırma varyantından çıkarmanın temel yoludur.

Verilerin yapısını doğrudan yeni değişkenlere çözebilir, böylece her varyantın içeriğiyle çalışmayı kolaylaştırabilirsiniz.

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
  match msg {
    Message::Quit => println!("Quit message."),
    Message::Move { x, y } => {
      println!("Move to x: {}, y: {}", x, y);
    }
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
      println!("Color: R:{}, G:{}, B:{}", r, g, b);
    }
  }
}

fn main() {
  process_message(Message::Move { x: 10, y: 20 });
  process_message(Message::Write(String::from("Hello!")));
}

Joker Örüntü `_`

Özel _ (alt çizgi) örüntüsü bir genel eşleştirici görevi görür. Her değerle eşleşir ve o değeri bir değişkene bağlamaz.

Kapsamlılığı sağlamak için tüm olasılıkları kapsamanız gerektiğinde, ancak belirli bir kolla eşleşen değeri önemsemediğinizde kullanışlıdır.

fn main() {
  let some_value = Some(5);
  let absent_value: Option<i32> = None;

  match some_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("Something else!"), // Matches None too
  }

  match absent_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("No value here!"),
  }
}

Tek Örüntüler için `if let`

Bazen yalnızca belirli bir örüntüyü eşleştirmek, diğerlerini yok saymak istersiniz. Bu durumlarda if let, tam bir match ifadesine göre daha kısa bir seçenektir.

Temelde şöyle der: "Bu örüntü eşleşirse bunu yap; aksi takdirde hiçbir şey yapma (veya isteğe bağlı bir else bloğu çalıştır).".

fn main() {
  let config_max = Some(3u8);
  let none_value: Option<u8> = None;

  if let Some(max) = config_max {
    println!("Max configured to be: {}", max);
  }

  if let Some(val) = none_value {
    println!("This won't print: {}", val);
  } else {
    println!("No value found!");
  }
}

Koşullu Döngüler için `while let`

if let'e benzer şekilde while let, bir örüntü eşleşmeye devam ettiği sürece döngü kurmanızı sağlar.

Bu, Vec gibi koleksiyonlardan öğeleri işlerken, eşleşen başka öğe kalmayana kadar devam etmek istediğinizde (örneğin pop() None döndürene kadar) son derece kullanışlıdır.

fn main() {
  let mut stack = vec![1, 2, 3];

  while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
  }

  println!("Stack is empty now.");
}

Eşleme Koruyucuları: Koşul Ekleme

Bir match koluna eşleme koruyucusu adı verilen ek bir if koşulu ekleyebilirsiniz. Bu kolun çalışması için hem örüntünün eşleşmesi AND koruyucu koşulunun doğru olması gerekir.

Bu, daha fazla numaralandırma varyantı oluşturmaya gerek kalmadan bir örüntü içinde daha ayrıntılı denetim sağlar.

fn main() {
  let num = Some(4);

  match num {
    Some(x) if x % 2 == 0 => println!("Even number: {}", x),
    Some(x) if x < 5 => println!("Small odd number: {}", x),
    Some(x) => println!("Any other number: {}", x),
    None => println!("No number"),
  }
}

Örüntü Eşleme Görevi

Aşağıdaki Rust kod parçacığını düşünün. match ifadesi ve çıktısı hakkındaki aşağıdaki ifadelerden hangileri TRUE'dur?

enum Status {
  Loading,
  Success(u32),
  Error(String),
}

fn process_status(s: Status) {
  match s {
    Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
    Status::Success(code) => println!("Success with code: {}", code),
    Status::Error(msg) => println!("Failed: {}", msg),
    _ => println!("Status unknown or loading..."),
  }
}

fn main() {
  process_status(Status::Success(201));
  process_status(Status::Error(String::from("Network issue")));
  process_status(Status::Loading);
  process_status(Status::Success(200));
}

Tekrar: Örüntülerde Ustalaşma

Rust'ta örüntü eşlemenin inanılmaz gücünü keşfettiniz! Bu, açık, kısa ve güvenli kod yazmanın temel kavramlarından biridir.

match ifadeleri, veri yapısına göre kapsamlı akış denetimi sağlar.
Değişmez değerleri, aralıkları ve jokerleri (_) eşleyebilirsiniz.
Yapıyı çözme, değerleri doğrudan yapılardan ve numaralandırmalardan çıkarmanızı sağlar.
if let ve while let, tek örüntüleri eşlemenin kısa yollarını sunar.
Eşleme koruyucuları, match kollarına koşullu mantık ekler.

Bu örüntüleri uygulamaya devam edin; deyimsel Rust için gereklidirler!

Sıkça Sorulan Sorular

“Güçlü Örüntü Eşleştirme” dersi ücretsiz mi?

Evet — “Güçlü Örüntü Eşleştirme” 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 3 dersten oluşur.

“Güçlü Örüntü Eşleştirme” dersinde ne öğreneceğim?

Veri varyantlarını özlü ve eksiksiz biçimde ele almak için `match` ifadelerinde ve diğer örüntü eşleştirme yapılarında ustalaşın. 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, 3 dersinin 3. dersidir.

“Güçlü Örüntü Eşleştirme” 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