הבנת פונקציות בחלודה

פונקציות הן מבני תכנות חיוניים שכן הן מהוות בסיס לשימוש חוזר בקוד ומקלות על תכנות מודולרי. פונקציות הן בלוקים עצמאיים של קוד המבצעים משימות ספציפיות. הם יכולים לקבל קלט, בצורה של ארגומנטים, ולהחזיר ערך.

Rust מספקת פונקציות לארגון קוד, אנקפסולציה ושימוש חוזר בקוד.

הגדרת פונקציות בחלודה

פונקציות חלודה דומות מאוד פונקציות בכל שפת תכנות אחרת, למרות שיש הבדלים קטנים שתצטרך להבין.

אתה תגדיר פונקציות עבור תוכניות Rust שלך עם fn מילת מפתח ואחריה שם הפונקציה, ארגומנטים אופציונליים והחזרה אופציונלית סוג מידע.

// פונקציה שאינה קולטת ארגומנטים ולא מחזירה ערך
fn function_name() {
// גוף הפונקציה כאן
}

הנה פונקציית Rust פשוטה שאינה קולטת ארגומנטים או מחזירה ערכים כלשהם.

fn a_function(){
 תן x = 3;
println!("{}", איקס)
}

תפקוד היא פונקציית Rust פשוטה שמדפיסה את המשתנה איקס.

חתימות פונקציית חלודה

חתימות פונקציות הן דרך לתת שם לפונקציות, ולתיאור הארגומנטים וסוגי ההחזרות שלהן, מבלי לכלול גוף פונקציה. חתימות פונקציות שימושיות לתיעוד ממשקי API של ספריות Rust.

הנה דוגמה לחתימת פונקציית חלודה:

fn name()
fn greet (שם: &str)

ה שֵׁם הפונקציה היא חתימת פונקציה מינימלית, בעוד ה- לברך חתימה מציינת שהפונקציה לוקחת ארגומנט בודד, שֵׁם, מסוג מחרוזת (&str).

הצהרת פונקציות עם ארגומנטים וערכי החזרה

פונקציות חלודה יכולות לקלוט ארגומנטים רבים, והמגבלה אינה מוגדרת במפורש. פונקציות עם ארגומנטים הן בדרך כלל גמישות יותר מכיוון שהן יכולות לקלוט ערכים מפונקציות אחרות וחלקי קוד.

להלן המודל הטיפוסי של פונקציית Rust שמקבלת ארגומנטים:

fn function_name (arg: סוּג, arg2: סוּג) {
// גוף הפונקציה כאן
}

סוג הארגומנט של הפונקציה יכול להיות סוג מובנה של Rust או סוג מותאם אישית מהתוכנית שלך.

הנה דוגמה לפונקציה פשוטה שלוקחת שני מספרים שלמים כארגומנטים:

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

ה add_numbers הפונקציה לוקחת שני מספרים שלמים של 32 סיביות ומדפיסה את סכום המספרים השלמים.

פונקציות חלודה יכולות להחזיר ערכים מרובים; תצטרך לציין את סוג ההחזרה (ים) ולהחזיר את ערכי הסוג מהפונקציה.

fn function_name (arg: סוּג, arg2: סוּג) -> (סוּג, סוּג) {
// גוף הפונקציה כאן
לַחֲזוֹר arg, arg2
}

הנה פונקציה שלוקחת מחרוזת ומספר שלם של 32 סיביות כארגומנט ומחזירה את הארגומנטים כטופל.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
לַחֲזוֹר (ש, נ);
}

ה מחרוזת_ומספר_שלם הפונקציה לוקחת מחרוזת ומספר שלם של 32 סיביות, ומחזירה אותם כ-tuple. אתה יכול להחזיר רק ערך בודד מפונקציית Rust.

אתה יכול להשאיר את לַחֲזוֹר מילת מפתח בעת החזרת הביטוי הסופי מפונקציה, כדי להפוך את הקוד לתמציתי יותר.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
לַחֲזוֹר (ש, נ);
}
// הפונקציות שוות ערך
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

לשתי הפונקציות הללו יש את אותה התנהגות מכיוון ששתיהן לוקחות מחרוזת ומספר שלם ומחזירות את הארגומנטים האלה כטופל.

קריאה לפונקציות חלודה

אתה יכול לקרוא לפונקציה אחת מאחרת על ידי כתיבת השם שלה ואחריו ערכים שאתה רוצה להעביר אליה בתוך סוגריים:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 תן לתוצאה = add_numbers(3, 5);
println!("התוצאה היא {}", תוצאה); // פלט: התוצאה היא 8
}

ה רָאשִׁי קריאות פונקציות add_numbers, מעביר לו שני מספרים שלמים. הוא מקצה את התוצאה של הפונקציה למשתנה, תוֹצָאָה.

אתה יכול להכריז על פונקציות עבור מבני חלודה

אתה יכול להכריז על פונקציות בתוך מבני Rust. אלה הופכים לשיטות עבור המבנה שיכולים לגשת אליו ולשנות אותו.

חלודה אינה מונחה עצמים גרידא, אבל היא מספקת מבנים לקיבוץ נתונים הקשורים. אתה יכול לעבוד לקראת הטמעת מושגי OOP ב-Rust באמצעות מבנים עם שיטות.