مفاهیم پایه زبان RUST

مفاهیم پایه در زبان Rust 

در این بخش، به مفاهیم پایه‌ای و ضروری زبان Rust می‌پردازیم. این مفاهیم زیربنای درک صحیح از زبان هستند و در تمامی پروژه‌ها تکرار می‌شوند. درک عمیق آن‌ها، پیش‌نیاز ورود به مباحث پیشرفته‌تر مانند مالکیت حافظه، مدیریت خطا، یا async است.

متغیرها و ثوابت

در Rust متغیرها به‌صورت پیش‌فرض غیرقابل تغییر (immutable) هستند. یعنی پس از مقداردهی، دیگر نمی‌توان مقدار آن‌ها را تغییر داد، مگر این که با کلمه‌ی کلیدی mut آن‌ها را قابل تغییر کنیم.

let x = 5;          // غیرقابل تغییر
let mut y = 10;     // قابل تغییر
y = 20;             // مجاز است

تعیین نوع:

Rust می‌تواند نوع متغیر را به‌طور خودکار تشخیص دهد، ولی برای شفافیت می‌توان آن را به‌صراحت مشخص کرد:

let count: i32 = 100;
let name: &str = "Ali";

ثوابت:

ثابت‌ها با کلمه کلیدی const تعریف می‌شوند و همیشه باید نوع آن‌ها مشخص باشد. مقدار آن‌ها در زمان کامپایل تعیین می‌شود و نمی‌توان آن‌ها را درون توابع تعریف کرد.

const PI: f64 = 3.1415;

بازتعریف (Shadowing):

Rust امکان بازتعریف متغیر با همان نام را فراهم می‌کند، حتی با نوع متفاوت:

let spaces = "   ";
let spaces = spaces.len(); // حالا spaces یک عدد است

انواع داده‌های پایه

Rust از انواع داده‌های پایه‌ای متنوعی پشتیبانی می‌کند:

عددی (Integer و Float):

- اعداد صحیح: i8, i16, i32, i64, u8, ...

- اعداد اعشاری: f32, f64

let age: i32 = 25;
let price: f64 = 19.99;

بولی:

let is_logged_in: bool = true;

کاراکتری:

Rust از کاراکترهای یونیکد پشتیبانی می‌کند.

let letter: char = 'A';
let heart: char = '❤';

رشته‌ای:

- &str: رشته ثابت

- String: رشته قابل تغییر

let name = "Ali";                  // &str
let mut full_name = String::from("Ali");
full_name.push_str(" Rezaei");     // حالا "Ali Rezaei"

توابع و محدوده‌ها (Scopes)

تعریف توابع:

توابع با fn تعریف می‌شوند و می‌توانند ورودی و خروجی داشته باشند.

fn greet(name: &str) -> String {
    format!("سلام، {}!", name)
}

فراخوانی توابع:

let message = greet("مریم");
println!("{}", message);

محدوده‌ها و عمر متغیرها:

Rust بر اساس بلوک‌های {} محدوده متغیرها را تعریف می‌کند. متغیرها زمانی که از بلوک خارج می‌شوند، Drop می‌شوند و حافظه‌شان آزاد می‌شود.

{
    let a = 5;
    println!("{}", a);
}
// a دیگر وجود ندارد

مفاهیم Ownership و Borrowing (به‌صورت مقدماتی):

- هر مقدار یک مالک دارد.

- با انتقال مالکیت، مقدار از متغیر قبلی "می‌رود".

- با استفاده از ارجاع (&)، بدون انتقال مالکیت از مقدار استفاده می‌کنیم.

fn print_name(name: &String) {
    println!("{}", name); // فقط وام‌گیری کرده‌ایم، مالکیت منتقل نشده
}

کنترل جریان (Control Flow)

شرط‌ها: if, else

let score = 85;
if score > 90 {
    println!("عالی!");
} else if score > 75 {
    println!("خوب");
} else {
    println!("نیاز به تلاش بیشتر");
}

نکته مهم: در Rust، if خودش یک expression است، یعنی می‌توان از آن مقدار گرفت:

let grade = if score > 90 { "A" } else { "B" };

استفاده از match

match جایگزینی قدرتمند برای switch در سایر زبان‌هاست، و ترکیب آن با enumها بسیار قدرتمند است.

let number = 3;
match number {
    1 => println!("یک"),
    2 | 3 => println!("دو یا سه"),
    _ => println!("دیگر"),
}

حلقه‌ها: loop, while, for

- loop: حلقه‌ی بی‌نهایت

loop {
    println!("بی‌نهایت");
    break;
}
- while:

let mut n = 0;
while n < 5 {
    println!("{}", n);
    n += 1;
}

for:

for i in 0..5 {
    println!("i: {}", i);
}

جمع‌بندی

در این بخش آموختیم که:

- چگونه متغیرها را تعریف کنیم، چه زمانی از mut، const یا بازتعریف استفاده کنیم.

- با انواع داده‌های پایه در Rust آشنا شدیم: عددی، بولی، کاراکتری و رشته‌ای.

- توابع را تعریف و فراخوانی کردیم، و با محدوده‌ی متغیرها و مقدمات مالکیت آشنا شدیم.

- کنترل جریان در Rust را با استفاده از if, match, و حلقه‌های مختلف یاد گرفتیم.

در بخش بعدی، وارد یکی از مهم‌ترین ویژگی‌های Rust خواهیم شد: مالکیت (Ownership)، وام‌گیری (Borrowing) و طول‌عمر (Lifetimes) — مفاهیمی که باعث امنیت حافظه بی‌نظیر Rust می‌شوند.