Enums והתאמת דפוסים בחלודה

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

Enums (enumerations) הוא סוג נתונים המאפשר ייצוג של קבוצה קבועה של ערכים, כמו ימי השבוע וצבע הקשת. Enums שימושיים כאשר הערכים האפשריים עבור משתנה מוגבלים וידועים.

הגדרת Enums בחלודה

הכרזה על enums ב-Rust דומה ל הכרזה על enums ב-C#. אתה תשתמש ב enum מילת מפתח אחרי השם וקבוצה של סוגרים מסולסלים להגדרת ספירות. אתה יכול להגדיר את הגרסאות האפשריות (ישויות) בתוך הסוגרים המתולתלים עם פסיק כמפריד.

להלן רשימה של ימות השבוע:

enumיוֹם חוֹל {
 יוֹם שֵׁנִי,
 יוֹם שְׁלִישִׁי,
 יום רביעי,
 יוֹם חֲמִישִׁי,
 יוֹם שִׁישִׁי,
 יום שבת,
 יוֹם רִאשׁוֹן,
}

ה יוֹם חוֹל enum מייצג את ימי השבוע. ה גרסאות הם שמות היום ואין להם ערכים משויכים. כמו כן, הווריאציות של ה-enum שלך יכולות להיות כל אחת סוג נתוני חלודה.

אתה יכול לגשת לגרסאות על ידי ציון שם הווריאציה באמצעות אופרטור מפריד הנתיב (::) ב-enum.

לתת יום = יום חול:: יום שני;
// גרסה בהקלדה סטטית של המשתנה `day`
לתת יום: יום חול = יום חול:: יום שני;

הקוד מציין שברצונך לגשת ל- יוֹם שֵׁנִי גרסה של הרשימה של יום השבוע.

וריאנטים ומבחנים של Enums

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

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

enumיוֹם חוֹל {
 יום שני = 1,
 יום שלישי = 2,
 יום רביעי = 3,
 יום חמישי = 4,
 יום שישי = 5,
 שבת = 6,
 יום ראשון = 7,
}

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

אתה יכול לגשת לערך המבחין באמצעות שם הגרסה.

fnרָאשִׁי() {
println!("יום שני: {}", יום חול:: יום שני כפי שi32);
println!("יום שלישי: {}", יום חול:: יום שלישי כפי שi32);
println!("יום רביעי: {}", יום חול:: יום רביעי כפי שi32);
println!("חמישי: {}", יום חול:: יום חמישי כפי שi32);
println!("שישי: {}", יום חול:: שישי כפי שi32);
println!("יום שבת: {}", יום חול:: שבת כפי שi32);
println!("יום ראשון: {}", יום חול:: יום ראשון כפי שi32);
}

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

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

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

הנה התוצאה מהפעלת ה רָאשִׁי פוּנקצִיָה:

התאמת דפוסים בחלודה

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

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

הנה דוגמה למשפט התאמה:

fnרָאשִׁי(){
לתת x = 5;
התאמה איקס {
1 => println!("אחד"),
2 => println!("שתיים"),
3 => println!("שְׁלוֹשָׁה"),
// פועל אם אף אחת מהדפוסים לא תואמת
 _ => println!("משהו אחר"),
 }
}

ה רָאשִׁי התאמת פונקציות איקס כנגד מספר תבניות ולאחר מכן מדפיס את הערך על סמך הערך של x. תבנית הקו התחתון (_) היא תבנית גלויה המשמשת כ-catch-all עבור מקרים שאינם מטופלים במפורש.

Enums והתאמת תבניות

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

הנה רשימה של הצבעים בקשת בענן:

enumקשת בענן {
 אָדוֹם,
 תפוז,
 צהוב,
 ירוק,
 כְּחוֹל,
 אִינדִיגוֹ,
 סָגוֹל,
}

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

הנה פונקציה שמקבלת את וריאנט הצבע מ-Rainbow enum ומדפיסה הודעה על סמך הצבע.

fnprint_color(צבע: קשת) {
התאמה צבע {
 קשת בענן:: אדום => println!("הצבע אדום!"),
 קשת בענן:: כתום => println!("הצבע הוא כתום!"),
 קשת בענן:: צהוב => println!("הצבע צהוב!"),
 קשת בענן:: ירוק => println!("הצבע הוא ירוק!"),
 קשת בענן:: כחול => println!("הצבע הוא כחול!"),
 קשת בענן:: אינדיגו => println!("הצבע הוא אינדיגו!"),
 קשת בענן:: סגול => println!("הצבע סגול!"),
 }
}
fnרָאשִׁי() {
לתת צבע = קשת בענן:: כחול;
 print_color (צבע);
}

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

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

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

fnלחשב אורך_גל(צבע: קשת) -> u32 {
התאמה צבע {
 קשת בענן:: אדום => 700,
 קשת בענן:: כתום => 590,
 קשת בענן:: צהוב => 570,
 קשת בענן:: ירוק => 510,
 קשת בענן:: כחול => 475,
 קשת בענן:: אינדיגו => 445,
 קשת בענן:: סגול => 400,
 }
}

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

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

Enums שימושיים להגדרת סוגים מותאמים אישית עבור מספר פעולות, במיוחד במקרים בהם השדות ידועים ומוגדרים.

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