למד כיצד לטפל ביעילות בקובצי TOML ב-Rust עם המדריך המקיף הזה.

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

TOML (השפה המינימלית הברורה של טום) בולטת כאפשרות חזקה וידידותית למשתמש בין פורמטים רבים של קבצי תצורה עבור תחביר וכיצד הוא מטפל בחסרונות של פורמטים קיימים של קבצי תצורה כדי לספק אינטואיטיבי ופשוט יותר חֲלוּפָה.

הבנת קובץ TOML

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

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

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

instagram viewer

  1. מבנה אינטואיטיבי: TOML מאמץ מבנה היררכי הכולל טבלאות, צמדי מפתח-ערך ומערכים. הארגון של TOML מאפשר ייצוג ברור והגיוני של הגדרות תצורה מורכבות.
  2. הערות ורווחים לבנים: TOML תומך בהערות מוטבעות ומרובות שורות, מה שמאפשר לך להוסיף הערות ולתעד את קובצי התצורה שלך ביעילות. מתעלמים מרווחים לבנים בעיקר כדי להבטיח קריאה ולהפחית רעש מיותר.
  3. הקלדה חזקה: כל ערך ב-TOML משויך לסוג נתונים ספציפי, ממחרוזות ועד מספרים שלמים, צפים, בוליאנים ותאריכים. אכיפת ההקלדה החזקה של TOML מסייעת בשמירה על שלמות הנתונים לעיבוד נטול שגיאות.
  4. תמיכה במבנים מקוננים: TOML מאפשר קינון של טבלאות בתוך טבלאות עבור ייצוג תצורה היררכי. מבנים מקוננים מועילים כאשר מתמודדים עם הגדרות רב-ממדיות או הגדרות יישומים מורכבות.
  5. תמיכה במערך ובטבלה מוטבעת: TOML מספקת מערכים וטבלאות מוטבעות עבור גמישות בביטוי מבני נתונים מיותרים או קומפקטיים.

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

הנה דוגמה לקובץ TOML פשוט עבור תצורות:

[שרת]
נמל = 8080
מנחה = "מארח מקומי"
לנפות = שֶׁקֶר
[מאגר מידע]
שֵׁם = "מסד הנתונים שלי"
שם משתמש = "אדמין"
סיסמה = "סיסמה סודית"

לקובץ TOML הזה יש שני חלקים המכילים צמדי מפתח-ערך המייצגים אפשרויות תצורה ספציפיות. הנה ה נמל מפתח את [שרת] סעיף מציין מספר יציאה על מנחה מפתח המציין את שם המארח של השרת.

עבודה עם קבצי TOML בחלודה

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

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

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

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

ל לעבוד עם חבילות של צד שלישי ב- Rust, צור פרויקט Rust עם Cargo והוסף הנחיה זו ל- תלות קטע של הפרויקט שלך Cargo.toml קובץ להתקנה ולהשתמש ב- toml ארגז בפרויקטי החלודה שלך:

[תלות]
toml = "0.5"

עבור TOML סריאליזציה וסידריאליזציה של נתונים, תזדקק לארגז השרת. ה toml ארגז משתלב היטב עם serde לעיבוד נתונים.

[תלות]
serde = { גרסה = "1.0", תכונות = ["לְהָפִיק"] }
toml = "0.5"

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

להשתמש toml;

ה toml ארגז יכול לקרוא, לכתוב ולנתח קבצי TOML.

קריאת קבצי TOML עם חלודה

לאחר הוספת ה toml ארגז כתלות בפרויקט וייבוא ​​הארגז לפרויקט שלך, אתה יכול לקרוא קבצי TOML בתוכניות Rust שלך.

ראשית, תצטרך לפתוח את קובץ TOML עם המובנה fs של ארגז קוֹבֶץ מבנה:

להשתמש std:: fs:: קובץ;
להשתמש std:: io:: קרא;
fnרָאשִׁי() {
לתתמוט file = File:: open("config.toml").לְצַפּוֹת("נכשל בפתיחת הקובץ");
לתתמוט תוכן = חוּט::חָדָשׁ();
 file.read_to_string(&מוט תוכן)
 .לְצַפּוֹת("קריאת הקובץ נכשלה");
// בשלב זה, `תוכן` מכיל את התוכן של קובץ ה-TOML
println!("{}", תוכן);
}

ה רָאשִׁי הפונקציה פותחת את א cargo.toml קובץ עם ה קובץ:: פתוח שיטה וקוראת את תוכן הקובץ למחרוזת עם ה- read_to_string שיטה לפני הדפסת התוכן למסוף עם println! מאקרו.

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

