Programming Rust

1. سیستم مالکیت در Rust: ایمنی حافظه بدون جمع‌آوری زباله

شرط‌بندی جسورانه Rust این است که حتی با وجود این محدودیت‌ها، زبان را به اندازه کافی انعطاف‌پذیر برای تقریباً هر وظیفه‌ای خواهید یافت و مزایای آن—حذف دسته‌های گسترده‌ای از اشکالات مدیریت حافظه و همزمانی—توجیه‌کننده تطبیقاتی خواهد بود که باید در سبک خود ایجاد کنید.

مالکیت و قرض‌گیری. سیستم مالکیت در Rust رویکردی نوین به مدیریت حافظه است که ایمنی حافظه را بدون نیاز به جمع‌آوری زباله تضمین می‌کند. هر مقدار در Rust یک مالک واحد دارد و مالکیت می‌تواند بین متغیرها منتقل (جابجا) شود. وقتی یک مقدار از دامنه خارج می‌شود، Rust به‌طور خودکار حافظه آن را آزاد می‌کند.

ارجاعات و طول عمرها. Rust اجازه می‌دهد ارجاعاتی به مقادیر قرض گرفته شود که می‌توانند به صورت مشترک (&T) یا قابل تغییر (&mut T) باشند. بررسی‌کننده قرض قوانین سخت‌گیرانه‌ای را برای جلوگیری از رقابت داده و خطاهای استفاده پس از آزادسازی اعمال می‌کند:

• تنها یک ارجاع قابل تغییر یا هر تعداد ارجاع مشترک به یک مقدار در یک زمان
• ارجاعات نباید بیشتر از مرجع‌های خود زنده بمانند

این قوانین در زمان کامپایل اعمال می‌شوند و دسته‌های کاملی از اشکالات را بدون سربار زمان اجرا حذف می‌کنند.

2. ساختارها و شمارش‌ها: بلوک‌های سازنده برای انواع سفارشی

درست مانند هر جای دیگر در زبان، اگر یک بسته‌بندی بخواهد مقداری از نوع قابل کپی، مانند i32، را جابجا کند، مقدار را کپی می‌کند.

ساختارها برای گروه‌بندی داده‌ها. ساختارها در Rust به شما اجازه می‌دهند تا با گروه‌بندی داده‌های مرتبط، انواع سفارشی ایجاد کنید. آن‌ها در سه نوع ارائه می‌شوند:

• ساختارهای با فیلد نام‌گذاری شده: رایج‌ترین، با فیلدهای نام‌گذاری شده
• ساختارهای توده‌ای: فیلدهای بدون نام، مفید برای بسته‌بندی‌های ساده
• ساختارهای شبیه واحد: بدون فیلد، مفید برای پیاده‌سازی صفات

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

قابلیت‌های تطبیق الگو در Rust، به‌ویژه با عبارت match، کار با شمارش‌ها را بسیار راحت و ایمن می‌کند.

3. صفات: تعریف رفتار مشترک

صفات برداشت Rust از رابط‌ها یا کلاس‌های پایه انتزاعی هستند.

تعریف رفتار مشترک. صفات در Rust مجموعه‌ای از روش‌ها را تعریف می‌کنند که انواع می‌توانند پیاده‌سازی کنند، مشابه رابط‌ها در زبان‌های دیگر. آن‌ها اجازه می‌دهند تا انتزاعی بر رفتارهایی که انواع می‌توانند به اشتراک بگذارند، ایجاد شود و چندریختی و استفاده مجدد از کد را ممکن می‌سازند.

اشیاء صفت و جنریک‌ها. Rust دو روش اصلی برای استفاده از صفات ارائه می‌دهد:

1. اشیاء صفت: اجازه چندریختی زمان اجرا با کمی سربار عملکرد
2. صفات جنریک: ارائه انتزاع‌های بدون هزینه از طریق تک‌ریخت‌سازی

صفات همچنین می‌توانند انواع مرتبط و پیاده‌سازی‌های روش پیش‌فرض داشته باشند، که آن‌ها را به ابزاری قدرتمند برای طراحی کد انعطاف‌پذیر و قابل استفاده مجدد تبدیل می‌کند.

