מבנים לבקרת חלודה וכיצד להשתמש בהם

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

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

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

הצהרות מותנות הן קונסטרוקציות המאפשרות לך להריץ קוד על סמך תנאים. הצהרות מותנות מועילות לקבלת החלטות שכן ביצוע התוכנית תלוי בשאלה אם התנאי מוערך נָכוֹן אוֹ שֶׁקֶר. חלודה מספקת אם, אַחֵר, ו התאמה הצהרות לקבלת החלטות.

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

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

הצהרות של Rust's if

אתה תצהיר אם הצהרות בתוכניות Rust שלך עם ה אם מילת מפתח ואחריה תנאי:

אם מצב {
// קוד לביצוע אם התנאי אמת
}

הנה דוגמה לאופן שבו אתה יכול להשתמש בהצהרת if בתוכניות Rust שלך:

fnרָאשִׁי() {
לתת x = 15;
אם x > 10 {
println!("x גדול מ-10");
 }
}

ה איקס המשתנה מכיל מספר שלם של 32 סיביות, והמשפט if בודק אם הערך של x גדול מ-10 לפני הפעלת גוש הקוד שמדפיס אותו.

ההצהרות האחרות של Rust

אתה תשתמש ב- אַחֵר מילת מפתח לביצוע גוש קוד כאשר אתה צופה כי an אם הצהרה תוערכת כשקרית.

אם מצב {
// קוד לביצוע אם התנאי אמת
} אַחֵר {
// קוד לביצוע אם התנאי הוא שקר
}

הנה דוגמה איפה איקס אינו גדול מ-10, ה אם הצהרה מעריכה שֶׁקֶר, ו אַחֵר ההצהרה פועלת.

fnרָאשִׁי(){
לתת x = 5;
אם x > 10 {
println!("x גדול מ-10");
 } אַחֵר {
println!("x אינו גדול מ-10");
 }
}

מאז איקס הוא 5 ו-5 אינו גדול מ-10, התוכנית מדלגת על אם לחסום ומבצע את אַחֵר לַחסוֹם.

הצהרות ההתאמה של Rust

אתה תשתמש ב- התאמה מילת מפתח לקבלת החלטות מורכבות לבדיקת סדרה של דפוסים וביצוע קוד המבוסס על התאמות דפוסים. הצהרות התאמה דומות ל להחליף הצהרות ב-C#, Go ו-C++.

להלן המבנה של הצהרת התאמה של Rust:

התאמה ערך {
 תבנית1 => {
// קוד לביצוע אם הערך תואם לתבנית1
 },
 דפוס2 => {
// קוד לביצוע אם הערך תואם לתבנית2
 },
// וכו.
}

כך תוכל להשתמש בהצהרות התאמה בתוכניות שלך:

לתת ציון = 'ב';
התאמה כיתה {
'א' => println!("עבודה מצויינת!"),
'ב' => println!("עבודה טובה."),
'ג' => println!("אתה יכול לעשות יותר טוב."),
 _ => println!("זה לא ציון תקף."),
}

ה כיתה המשתנה הוא תו, וה- התאמה הצהרה בודקת איזה מהתווים מעריך את הערך של משתנה הציון לפני ביצוע הקוד אחרי האופרטור =>. אתה יכול להשתמש בדפוס הקו התחתון (_) כדי להתאים ערכים שאינם תואמים לדפוסים אחרים (דפוס ברירת המחדל).

לולאות בחלודה

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

חלודה בזמן לולאות

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

בזמן מצב {
// קוד לביצוע
}

התנאי צריך להיות ביטוי בוליאני שקובע את המשך הלולאה. כאשר התנאי מעריך false, הלולאה יוצאת.

הנה דוגמה ללולאת Rust while שמדפיסה מספרים מאחד עד חמש.

fnרָאשִׁי() {
לתתמוט אני = 1;
בזמן אני <= 5 {
println!("{}", אני);
 אני += 1;
 }
}

לולאת ה-while ב- רָאשִׁי הפונקציה עוברת את המספרים אחד עד חמש תוך הגדלה של ה- אני משתנה באחד עד אני המשתנה גדול מחמש, כאשר הלולאה מסתיימת.

הלולאה לולאה

ה לוּלָאָה מילת מפתח יוצרת לולאה אינסופית עד שאתה מציין יציאה עם לשבור מילת מפתח.

לוּלָאָה {
// קוד לביצוע
אם מצב {
לשבור;
 }
}

הקוד ב- לוּלָאָה בלוק ימשיך לפעול עד שהלולאה נתקלת ב-a לשבור מילת מפתח.

הנה דוגמה לשימוש ב- לוּלָאָה לולאה להדפסת מספרים אחד עד חמש לפני ציון לשבור מילת מפתח עבור היציאה.

fnרָאשִׁי() {
לתתמוט אני = 1;
לוּלָאָה {
println!("{}", אני);
 אני += 1;
אם אני > 5 {
לשבור;
 }
 }
}

ה רָאשִׁי הפונקציה מבצעת את הלולאה, ואת אם ההצהרה מגדילה את אני מִשְׁתַנֶה. ה אם הצהרה מציינת את סיום הלולאה כאשר ה- אני המשתנה עולה על חמישה.

Rust's for Loops

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

ל מִשְׁתַנֶה ב טווח {
// קוד לביצוע
}

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

הנה דוגמה ללולאת for שמדפיסה ערכים שנעים בין אחד לעשרה.

fnרָאשִׁי() {
ל אני ב1..=10 {
println!("{}", אני);
 }
}

הלולאה חוזרת על הערכים מ-1 עד 10. בכל איטרציה, המשתנה (i) מחזיק את הערך הבא, שה- println! לאחר מכן מודפס מאקרו.

אתה יכול להשתמש ב לְהַמשִׁיך מילת מפתח כדי לדלג על ערכים ב-for-loops. כך תוכל לדלג על המספרים הזוגיים כאשר אתה פועל על טווח:

fnרָאשִׁי() {
ל מספר ב1..=10 {
אם מספר % 2 == 0 {
לְהַמשִׁיך; // דלג על מספרים זוגיים
 }
println!("{}", מספר); // הדפס מספרים אי-זוגיים
 }
}

ה אם הצהרה משתמשת ב- לְהַמשִׁיך מילת מפתח כדי לציין שהלולאה צריכה לדלג על מספרים המתחלקים בשניים.

בנוסף, אתה יכול לצאת מ-for-loop עם ה- לשבור מילת מפתח. הלולאה מסתיימת במפגש עם לשבור מילת מפתח.

fnרָאשִׁי() {
ל מספר ב1..=10 {
אם מספר == 5 {
לשבור; // צא מלולאה כאשר המספר שווה ל-5
 }
println!("{}", מספר); // הדפס את המספרים 1 עד 4
 }
}

ה אם הצהרה מציינת שהלולאה צריכה להסתיים כאשר ה- אני משתנה שווה לחמישה.

השתמש במבני הבקרה של Rust עם סוגי נתונים כדי לשלוט בשפה

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

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