כך תוכל לקרוא את תוכן הפרויקט שלך Cargo.toml קובץ והדפיס אותם למסוף:

להשתמש serde:: Deserialize;
להשתמש std:: fs;
#[נגזר (ניפוי באגים, ביטול סדרה)]
מבנהCargoToml {
#[allow (dead_code)]// השבת אזהרת קוד מת עבור המבנה כולו
 חבילה: חבילה,
#[allow (dead_code)]
 תלות: תלות,
}


#[נגזר (ניפוי באגים, ביטול סדרה)]
מבנהחֲבִילָה {
#[allow (dead_code)]
 שֵׁם: חוּט,
#[allow (dead_code)]
 גִרְסָה: חוּט,
#[allow (dead_code)]
 מַהֲדוּרָה: חוּט,
}


#[נגזר (ניפוי באגים, ביטול סדרה)]
מבנהתלות {
#[allow (dead_code)]
 serde: SerdeDependency,
#[allow (dead_code)]
 toml: חוּט,
}


#[נגזר (ניפוי באגים, ביטול סדרה)]
מבנהSerdeDependency {
#[allow (dead_code)]
 גִרְסָה: חוּט,
#[allow (dead_code)]
 מאפיינים: Vec<חוּט>,
}


fnרָאשִׁי() {
לתת toml_str = fs:: read_to_string("Cargo.toml").לְצַפּוֹת("קריאת קובץ Cargo.toml נכשלה");


לתת cargo_toml: CargoToml = toml:: from_str(&toml_str).expect("הסרת הרצף של Cargo.toml נכשלה");
println!("{:#?}", cargo_toml);
}

ה CargoToml, חֲבִילָה, תלות, ו SerdeDependency structs מייצגים את המבנה של קובץ TOML. המבנים מסומנים עם #[allow (dead_code)] תכונות להשבית אזהרות קוד מת עבור המבנים.

ה רָאשִׁי הפונקציה קוראת את התוכן של Cargo.toml קובץ לתוך toml_str משתנה וה- from_str שיטת ה toml ארגז קורא את מחרוזת TOML ומסיר את התוכן לתוך ה- cargo_toml מִשְׁתַנֶה.

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

כתיבת נתונים לקבצי TOML עם חלודה

כתיבת נתונים לקובצי TOML שימושית ליצירת קובצי תצורה מהתוכניות שלך.

הנה איך להעביר מבנה בסידרה ל-TOML ולכתוב את התוכן ל-a config.toml קובץ בספריית השורש של הפרויקט שלך:

להשתמש std:: fs:: קובץ;
להשתמש std:: io:: כתוב;
להשתמש serde:: סדרה;
להשתמש toml:: to_string;
#[נגזר (בסדרה)]
מבנהServerConfig {
 מנחה: חוּט,
 נמל: u16,
 פסק זמן: u32,
}


fnwrite_config_to_file(config: &ServerConfig, file_path: &str) -> תוֹצָאָהקופסא<dyn std:: error:: Error>> {
לתת toml_string = to_string (config)?;
לתתמוט file = File:: create (file_path)?;
 file.write_all (toml_string.as_bytes())?;
בסדר(())
}


fnרָאשִׁי() {
לתת config = ServerConfig {
 מנחה: "מארח מקומי".to_owned(),
 נמל: 8000,
 פסק זמן: 30,
 };
אםלתתלִטְעוֹת(e) = write_config_to_file(&config, "config.toml") {
 eprintln!("שגיאה: {}",ה);
 } אַחֵר {
println!("קובץ התצורה נוצר בהצלחה.");
 }
}

ה write_config_to_file הפונקציה מתייחסת למופע של ה ServerConfig struct ואת נתיב הקובץ עבור config.toml קובץ ממיר את מופע ה-struct למחרוזת ויוצר את config.toml קובץ בנתיב הקובץ שצוין. לבסוף, הוא כותב את מחרוזת TOML לקובץ TOML באמצעות ה לכתוב_הכל פוּנקצִיָה.

ה רָאשִׁי הפונקציה מאתחלת את א ServerConfig אובייקט struct, קורא ל- write_config_to_file עם הנתונים הדרושים, ומדפיס הודעה למסוף בהתבסס על מצב הפעולה.

Cargo משתמש בקבצי TOML לניהול תלות

Cargo, מנהל התלות של Rust, וכלי ה-build, משתמשים בקבצי TOML לציון וניהול תלות.

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