4. مدیریت خطا: نتایج و وحشت‌ها

Rust استثنا ندارد. در عوض، توابعی که ممکن است شکست بخورند، نوع بازگشتی دارند که این موضوع را بیان می‌کند.

نتایج برای خطاهای مورد انتظار. Rust از نوع Result<T, E> برای مدیریت خطاهای مورد انتظار استفاده می‌کند. این شمارش دو واریانت دارد:

• Ok(T): نتیجه موفقیت‌آمیز را نگه می‌دارد
• Err(E): اطلاعات خطا را شامل می‌شود

عملگر ? شکر نحوی برای انتشار خطاها فراهم می‌کند و مدیریت خطا را مختصر و صریح می‌سازد.

وحشت‌ها برای خطاهای غیرمنتظره. برای خطاهای غیرمنتظره یا موقعیت‌هایی که بازیابی غیرممکن است، Rust از وحشت‌ها استفاده می‌کند. وحشت‌ها پشته را باز می‌کنند، مخرب‌ها را فراخوانی می‌کنند و منابع را آزاد می‌کنند. آن‌ها برای:

• خطاهای برنامه‌نویسی (مثلاً دسترسی خارج از محدوده)
• موقعیت‌هایی که ادامه دادن غیرممکن یا خطرناک است

این رویکرد دوگانه تشویق به مدیریت خطاهای مورد انتظار به‌طور شایسته می‌کند در حالی که هنوز مکانیزمی برای موقعیت‌های غیرقابل بازیابی فراهم می‌کند.

5. ماژول‌ها و جعبه‌ها: سازماندهی و اشتراک‌گذاری کد

برنامه‌های Rust از جعبه‌ها ساخته شده‌اند.

ماژول‌ها برای سازماندهی کد. ماژول‌ها در Rust راهی برای سازماندهی کد درون یک جعبه فراهم می‌کنند. آن‌ها می‌توانند:

• در یک فایل تعریف شوند
• در چندین فایل پخش شوند
• درون ماژول‌های دیگر تو در تو شوند

ماژول‌ها حریم خصوصی آیتم‌ها را کنترل می‌کنند و به شما اجازه می‌دهند رابط‌های عمومی تعریف کنید در حالی که جزئیات پیاده‌سازی را خصوصی نگه می‌دارید.

جعبه‌ها برای اشتراک‌گذاری کد. جعبه‌ها واحد کامپایل و توزیع در Rust هستند:

• جعبه‌های کتابخانه: عملکردی برای استفاده توسط جعبه‌های دیگر فراهم می‌کنند
• جعبه‌های باینری: اجرایی تولید می‌کنند

مدیر بسته Cargo مدیریت وابستگی‌ها، ساخت پروژه‌ها و انتشار جعبه‌ها به crates.io، رجیستری بسته جامعه Rust، را آسان می‌کند.

6. تکرارگرها: انتزاع‌های قدرتمند برای توالی‌ها

تکرارگرهای Rust با دقت طراحی شده‌اند تا اطمینان حاصل شود که کامپایلر می‌تواند آن‌ها را به کد ماشین عالی ترجمه کند.

ارزیابی تنبل. تکرارگرها در Rust تنبل هستند، به این معنی که تنها زمانی کار انجام می‌دهند که مصرف شوند. این اجازه می‌دهد تا عملیات‌ها به‌طور کارآمد زنجیره شوند بدون ایجاد مجموعه‌های میانی.

روش‌های قدرتمند. صفت Iterator مجموعه‌ای غنی از روش‌ها برای کار با توالی‌ها فراهم می‌کند:

• آداپتورها: تکرارگرها را تغییر می‌دهند (مثلاً map، filter، zip)
• مصرف‌کنندگان: نتایج نهایی تولید می‌کنند (مثلاً collect، fold، sum)

این روش‌ها اغلب به کدی خواناتر و کارآمدتر نسبت به حلقه‌های صریح منجر می‌شوند.

انتزاع بدون هزینه. از طریق بهینه‌سازی‌های کامپایلر، زنجیره‌های تکرارگر اغلب به کدی به اندازه حلقه‌های دست‌نویس کارآمد کامپایل می‌شوند و انتزاع‌های سطح بالا را بدون جریمه عملکردی فراهم می‌کنند.

