برنامه نویسی

ویژگی در زنگ زدگی توضیح داده شده: از اصول گرفته تا استفاده پیشرفته

ek3nk4r 2025-03-02

0 4 خواندن این مطلب 7 دقیقه زمان میبرد

ویژگی در زنگ زدگی توضیح داده شده: از اصول گرفته تا استفاده پیشرفته

پیشنهاد ویژه

خرید فالوور واقعی خرید لایک اینستاگرام خرید ویو اینستاگرام خرید فالوور اینستاگرام

پوشش

فهرست مطالب

صفت چیست؟

در زنگ زدگی ، یک ویژگی راهی برای تعریف رفتار مشترک است. این امکان را به ما می دهد تا روش هایی را که یک نوع باید پیاده سازی کند ، مشخص کنیم و از این طریق پلی مورفیسم و انتزاع رابط را فعال کنیم.

در اینجا یک مثال ساده وجود دارد که یک ویژگی به نام را تعریف می کند Printable، که شامل روشی است print:

trait Printable {
    fn print(&self);
}

تعریف و اجرای صفات

برای تعریف یک صفت ، ما از trait کلمه کلیدی ، به دنبال آن نام صفت و یک جفت براکت فرفری. در داخل براکت های فرفری ، روش هایی را که صفت شامل می شود تعریف می کنیم.

برای اجرای یک صفت ، ما از impl کلمه کلیدی ، به دنبال آن نام صفت ، for کلمه کلیدی و نوعی که ما در حال اجرای صفت هستیم. در داخل براکت های فرفری ، ما باید برای کلیه روشهای تعریف شده در صفت پیاده سازی کنیم.

در زیر مثالی آورده شده است که نحوه اجرای قبلاً تعریف شده را نشان می دهد Printable صفت برای i32 نوع:

impl Printable for i32 {
    fn print(&self) {
        println!("{}", self);
    }
}

در این مثال ، ما Printable صفت برای i32 نوع و اجرای ساده ای از print روش

وراثت و ترکیب صفت

زنگ زدگی به ما اجازه می دهد تا صفات موجود را از طریق وراثت و ترکیب گسترش دهیم. وراثت ما را قادر می سازد از روشهای تعریف شده در یک ویژگی والدین در یک ویژگی جدید استفاده کنیم ، در حالی که ترکیب به ما امکان می دهد از چندین ویژگی مختلف در یک ویژگی جدید استفاده کنیم.

در اینجا مثالی آورده شده است که نحوه استفاده از وراثت را برای گسترش نشان می دهد Printable صفت:

trait PrintableWithLabel: Printable {
    fn print_with_label(&self, label: &str) {
        print!("{}: ", label);
        self.print();
    }
}

در این مثال ، ما یک ویژگی جدید به نام تعریف می کنیم PrintableWithLabel، که از Printable صفت این بدان معنی است که هر نوع اجرا PrintableWithLabel همچنین باید پیاده سازی کند Printableبشر علاوه بر این ، ما یک روش جدید ارائه می دهیم ، print_with_label، که قبل از چاپ مقدار یک برچسب را چاپ می کند.

در اینجا مثال دیگری آورده شده است که نحوه استفاده از ترکیب را برای تعریف یک ویژگی جدید نشان می دهد:

trait DisplayAndDebug: Display + Debug {}

در این مثال ، ما یک ویژگی جدید را تعریف می کنیم DisplayAndDebug، که از دو صفت از کتابخانه استاندارد تشکیل شده است: Display وت Debugبشر این بدان معنی است که هر نوع اجرا DisplayAndDebug همچنین باید هر دو را پیاده سازی کند Display وت Debugبشر

صفات به عنوان پارامترها و مقادیر بازگشت

Rust به ما اجازه می دهد تا از صفات به عنوان پارامترها و مقادیر بازگشت در امضاهای عملکرد استفاده کنیم و کد ما را عمومی تر و انعطاف پذیر تر می کند.

در اینجا مثالی آورده شده است که نحوه استفاده از آن را نشان می دهد PrintableWithLabel صفت به عنوان یک پارامتر عملکرد:

fn print_twice<T: PrintableWithLabel>(value: T) {
    value.print_with_label("First");
    value.print_with_label("Second");
}

در این مثال ، ما تابعی به نام را تعریف می کنیم print_twice این یک پارامتر عمومی می گیرد Tبشر پارامتر باید پیاده سازی کند PrintableWithLabel صفت در داخل بدنه عملکرد ، ما تماس می گیریم print_with_label روش روی پارامتر.

در اینجا مثالی آورده شده است که نحوه استفاده از یک صفت به عنوان یک مقدار بازگشت عملکرد را نشان می دهد:

fn get_printable() -> impl Printable {
    42
}

با این حال ، fn get_printable() -> impl Printable { 42 } نادرست است زیرا 42 یک عدد صحیح است و پیاده سازی نمی کند Printable صفت

رویکرد صحیح بازگشت نوعی است که Printable صفت به عنوان مثال ، اگر ما پیاده سازی کنیم Printable برای i32 نوع ، ما می توانیم بنویسیم:

impl Printable for i32 {
    fn print(&self) {
        println!("{}", self);
    }
}

fn get_printable() -> impl Printable {
    42
}

در این مثال ، ما Printable صفت برای i32 یک اجرای ساده از print روش سپس ، در get_printable عملکرد ، ما i32 ارزش 42بشر از آنجا که i32 نوع پیاده سازی Printable صفت ، این کد صحیح است.

