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

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

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

עיצוב מחרוזת בסיסי בחלודה

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

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

fnרָאשִׁי() {
לתת שם = "אליס";
לתת גיל = 25;
לתת הודעה = פוּרמָט!("שמי {} ואני בן {} שנים.", שם, גיל);
println!("{}", הודעה);
}

ה שֵׁם משתנה מחזיק מחרוזת, וה- גיל משתנה מכיל מספר שלם. ה הוֹדָעָה למשתנה יש מחרוזת מעוצבת שמשתמשת פוּרמָט! כדי להחליף את מצייני המיקום בערכים תואמים, וכתוצאה מכך מחרוזת פורמט המכילה את שֵׁם ו גיל.

ה פוּרמָט! מאקרו תומך במפרטי פורמטים שונים המאפשרים לך לשלוט בפלט.

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

fnרָאשִׁי() {
לתת pi = 3.14159;
לתת formatted_pi = פוּרמָט!("הערך של pi הוא בערך {:.2}", פאי);
println!("{}", formatted_pi); // מדפיסים 3.14
}

ה פאי משתנה מחזיק ערך נקודה צפה; עם מפרט הפורמט :.2, אתה יכול להנחות את פוּרמָט! מאקרו לתצוגה פאי עם שני מקומות עשרוניים.

ה פוּרמָט! מאקרו היא אחת מהשיטות הרבות של עיצוב מחרוזת עם Rust. בהתאם לדרישות שלך, שקול להשתמש ב- println! אוֹ לִכתוֹב! מאקרו עבור פלט מעוצב לקונסולה או לזרמי פלט אחרים.

עיצוב ערכים מספריים

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

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

להלן כמה ממפרטי הפורמטים ש-Rust מספקת עבור ערכים מספריים:

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

כדי ליישר ערך שמאלה, השתמש ב- - דֶגֶל. כדי ליישר ערך ימינה, הסר את הדגל או השתמש בדגל '0' עבור ריפוד אפס.

fnרָאשִׁי() {
 מספר = 42
 formatted_number = "%10d" % מספר
 הדפס (מספר_פורמט)
}

הערך מיושר לימין ברוחב של 10 תווים, וכתוצאה מכך שמונה רווחים מובילים לפני המספר.

עיצוב מחרוזת מותאם אישית בחלודה

עיצוב מחרוזת מותאם אישית חשוב לפעולות תובעניות יותר. אתה יכול ליצור יישומי עיצוב מותאמים אישית עבור הסוגים שלך עם ה-Rust המובנה std:: fmt מודול.

ה std:: fmt מודול מספק תכונות לעיצוב פלט עם מגוון רחב של אפשרויות להתאמה אישית של מראה הנתונים במהלך תהליך המרת המחרוזות. ה std:: fmt מודול מספק א לְהַצִיג ו לנפות תכונה שימושית עבור פעולות עיצוב מחרוזות.

תכונת התצוגה

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

הפורמט מספק שיטות שונות לשליטה בפלט הפורמט, כמו ה- write_str ו write_fmt שיטות.

להשתמש std:: fmt;
// הגדר מבנה בשם `נקודה`
structנְקוּדָה {
 איקס: i32,
 y: i32,
}
// יישם את התכונה 'תצוגה' עבור 'נקודה'
impl fmt:: תצוגה ל נקודה {
fnfmt(&עצמי,f: &מוט fmt:: פורמט<'_>) -> fmt::תוֹצָאָה {
// עצב את מבנה ה-'Point' בתור "(x, y)"
לִכתוֹב!(ו, "({}, {})", עצמי.איקס, עצמי.y)
 }
}
fnרָאשִׁי() {
// צור מופע 'Point' חדש
לתת נקודה = נקודה { x: 5, y: 10 };
// הדפס את מבנה ה-'Point' באמצעות עיצוב ה-'Display'
println!("הנקודה היא: {}", נקודה);
}

ה נְקוּדָה struct מיישם את לְהַצִיג תְכוּנָה. בתוך ה fmt שיטה, ה לִכתוֹב! פורמטי מאקרו וכתוב את הפלט הרצוי לפורמט עם ה- {} מציין מיקום.

תכונת ניפוי באגים

ה לנפות תכונה דומה ל- לְהַצִיג תכונה, אלא שהיא מתמקדת בהפקת פלט המתאים לניפוי באגים ו טיפול בשגיאות מטרות. ה לנפות תכונה משמשת בעיקר עם {:?} מציין מיקום.

יישום ה לנפות התכונה בסוגים המותאמים אישית שלך היא פשוטה. ה לנפות תכונה מספקת מימוש ברירת מחדל המבוסס על לְהַצִיג תְכוּנָה. עם זאת, אתה יכול לעקוף את התנהגות ברירת המחדל כדי לספק ייצוג מיוחד של ניפוי באגים.

להשתמש std:: fmt;
// הגדר מבנה בשם 'אדם'
#[נגזר (ניפוי באגים)]
structאדם {
 שֵׁם: חוּט,
 גיל: u32,
}
// יישם את התכונה 'תצוגה' עבור 'אדם'
impl fmt:: תצוגה ל אדם {
fnfmt(&עצמי,f: &מוט fmt:: פורמט) -> fmt::תוֹצָאָה {
// עצב את המבנה 'אדם' כמחרוזת הניתנת לקריאה על ידי אדם
לִכתוֹב!(ו, "שם: {}, גיל: {}", עצמי.שֵׁם, עצמי.גיל)
 }
}
fnרָאשִׁי() {
// צור מופע 'אדם' חדש
לתת אדם = אדם {
 שֵׁם: חוּט::מ("אליס"),
 גיל: 30,
 };
// הדפס את מבנה 'אדם' באמצעות עיצוב 'תצוגה'
println!("תצוגה: {}", אדם);
// הדפס את המבנה 'אדם' באמצעות עיצוב 'Debug'
println!("לנפות: {:?}", אדם);
}

התוכנית גוזרת את לנפות תכונה עבור אדם לבנות עם #[נגזר (ניפוי באגים)]. זה יוצר אוטומטית את היישום על סמך שדות ה-struct.

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

לחלודה יש ​​מערכת עשירה בתכונות

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

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