درک توابع در Rust

توابع Rust دارای تفاوت های ظریف بسیاری است که با زبان های دیگر متفاوت است. در اینجا همه چیز را در مورد نحو آنها بیاموزید.

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

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

تعریف توابع در Rust

توابع Rust بسیار شبیه توابع در هر زبان برنامه نویسی دیگری هستند، اگرچه تفاوت های کوچکی وجود دارد که باید درک کنید.

توابع را برای برنامه های Rust خود با کلمه کلیدی fn و به دنبال آن نام تابع، آرگومان های اختیاری و نوع داده بازگشتی اختیاری تعریف می کنید.

// function that neither takes in arguments nor returns a value
fn function_name() {
    // function body here
}

در اینجا یک تابع Rust ساده وجود دارد که هیچ آرگومان یا مقداری را بر نمی گرداند.

fn a_function(){
    let x = 3;
    println!("{}", x)
}

a_function یک تابع Rust ساده است که متغیر x را چاپ می کند.

امضاهای تابع زنگ

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

در اینجا نمونه ای از امضای تابع Rust آمده است:

fn name()

fn greet(name: &str)

تابع name یک امضای تابع حداقل است، در حالی که امضای سلام مشخص می کند که تابع یک آرگومان، نام، از نوع رشته (&str) را می گیرد.

اعلان توابع با آرگومان ها و مقادیر بازگشتی

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

در اینجا مدل معمولی تابع Rust است که آرگومان ها را می گیرد:

fn function_name(arg: type, arg2: type) {
    // function body here
}

نوع آرگومان تابع می تواند نوع داخلی Rust یا نوع سفارشی برنامه شما باشد.

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

fn add_numbers(x: i32, y: i32) {
    println!("{}", x + y);
}

تابع add_numbers دو عدد صحیح 32 بیتی می گیرد و مجموع اعداد صحیح را چاپ می کند.

توابع Rust می توانند چندین مقدار را برگردانند. باید نوع(های) بازگشتی را مشخص کنید و مقادیر نوع را از تابع برگردانید.

fn function_name(arg: type, arg2: type) -> (type, type) {
    // function body here
    return arg, arg2
}

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

fn string_and_integer(s: String, n: i32) -> (String, i32) {
    return (s, n);
}

تابع string_and_integer یک رشته و یک عدد صحیح 32 بیتی را می گیرد و آنها را به صورت یک تاپل برمی گرداند. شما فقط می توانید یک مقدار واحد را از تابع Rust برگردانید.

می‌توانید هنگام بازگرداندن عبارت نهایی از یک تابع، کلمه کلیدی بازگشت را کنار بگذارید تا کد مختصرتر شود.

fn string_and_integer(s: String, n: i32) -> (String, i32) {
    return (s, n);
}

// the functions are equivalent

fn str_and_int(s: String, n: i32) -> (String, i32) {
    (s, n)
}

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

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

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

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let result = add_numbers(3, 5);
    println!("The result is {}", result); // Output: The result is 8
}

تابع اصلی add_numbers را فراخوانی می کند و آن را دو عدد صحیح ارسال می کند. نتیجه تابع را به یک متغیر، نتیجه اختصاص می دهد.

شما می توانید توابع را برای سازه های زنگ اعلام کنید

شما می توانید توابع را در ساختارهای Rust اعلام کنید. اینها به روش هایی برای ساختاری تبدیل می شوند که می توانند به آن دسترسی داشته باشند و آن را اصلاح کنند.

Rust صرفاً شی گرا نیست، اما ساختارهایی را برای گروه بندی داده های مرتبط ارائه می دهد. شما می توانید با استفاده از ساختارهایی با متدها، در جهت پیاده سازی مفاهیم OOP در Rust کار کنید.

منبع مقاله