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

JSON (סימון אובייקט JavaScript) הופיע כפורמט פופולרי לחילופי נתונים בתוכנה פיתוח בשל הפשטות, הקריאות והתמיכה הנרחבת שלו בתכנות שונות שפות. JSON הוא חלופה קלת משקל ל-XML להעברת נתונים בין שרת לאפליקציית אינטרנט או בין רכיבי מערכת תוכנה שונים.

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

תחילת העבודה עם Serde

Serde (סידריאליזציה ודה-סריאליזציה) היא ספריית Rust בשימוש נרחב המספקת מסגרת להמרה מבני נתונים חלודה לפורמטים לאחסון, שידור, שיתוף ואחרים.

Serde מאפשר המרה חלקה בין סוגי נתוני Rust ופורמטים שונים של החלפת נתונים, כולל JSON, YAML, BSON, CBOR, MessagePack ואחרים.

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

instagram viewer

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

[תלות]
serde = { גרסה = "1.0.159", תכונות = ["לְהָפִיק"] }
serde_json = "1.0.96"

תצטרך גם את serde ו serde_json ארגזים לאינטראקציה עם JSON. ה serde ארגז מספק את פונקציונליות הליבה, ואת serde_json ארגז הוא יישום ספציפי של Serde לעבודה עם JSON.

כך תוכל לייבא את serde_json ארגז ואת עשה סדרה ו דה-סדרה מודולים מה serde אַרְגָז:

להשתמש serde::{Serialize, Deserialize};
להשתמש serde_json;

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

סידור נתונים עם Serde

תהליך הסדרת JSON כולל המרת סוג Rust (מותאם אישית או מובנה) ל-JSON עבור פעולות אחרות. Serde מספקת קבוצה של תכונות שבהן תוכל להשתמש עם מבנה Rust כדי לאפשר שליטה מדויקת על תהליך ההסדרה, כולל #[נגזר (בסדרה)] תכונה המאפשרת לך ליצור קוד סריאליזציה עבור מבני הנתונים שלך ולהמיר את מבנה Rust שלך ל-JSON.

שקול את המבנה הזה המייצג את הביו-נתונים של אדם; כך תוכל לייבא ולהשתמש ב- עשה סדרה תכונה על המבנה:

להשתמש serde::{Serialize, Deserialize};
להשתמש serde_json;
#[נגזר (בסדרה)]
structאדם {
 שֵׁם: חוּט,
 גיל: u32,
}