اشیاء صفت و اعزام استاتیک

در زنگ زدگی ، ما می توانیم از دو طریق به پلی مورفیسم دست یابیم: اعزام استاتیک وت اعزام پویابشر

اعزام استاتیک با استفاده از Generics حاصل می شود. هنگامی که ما از پارامترهای عمومی استفاده می کنیم ، کامپایلر برای هر نوع ممکن کد جداگانه تولید می کند. این اجازه می دهد تا تماس های عملکردی در زمان کامپایل تعیین شوند.
اعزام پویا با استفاده از اشیاء صفتبشر هنگامی که ما از اشیاء صفت استفاده می کنیم ، کامپایلر یک کد با هدف کلی تولید می کند که می تواند هر نوع اجرای صفت را اداره کند. این اجازه می دهد تا تماس های عملکرد در زمان اجرا تعیین شود.

در اینجا مثالی آورده شده است که نشان می دهد چگونه می توان از اعزام استاتیک و اعزام پویا استفاده کرد:

fn print_static<T: Printable>(value: T) {
    value.print();
}

fn print_dynamic(value: &dyn Printable) {
    value.print();
}

در این مثال:

print_static از a استفاده می کند پارامتر عمومی T، که باید Printable صفت هنگامی که این عملکرد نامیده می شود ، کامپایلر برای هر نوع که به آن منتقل می شود ، کد جداگانه ای تولید می کند (اعزام استاتیک).
print_dynamic از a استفاده می کند شیء صفت (&dyn Printable) به عنوان یک پارامتر این امکان اعزام پویا را فراهم می کند و به عملکرد امکان پردازش هر نوع اجرای آن را می دهد Printable صفت

انواع مرتبط و محدودیت های عمومی

در زنگ زدگی ، ما می توانیم استفاده کنیم انواع مرتبط وت محدودیت های عمومی برای تعریف صفات پیچیده تر.

انواع مرتبط

انواع مرتبط به ما امکان می دهد نوعی را تعریف کنیم که با یک ویژگی خاص همراه باشد. این برای تعریف روش هایی که به یک نوع مرتبط بستگی دارد مفید است.

در اینجا نمونه ای از ویژگی های نامگذاری شده است Add با استفاده از یک نوع مرتبط:

trait Add<RHS = Self> {
    type Output;

    fn add(self, rhs: RHS) -> Self::Output;
}

در این مثال:

ما یک صفت به نام را تعریف می کنیم Addبشر
این شامل یک نوع مرتبط Output، که نشان دهنده نوع بازگشت add روش
در RHS پارامتر عمومی سمت راست عملکرد اضافی را مشخص می کند ، به طور پیش فرض به Selfبشر

محدودیت های عمومی

محدودیت های عمومی به ما این امکان را می دهد تا مشخص کنیم که یک پارامتر عمومی باید شرایط خاصی را برآورده کند (به عنوان مثال ، یک ویژگی خاص را پیاده سازی کنید).

در اینجا مثالی آورده شده است که نحوه استفاده از محدودیت های عمومی را در یک صفت نامگذاری شده نشان می دهد SummableIterator:

use std::iter::Sum;

trait SummableIterator: Iterator
where
    Self::Item: Sum,
{
    fn sum(self) -> Self::Item {
        self.fold(Self::Item::zero(), |acc, x| acc + x)
    }
}

در این مثال:

ما یک صفت را تعریف می کنیم SummableIterator این استاندارد را گسترش می دهد Iterator صفت
ما از a استفاده می کنیم محدودیت عمومی (where Self::Item: Sum) برای مشخص کردن Item نوع تکرار کننده باید پیاده سازی کند Sum صفت
در sum روش کل کل عناصر موجود در تکرار را محاسبه می کند.

مثال: اجرای پلی مورفیسم با استفاده از صفات

در اینجا مثالی آورده شده است که نحوه استفاده از آن را نشان می دهد PrintableWithLabel صفت برای دستیابی به پلی مورفیسم:

struct Circle {
    radius: f64,
}

impl Printable for Circle {
    fn print(&self) {
        println!("Circle with radius {}", self.radius);
    }
}

impl PrintableWithLabel for Circle {}

struct Square {
    side: f64,
}

impl Printable for Square {
    fn print(&self) {
        println!("Square with side {}", self.side);
    }
}

impl PrintableWithLabel for Square {}

fn main() {
    let shapes: Vec<Box<dyn PrintableWithLabel>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Square { side: 2.0 }),
    ];

    for shape in shapes {
        shape.print_with_label("Shape");
    }
}

در این مثال:

ما دو ساختار را تعریف می کنیم: Circle وت Squareبشر
هر دو ساختار Printable وت PrintableWithLabel ویژگی ها
در main عملکرد ، ما یک بردار ایجاد می کنیم shapes که فروشگاه ها اشیاء صفت (Box).
ما بیش از shapes بردار و تماس print_with_label در هر شکل

از آنجا که هر دو Circle وت Square اجرا PrintableWithLabel، آنها می توانند به عنوان ذخیره شوند اشیاء صفت در یک بردار وقتی تماس می گیریم print_with_label، کامپایلر به صورت پویا تعیین می کند که بر اساس نوع واقعی شیء ، کدام روش را فراخوانی می کند.

اینگونه صفات فعال می شوند چند شکل در زنگ زدگی امیدوارم این مقاله به شما کمک کند تا درک کنید ویژگی بهتر