مالکیت و قرض گرفتن در Rust برای برنامه‌نویسان پایتون


چرا Rust برای پایتون‌کارها عجیب به نظر می‌رسد؟ #

اگر سال‌ها با پایتون کار کرده باشید و اولین برنامهٔ Rust خود را بنویسید، احتمالاً خیلی زود با خطایی شبیه این روبه‌رو می‌شوید:

error[E0382]: borrow of moved value: `name`

در پایتون هیچ‌وقت چنین چیزی ندیده‌اید. یک متغیر را به تابع می‌دهید، بعد دوباره از آن استفاده می‌کنید و همه‌چیز کار می‌کند. پس چرا Rust این‌قدر سخت‌گیر است؟

پاسخ در مفهومی است که Rust را از تقریباً همهٔ زبان‌های دیگر متمایز می‌کند: مالکیت (Ownership). در این مطلب، این مفهوم را از دید یک برنامه‌نویس پایتون توضیح می‌دهیم: پایتون پشت صحنه چه می‌کند، Rust چه کار متفاوتی انجام می‌دهد و چرا این سخت‌گیری در نهایت به نفع شماست.

پایتون پشت صحنه چه می‌کند؟ #

در پایتون، متغیرها برچسب‌هایی روی اشیاء هستند، نه جعبه‌هایی که مقدار را نگه می‌دارند:

python_refs.pypython
a = [1, 2, 3]
b = a          # b و a به یک شیء اشاره می‌کنند
b.append(4)
print(a)       # [1, 2, 3, 4]
print(a is b)  # True

اگر تفاوت is و == برایتان مبهم است، مطلب تفاوت is و == در پایتون را بخوانید.

پایتون برای مدیریت حافظه از شمارش ارجاع (reference counting) و یک garbage collector برای چرخه‌ها استفاده می‌کند. هر شیء می‌داند چند متغیر به آن اشاره می‌کنند و وقتی این عدد به صفر برسد، حافظه آزاد می‌شود. این راحت است، اما هزینه دارد:

  • هر بار که ارجاعی ساخته یا حذف می‌شود، شمارنده باید به‌روز شود.
  • چند ارجاع تغییرپذیر به یک شیء، در کد هم‌روند می‌تواند به data race منجر شود؛ یکی از دلایلی که پایتون سال‌ها به GIL نیاز داشت.
  • زمان دقیق آزادسازی حافظه همیشه قابل پیش‌بینی نیست.

سه قانون مالکیت در Rust #

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

  1. هر مقدار در Rust یک مالک (owner) دارد.
  2. در هر لحظه فقط یک مالک می‌تواند وجود داشته باشد.
  3. وقتی مالک از محدودهٔ خود (scope) خارج شود، مقدار حذف (drop) می‌شود.
scope.rsrust
fn main() {
    {
        let s = String::from("سلام");   // s مالک رشته است
        println!("{s}");
    }                                   // s از scope خارج شد؛ حافظه آزاد شد
    // println!("{s}");  // خطا: s دیگر وجود ندارد
}

نکتهٔ کلیدی: کامپایلر دقیقاً می‌داند حافظه کجا آزاد می‌شود و هیچ هزینهٔ زمان اجرایی برای شمارش ارجاع یا GC پرداخت نمی‌شود.

Move: انتقال مالکیت #

انتقال مالکیت یک مقدار از متغیر اول به متغیر دوم

حالا به همان خطای اول برگردیم:

move.rsrust
fn greet(name: String) {
    println!("سلام {name}");
}

fn main() {
    let name = String::from("علی");
    greet(name);           // مالکیت به تابع greet منتقل شد
    println!("{name}");    // خطا: borrow of moved value
}

وقتی name را به greet می‌دهید، مالکیت منتقل (move) می‌شود. بعد از پایان greet، رشته آزاد می‌شود و name در main دیگر معتبر نیست. Rust اجازه نمی‌دهد از مقداری که دیگر مال شما نیست استفاده کنید؛ این همان چیزی است که در C به use-after-free معروف است و یکی از رایج‌ترین منشأهای آسیب‌پذیری‌های امنیتی است.

مقایسه با پایتون:

پایتون Rust
b = a برای لیست/رشته دو برچسب برای یک شیء مالکیت از a به b منتقل می‌شود
استفاده از a بعد از آن مجاز خطای کامپایل
کپی واقعی copy.deepcopy(a) a.clone()
آزادسازی حافظه وقتی شمارنده صفر شود وقتی مالک از scope خارج شود

Copy: استثنای انواع ساده #

انواع ساده‌ای که اندازهٔ ثابت دارند و روی stack هستند (اعداد صحیح، اعشاری، bool، char) ویژگی Copy دارند و به‌جای move، کپی می‌شوند:

rust
let x = 5;
let y = x;          // کپی شد
println!("{x} {y}"); // هر دو معتبرند

clone: وقتی واقعاً کپی می‌خواهید #

rust
let name = String::from("علی");
greet(name.clone());   // یک کپی کامل منتقل می‌شود
println!("{name}");    // name اصلی هنوز معتبر است

نکته

clone() همیشه یک کپی واقعی (و احتمالاً پرهزینه) روی heap می‌سازد. در کد Rust، دیدن clone() نشانه‌ای صریح از هزینه است؛ برخلاف پایتون که کپی و ارجاع از ظاهر کد قابل تشخیص نیستند.

Borrowing: قرض گرفتن بدون مالکیت #