על ידי הערת ה אדם לבנות עם ה [#derive (הסדרה)], אתה אומר ל-Serde ליצור את קוד ההסדרה הדרוש עבור אדם לבנות באופן אוטומטי.

הנה איך אתה יכול לעשות סדרה של מופע של ה אדם struct ל-JSON:

להשתמש serde::{Serialize};
להשתמש serde_json;
fnרָאשִׁי() {
// הצהרת מופע ה-Person struct עם שדות השם והגיל
לתת אדם = אדם {
 שֵׁם: "Chukwuemeriwo".to_string(),
 גיל: 28,
 };


// מסדרת את מבנה האדם ל-JSON באמצעות ספריית serde_json
לתת json = serde_json:: to_string(&person).expect("הסדרה נכשלה");
// מדפיס את מחרוזת ה-JSON המסודרת
println!("JSON מסודר: {}", json);
}

בתוך ה רָאשִׁי פונקציה, ה serde_json ארגז מסדר את אדם לְהִתְנַגֵד. ה to_string הפונקציה לוקחת הפניה ל- אדם object ומחזירה מחרוזת JSON המייצגת את הנתונים בסידרה.

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

ה serde ו serde_json הם רב-תכליתיים, אתה יכול גם לעשות סדרה של מערכים עם serde.

להשתמש serde::{Serialize, Deserialize};
להשתמש serde_json;
#[נגזר (בסדרה)]
structקואורדינטות {
 איקס: f32,
 y: f32,
}


fnרָאשִׁי() {
לתת נקודות = vec![ 
 קואורדינטות { x: 1.0, y: 2.0 },
 קואורדינטות { x: 3.5, y: 4.5 },
 ];


לתת json = serde_json:: to_string(&points).expect("הסדרה נכשלה"); 
println!("JSON מסודר: {}", json); // הדפס את מחרוזת ה-JSON המסודרת
}

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

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

להשתמש serde::{Serialize, Deserialize};
להשתמש serde_json;
#[נגזר (סידרה, ביטול סדרה)]
enumבעל חיים {
 כֶּלֶב(חוּט),
 חתול(u32),
 ציפור,
}


fnרָאשִׁי() {
לתת כלב = חיה:: כלב("חָלוּד".to_string());


לתת json = serde_json:: to_string(&dog).expect("הסדרה נכשלה");
println!("JSON מסודר: {}", json);
}

בהתאם לגרסה, תהליך הסידרה מסתגל בהתאם (במקרה זה, ה חיה:: כלב גרסה כוללת א חוּט שדה ש-Serde יעשה בסידרה כמחרוזת JSON).

הסרת נתונים באמצעות Serde

Deserialization של JSON הוא תהליך של הפיכת נתוני JSON לסוגי נתונים מקוריים של שפת תכנות. Serde מספקת מסגרת מקיפה ל-Deserialization של JSON שפועלת על רוב סוגי הנתונים המובנים.

בדומה לסריאליזציה, Serde מציע תכונות שבהן אתה יכול להשתמש כדי להוסיף הערות למבני החלודה שלך לתהליך הסידריאליזציה. שתי תכונות נפוצות עבור סידרה הן #[להפיק (להסיר בהמשכים)] ו #[serde (rename = "json_field_name")] תכונות.

ה #[להפיק (להסיר בהמשכים)] תכונה גוזרת באופן אוטומטי את יישום הדה-סריאליזציה עבורך סוגי מבנה חלודה, בזמן ש #[serde (rename = "json_field_name")] attribute מאפשר לך למפות שדות struct לשמות שדות JSON תואמים.

כך תוכל לבטל את נתוני JSON לסוג מבנה מותאם אישית עם Serde:

להשתמש serde:: Deserialize;
להשתמש serde_json;
// מגדיר מבנה לאדם עם תכונת Deserialize מ-Serde
#[להפיק (להסיר בהמשכים)]
structאדם {
#[serde (שנה שם = "שֵׁם")]// משנה את שם השדה ל"שם" 
 שם מלא: חוּט, 
 גיל: u32,
}


fnרָאשִׁי() {
לתת json_data = r#"
 {
"שֵׁם": "פלוני אלמוני",
"גיל": 30
 }
"#;


// מסיר את נתוני ה-JSON למבנה Person 
לתת person: Person = serde_json:: from_str (json_data).unwrap();
// הדפס את השם המלא וגילו של האדם
println!("שם: {}", person.full_name);
println!("גיל: {}", person.age);
}

על ידי הערת ה אדם לבנות עם ה #[להפיק (להסיר בהמשכים)] תכונה, אתה מציין ש-Serde יכול לבצע דה-סריאליזציה של המבנה מ-JSON. ה #[serde (שנה שם = "שם")] תכונה ממפה את שֵׁם שדה ב-JSON ל- שם מלא שדה.

ה from_str הפונקציה מבטלת את ה- json_data משתנה לתוך אדם חפץ, ואת רָאשִׁי הפונקציה מדפיסה את השדות למסוף.

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

כך תוכל לבטל סדרת מערך JSON למבנה Rust המכיל שדה וקטור:

להשתמש serde:: Deserialize;
#[להפיק (להסיר בהמשכים)]
structנתונים {
 מספרים: Vec<u32>,
}


fnרָאשִׁי() {
לתת json_data = r#"
 {
"מספרים": [1, 2, 3, 4, 5]
 }
"#;


לתת data: Data = serde_json:: from_str (json_data).unwrap();
ל מספר ב data.numbers {
println!("מספר: {}", מספר);
 }
}

ה רָאשִׁי הפונקציה מבטלת את ה- json_data תוכן JSON לתוך נתונים משתנה, והלולאה מדפיסה את האלמנטים בווקטור.

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

Serde משתלב עם מסגרות אינטרנט פופולריות של חלודה

Serde היא ספרייה רבת עוצמה עם תכונות רבות ו-API פשוט להסדרה והעברת נתונים בסידרה לפורמטים שונים.

Serde מאומצת באופן נרחב במערכת האקולוגית של Rust, וארגזים ומסגרות פופולריים רבים מובנים תמיכה עבור Serde, כולל מסגרות אינטרנט פופולריות כמו Actix, Warp ו-Rocket ו-ORM של מסדי נתונים כמו דִיזֶל.