הבנת התכונות והחיים של חלודה

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

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

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

הבנת תכונות בחלודה

תכונות הן אוספים של שיטות שסוגים אחרים יכולים ליישם. תכונות דומות ל ממשקים בשפות כמו Java, Go ו-TypeScript אך גמישים יותר.

אתה תשתמש ב- תְכוּנָה מילת מפתח להגדרת תכונות ב-Rust, ואחריה הצהרה על חתימות השיטה.

תְכוּנָהMyTrait {
fnשלי_שיטה(&עצמי);
}

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

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

כך תוכל ליישם תכונה עבור סוגי המבנה שלך.

structאדם {
 שֵׁם: חוּט,
 גיל: u32,
}





instagram viewer
impl מידע ל אדם {
fnסיכום(&עצמי) {
println!("שמי {} ואני בן {} שנים.", עצמי.שֵׁם, עצמי.גיל);
 }
}

ה אדם מכשירי struct מידע, ואתה יכול להתקשר ל סיכום שיטה על מקרים של אדם מבנה.

fnרָאשִׁי(){
לתת John = אדם { שם: חוּט::מ("ג'ון"), גיל: 30 };
 john.summary(); // פלט: שמי ג'ון, ואני בן 30.
}

ה ג'ון משתנה הוא מופע של ה אדם מבנה.

ה רָאשִׁי קריאות פונקציות סיכום שמדפיס הודעה למסוף:

Enums יכולים ליישם תכונות. הנה איך אתה יכול להגדיר enum עם גרסאות שמיישמות את סיכום שיטה:

enumMyEnum {
 VariantA,
 VariantB,
}
impl מידע ל MyEnum {
fnסיכום(&עצמי) {
התאמהעצמי {
 MyEnum:: VariantA => {
// יישום עבור VariantA
 }
 MyEnum:: VariantB => {
// יישום עבור VariantB
 }
 }
 }
}

שימוש בתכונות לפרמטרים של פונקציות וערכי החזרה

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

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

fnעשה משהו(ערך: T) {
 value.summary();
}

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

תקופות חיים בחלודה

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

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

ב-Rust, אתה יכול לציין אורך חיים באמצעות הערת אפוסתרפיה:

func<'א>

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

הנה דוגמה למפרט לכל החיים בפונקציה.

fnעשה משהו<'א>(x: &'אi32) -> &'אi32 {
 איקס
}
fnרָאשִׁי() {
לתת x = 42;
לתת result = do_something(&x);
println!("התוצאה היא: {}", תוצאה);
}

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

ה רָאשִׁי הפונקציה מדפיסה את התוצאה על ידי העברת הפניה ל- איקס משתנה ב- רָאשִׁי פונקציה לקונסולה.

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

כלל חיי הקלט

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

במילים פשוטות, משך החיים של הפניות הפלט יהיה זהה לזה של הפניות הקלט.

fnהארוך ביותר<'א>(x: &'אstr, y: &'אstr) -> &'אstr {
אם x.len() > y.len() { x } אַחֵר {י}
}

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

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

כלל חיי הפלט

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

fnמילה ראשונה<'א>(ים: &'אstr) -> &'אstr {
 s.split_whitespace().next().unwrap()
}

בפונקציה זו, Rust מסיק כי משך החיים של התייחסות הפלט שונה משך החיים של התייחסות הקלט מכיוון ש split_whitespace() השיטה יוצרת הפניה לפלט שלא לוקחת פרמטרים של התייחסות לקלט.

חוק העלמות של חיי חיים

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

fnהארוך ביותר<'א>(x: &'אstr, y: &str) -> &'אstr {
אם x.len() > y.len() { x } אַחֵר {י}
}

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

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

תכונות ותקופות חיים

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

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

תְכוּנָהToString {
fnto_string(&עצמי) -> חוּט;
}
fnto_string<'א,T: ToString>(t: &'א ט) -> חוּט {
 t.to_string()
}

הנה, הפרמטר לכל החיים 'א מבטיח שההפניה ט תקף לכל החיים של האובייקט שאליו הוא מפנה. אתה יכול להשתמש ב to_string פונקציה עם טיפוסים שמיישמים את ToString תכונה בעלת חיים תקפה.

תכונות מהוות את הבסיס ליישום מושגי OOP בחלודה

תכונות מאפשרות לך להגדיר התנהגויות. למרות ש-Rust אינה שפת תכנות מונחה עצמים (OOP), אתה יכול להשתמש בתכונות כדי ליישם מושגי OOP מ-Encapsulation ועד ירושה, פולימורפיזם והפשטה.

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