מדריך לשימוש ב-JSON ב-Go

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

JSON כל כך שימושי שכמעט כל שפות התכנות המודרניות מספקות תמיכה מובנית לעבודה איתו, כולל Go.

עבודה עם JSON ב-Go

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

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

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

באמצעות Go, אתה יכול לרכז מבני נתונים מקוריים ל-JSON. ואתה יכול לבצע את הפעולה ההפוכה, לחלק נתוני JSON למשתני Go.

Marshaling ל-JSON ב-Go

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

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

מרשל func (v מִמְשָׁק{}) ([]בייט, שגיאה)

זה אומר ש מַרשַׁל מקבל פרמטר מכל סוג נתונים, ומחזיר שני ערכים: פרוסת בתים ושגיאה. במילים אחרות, אתה מתקשר מַרשַׁל עם ערך Go, והוא ממיר אותו ל-JSON ומחזיר את המקבילה ל-JSON. אם הוא נתקל בשגיאה במהלך תהליך ההמרה, הוא יחזיר את השגיאה ופרוסה ריקה.

הנה דוגמה לקוד שמשתמש מַרשַׁל כדי להמיר מפה ל-JSON. כדי להפעיל את הדוגמה הזו, כל מה שאתה צריך הוא ליצור קובץ Go עורך הקוד המועדף עליך, או השתמש ב- לך למגרש משחקים:

חֲבִילָה רָאשִׁי
יְבוּא (
"קידוד/json"
"fmt"
)
func רָאשִׁי(){
 val := מפה[מחרוזת]int{
"ג'ון": 25,
"מרי": 19,
"אדם": 5,
 }
res, _ := json. מרשל (ואל)
fmt.הדפסה(חוּט(מילואים))
}

אם תפעיל את הקוד הזה, הוא יוציא את הטקסט הבא:

כפי שצוין קודם, אתה יכול לרכז כל סוג של נתוני Go ל-JSON, אם כי בחיים האמיתיים אתה בדרך כלל מסדר מבנים. בגלל זה, Go מספקת תכונה הנקראת struct tags כדי לאפשר לך לתת מַרשַׁל הוראות נוספות להמרת המבנים שלך.

תג struct הוא מחרוזת שאתה כולל בהצהרת המבנה שלך לצד סוג הנתונים של שדה. תגי מבנה מאפשרים לך להתאים את הדרך מַרשַׁל מתייחס לשדה אליו שייך התג. אתה יכול להשתמש בתגי struct כדי לשנות שם של שדה בפלט JSON, או אפילו להשמיט אותו לחלוטין. תגיות מבנה (זה מַרשַׁל מזהה) מתחילים במחרוזת המשנה "json:".

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

חֲבִילָה רָאשִׁי
יְבוּא (
"קידוד/json"
"fmt"
)
func רָאשִׁי(){
סוּג מבנה רכב {
 מחרוזת מותג
 מחרוזת דגם
 מחיר int
 }
 val := רכב{מותג: "מרצדס", דגם: "בנץ", מחיר: 50000}
 res, _ := json. מרשל (ואל)
fmt.הדפסה(חוּט(מילואים))
}

קוד זה מייצר את הפלט:

ה מותג, דֶגֶם, ו מחיר שדות של אוטו צריך להתחיל באותיות גדולות, או מַרשַׁל לא יוכל להמיר אותם. כתוצאה מכך, שדות הפלט של JSON מתחילים גם באותיות רישיות. אבל מה אם אתה רוצה שהשמות יתחילו באותיות קטנות ב-JSON, או אם אתה רוצה לשנות את שם השדה לחלוטין? שם נכנסות תגיות ה-struct. הנה דוגמה:

חֲבִילָה רָאשִׁי
יְבוּא (
"קידוד/json"
"fmt"
)
func רָאשִׁי(){
סוּג מבנה רכב {
 מזהה int `json:"-"`
 מחרוזת מותג `json:"סוּג"`
 מחרוזת דגם `json:"דֶגֶם"`
 מחיר int `json:"מחיר"`
 }
 val := רכב{ID: 0, מותג: "מרצדס", דגם: "בנץ", מחיר: 50000}
 res, _ := json. מרשל (ואל)
fmt.הדפסה(חוּט(מילואים))
}

קוד זה מציג שדה מזהה חדש מַרשַׁל משמיט מפלט JSON באמצעות תג struct. הקוד משתמש גם בתגי struct כדי לשנות את שמות שדות ה-struct האחרים. להלן פלט התוכנית:

כפי שניתן לראות, החלק של תג ה-struct שאחרי "json:" הופך לשם של השדה בפלט של מרשל. יש חריג אחד: אם זו המחרוזת "-", מרשל משמיט את השדה הזה מהפלט. אתה יכול לקרוא עוד על מרשל ותגיות struct ב- לך תיעוד.

Unmarshaling מ-JSON ב-Go

חבילת ה-encoding/json מספקת גם פונקציית ביטול מארשה, הנקראת לא מרשל. יש לו את חתימת הפונקציה הבאה:

func Unmarshal (נתונים []byte, v מִמְשָׁק{}) שגיאה

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

כשאתה משחרר בתוכנית, אתה יכול להביא נתונים מ-API, אבל כאן אתה תשתמש בנתוני דמה. הנה איך אתה משתמש לא מרשל:

חֲבִילָה רָאשִׁי
יְבוּא (
"קידוד/json"
"fmt"
)
func רָאשִׁי(){
סוּג מבנה רכב {
 מזהה int `json:"-"`
 מחרוזת מותג `json:"סוּג"`
 מחרוזת דגם `json:"דֶגֶם"`
 מחיר int `json:"מחיר"`
 }
jsonInput := `{
"סוּג": "טויוטה",
"דֶגֶם": "קאמרי",
"מחיר": 2000
 }`
var jsonOutput Car
 טעות := json. Unmarshal([]בייט(jsonInput), &jsonOutput)
אם שגיאה != אפס {
 fmt. Println("שגיאת פענוח JSON!")
לַחֲזוֹר
 }
fmt.הדפסה(jsonOutput)
}

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

זה מראה שנתוני ה-Dmmy JSON חולקו בהצלחה לתוך ה- jsonOutput מבנה.

Go מקל על העבודה עם JSON

עם חבילת הקידוד/json, העבודה עם JSON ב-Go פשוטה כמו שתי קריאות פונקציה: Marshaland Unmarshal. Go גם מאפשר לך להתאים אישית את תהליך המרת/הסרה של JSON עם תגי struct.

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