Learn Rust Coding · Ders

Özellik Tanımlama

Paylaşılan davranış

Özellik Tanımlama, 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.

Özellik Nedir?

Bir özellik, ortak davranışı, yani bir türün uygulayabileceği yöntemler kümesini tanımlar. Diğer dillerdeki arayüze benzer.

Özellikler, farklı türlerin ortak bir sözleşme üzerinde anlaşmasını sağlar.

Özellik Tanımlama

trait anahtar sözcüğünü yöntem imzalarının ardından kullanın. İmzalar, uygulayanların neleri sağlaması gerektiğini bildirir.

trait Greet {
    fn hello(&self) -> String;
}

fn main() {
    println!("trait declared");
}

Özellik Uygulama

Yöntemleri sağlamak için impl TraitName for Type kullanın. İmza, özellikle tamamen aynı olmalıdır.

trait Greet {
    fn hello(&self) -> String;
}

struct Dog;

impl Greet for Dog {
    fn hello(&self) -> String {
        String::from("Woof")
    }
}

fn main() {
    let d = Dog;
    println!("{}", d.hello());
}

Birçok Tür, Tek Özellik

Birden fazla tür aynı özelliği, her biri kendi yöntemiyle uygulayabilir. Özellikler, ilgisiz türlerdeki davranışı böyle birleştirir.

trait Greet { fn hello(&self) -> String; }

struct Dog;
struct Cat;

impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }

fn main() {
    println!("{}", Dog.hello());
    println!("{}", Cat.hello());
}

İşlev Parametreleri Olarak Özellikler

impl Trait söz dizimi, özelliği uygulayan her türü kabul eder. İşlev, somut türü bilmeden aynı şekilde çalışır.

trait Greet { fn hello(&self) -> String; }
struct Dog;
impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }

fn announce(g: &impl Greet) {
    println!("It says: {}", g.hello());
}

fn main() {
    announce(&Dog);
}

Jeneriklerde Özellik Sınırları

Bir özellik sınırı kullanarak jenerik bir türün bir özelliği uygulamasını zorunlu kılabilirsiniz. Böylece işlev içinde özelliğin yöntemleri kullanılabilir.

trait Greet { fn hello(&self) -> String; }
struct Cat;
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }

fn shout<T: Greet>(g: &T) {
    println!("{}!", g.hello().to_uppercase());
}

fn main() {
    shout(&Cat);
}

+ İle Birden Çok Sınır

+ ile aynı anda birkaç özelliğin uygulanmasını zorunlu kılın. Burada bir değer hem özel bir özelliği hem de standart Clone özelliğini uygulamalıdır.

trait Named { fn name(&self) -> String; }

#[derive(Clone)]
struct Item { label: String }

impl Named for Item {
    fn name(&self) -> String { self.label.clone() }
}

fn describe<T: Named + Clone>(t: &T) {
    let copy = t.clone();
    println!("named {}", copy.name());
}

fn main() {
    describe(&Item { label: String::from("box") });
}

where Yan Tümcesi

Çok sayıda sınır olduğunda where yan tümcesi, kısıtlamaları imzanın altına taşıyarak imzanın okunabilir kalmasını sağlar.

use std::fmt::Debug;

fn print_all<T>(items: &[T])
where
    T: Debug,
{
    for it in items {
        println!("{:?}", it);
    }
}

fn main() {
    print_all(&[1, 2, 3]);
}

Özelliklerin Birden Çok Yöntemi Olabilir

Bir özellik birçok yöntem tanımlayabilir. Uygulayanlar, türün eksiksiz bir davranış kümesine sahip olması için gereken tüm yöntemleri sağlamalıdır.

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> String;
}

struct Square { side: f64 }

impl Shape for Square {
    fn area(&self) -> f64 { self.side * self.side }
    fn name(&self) -> String { String::from("square") }
}

fn main() {
    let s = Square { side: 3.0 };
    println!("{} area {}", s.name(), s.area());
}

Özellikler Neden Önemlidir?

Özellikler kalıtım olmadan çok biçimliliği mümkün kılar. Jeneriklere, işleçlerin aşırı yüklenmesine (Add), biçimlendirmeye (Display) ve standart kütüphanenin büyük bölümüne güç verir.

Rust'ın soyutlama modelinin merkezinde yer alırlar.

Tutarlılık Kuralı

Yetim kuralı, bir özellik için bir türü yalnızca özelliğin veya türün sahibiyseniz uygulayabileceğinizi söyler. Bu, derleme birimleri arasında çakışan uygulamaları önler.

Hızlı Kontrol

Özellikleri anlayışınızı sınayın.

Özet

Özellikleri tanımlamayı ve kullanmayı öğrendiniz:

trait ortak davranışı bildirir
impl Trait for Type yöntemleri sağlar
Özellik sınırları (T: Trait, +, where) jenerikleri kısıtlar
Yetim kuralı uygulamaların tutarlı kalmasını sağlar

Sıkça Sorulan Sorular

“Özellik Tanımlama” dersi ücretsiz mi?

Evet — “Özellik Tanımlama” 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.

“Özellik Tanımlama” dersinde ne öğreneceğim?

Paylaşılan davranış 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.

“Özellik Tanımlama” 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