7. بسته‌بندی‌ها: انواع تابع‌مانند انعطاف‌پذیر و کارآمد

بسته‌بندی‌های Rust برای سریع بودن طراحی شده‌اند: سریع‌تر از اشاره‌گرهای تابع، به اندازه کافی سریع که می‌توانید حتی در کد حساس به عملکرد از آن‌ها استفاده کنید.

نحو و ضبط. بسته‌بندی‌ها در Rust توابع ناشناسی هستند که می‌توانند مقادیر را از محیط خود ضبط کنند. آن‌ها نحوی مختصر دارند و می‌توانند با:

• ارجاع: مقادیر را قرض بگیرند
• ارجاع قابل تغییر: مقادیر را به‌طور قابل تغییر قرض بگیرند
• مقدار: مالکیت مقادیر را بگیرند (با استفاده از کلمه کلیدی move)

صفات بسته‌بندی. Rust سه صفت برای بسته‌بندی‌ها تعریف می‌کند:

1. Fn: می‌تواند چندین بار بدون تغییر مقادیر ضبط شده فراخوانی شود
2. FnMut: می‌تواند مقادیر ضبط شده را تغییر دهد
3. FnOnce: مقادیر ضبط شده را مصرف می‌کند، تنها یک بار می‌تواند فراخوانی شود

این صفات کنترل دقیق بر رفتار بسته‌بندی‌ها را ممکن می‌سازند و پیاده‌سازی‌های کارآمد را امکان‌پذیر می‌کنند.

8. همزمانی: موازی‌سازی ایمن و کارآمد

یک برنامه همزمان Rust که از کد ناایمن اجتناب می‌کند، به‌طور ساختاری از رقابت داده‌ها آزاد است.

همزمانی بی‌خوف. سیستم‌های مالکیت و نوع در Rust از رقابت داده‌ها در زمان کامپایل جلوگیری می‌کنند و برنامه‌نویسی همزمان را بسیار ایمن‌تر از بسیاری از زبان‌های دیگر می‌سازند.

ابتدایی‌های رشته‌ای. Rust ابزارهای متعددی برای برنامه‌نویسی همزمان فراهم می‌کند:

• std::thread: برای ایجاد رشته‌های سطح سیستم‌عامل
• std::sync: ابتدایی‌های همگام‌سازی (مثلاً Mutex، Arc)
• کانال‌ها: برای ارسال پیام بین رشته‌ها

غیرهمزمان/انتظار. Rust همچنین از برنامه‌نویسی غیرهمزمان با نحو async/await خود پشتیبانی می‌کند و اجازه می‌دهد تا بسیاری از وظایف همزمان را بدون سربار رشته‌های سیستم‌عامل به‌طور کارآمد مدیریت کنید.

9. اشاره‌گرهای هوشمند: مدیریت حافظه پیشرفته

Rc و Arc: مالکیت مشترک

فراتر از اشاره‌گرهای خام. Rust چندین نوع اشاره‌گر هوشمند فراهم می‌کند که فراتر از آنچه اشاره‌گرهای خام ارائه می‌دهند، عملکرد اضافه می‌کنند:

• Box<T>: برای تخصیص در پشته
• Rc<T>: مالکیت مشترک شمارش‌شده
• Arc<T>: مالکیت مشترک شمارش‌شده اتمی (ایمن در برابر رشته)
• RefCell<T>: برای تغییرپذیری داخلی

ایمنی و راحتی. این اشاره‌گرهای هوشمند انتزاع‌های ایمنی برای الگوهای رایج در برنامه‌نویسی سیستم‌ها فراهم می‌کنند، مانند:

• اعزام پویا
• مالکیت مشترک
• تغییرپذیری داخلی

آن‌ها اجازه می‌دهند تا سناریوهای مدیریت حافظه پیچیده‌تری را در حالی که هنوز تضمین‌های ایمنی Rust را حفظ می‌کنند، مدیریت کنید.

آخرین به‌روزرسانی:: August 12, 2024