در بیشتر موارد نمی‌خواهید مالکیت را منتقل کنید؛ فقط می‌خواهید تابع به مقدار نگاه کند. اینجا ارجاع (reference) یا قرض گرفتن وارد می‌شود:

borrow.rsrust
fn greet(name: &String) {
    println!("سلام {name}");
}

fn main() {
    let name = String::from("علی");
    greet(&name);          // فقط قرض داده شد
    println!("{name}");    // name هنوز مال ماست
}

علامت & یعنی «یک ارجاع فقط‌خواندنی». تابع greet مالک نیست، پس وقتی تمام شد چیزی آزاد نمی‌شود.

یادداشت

در کد واقعی Rust معمولاً پارامتر را &str تعریف می‌کنند، نه &String، چون &str هم رشته‌های String و هم رشته‌های ثابت را می‌پذیرد.

ارجاع تغییرپذیر #

برای تغییر مقدار از طریق ارجاع، از &mut استفاده می‌کنید:

rust
fn add_suffix(s: &mut String) {
    s.push_str(" جان");
}

fn main() {
    let mut name = String::from("علی");
    add_suffix(&mut name);
    println!("{name}");  // علی جان
}

قانون طلایی Borrow Checker #

چند ارجاع فقط‌خواندنی همزمان، یا فقط یک ارجاع تغییرپذیر

این مهم‌ترین قانون Rust است که borrow checker در زمان کامپایل بررسی می‌کند:

مهم

در هر لحظه می‌توانید یا هر تعداد ارجاع فقط‌خواندنی (&T) داشته باشید، یا دقیقاً یک ارجاع تغییرپذیر (&mut T)؛ نه هر دو با هم. و ارجاع‌ها همیشه باید معتبر باشند.

rules.rsrust
let mut v = vec![1, 2, 3];

let first = &v[0];      // ارجاع فقط‌خواندنی
v.push(4);              // خطا: نیاز به ارجاع تغییرپذیر در حالی که first زنده است
println!("{first}");

چرا این ممنوع است؟ چون push ممکن است وکتور را به جای بزرگ‌تری در حافظه منتقل کند و first به حافظهٔ آزادشده اشاره کند. در پایتون، معادل این مشکل را در قالب خطای «تغییر لیست حین پیمایش» دیده‌اید:

python
items = [1, 2, 3]
for x in items:
    if x == 2:
        items.remove(x)   # رفتار غیرمنتظره، بدون خطا

پایتون در این حالت چیزی نمی‌گوید و فقط نتیجهٔ غلط می‌دهد. Rust همین دسته از باگ‌ها را قبل از اجرا متوقف می‌کند.

Lifetimeها در یک نگاه #

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

rust
fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() { a } else { b }
}

'a می‌گوید «ارجاع خروجی حداقل به اندازهٔ کوتاه‌ترینِ دو ورودی معتبر است». خبر خوب: در بیشتر کدها کامپایلر lifetimeها را خودش استنتاج می‌کند و نیازی به نوشتن آن‌ها نیست.

نگاشت ذهنی برای پایتون‌کارها #

مفهوم پایتون معادل تقریبی در Rust
پاس دادن یک شیء به تابع &T (قرض فقط‌خواندنی)
تابعی که شیء را تغییر می‌دهد &mut T
تابعی که شیء را «نگه می‌دارد» پاس دادن با مالکیت (T)
copy.deepcopy .clone()
چند ارجاع به یک شیء مشترک Rc<T> یا در چندنخی Arc<T>
شیء مشترک تغییرپذیر Rc<RefCell<T>> یا Arc<Mutex<T>>

نکات عملی برای شروع #

  • پیام‌های خطای کامپایلر Rust را کامل بخوانید؛ معمولاً راه‌حل را پیشنهاد می‌دهند.
  • پیش‌فرض پارامترها را &T بگذارید و فقط وقتی لازم است مالکیت بگیرید.
  • در شروع کار از clone() نترسید؛ اول کد درست، بعد بهینه.
  • برای رشته‌ها در پارامترها &str و برای لیست‌ها &[T] را ترجیح دهید.
  • فصل ۴ کتاب رسمی Rust را حداقل دو بار بخوانید.
چرا Rust به‌جای این قوانین از GC استفاده نمی‌کند؟

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

آیا پایتون‌کارها واقعاً به Rust نیاز دارند؟

نه همیشه؛ اما بسیاری از ابزارهای محبوب پایتون مثل uv، Ruff، Polars و Pydantic v2 با Rust نوشته شده‌اند. با PyO3 و maturin می‌توانید بخش‌های پرهزینهٔ کد پایتون خود را با Rust بنویسید. مطلب آشنایی با uv را برای نمونه‌ای از این ابزارها ببینید.

جمع‌بندی #

مالکیت و قرض گرفتن در ابتدا شبیه دیواری بین شما و برنامهٔ کارا به نظر می‌رسند، اما در واقع همان قوانینی هستند که برنامه‌نویسان باتجربهٔ C و C++ سال‌ها در ذهنشان رعایت می‌کردند؛ با این تفاوت که حالا کامپایلر آن‌ها را برایتان بررسی می‌کند. با سه قانون مالکیت، تفاوت move و copy، و قانون طلایی «چند خواننده یا یک نویسنده»، بخش بزرگی از مسیر یادگیری Rust را طی کرده‌اید.

این پست چطور بود؟

پست‌های مرتبط