खोज…
वाक्य - विन्यास
- func Marshal (v इंटरफ़ेस {}) ([] बाइट, त्रुटि)
- func Unmarshal (डेटा [] बाइट, v इंटरफ़ेस {}) त्रुटि
टिप्पणियों
पैकेज "encoding/json" पैकेज जसन Go में JSON ऑब्जेक्ट्स की एन्कोडिंग और डिकोडिंग को लागू करता है।
JSON में गो में उनके संगत ठोस प्रकारों के प्रकार हैं:
| JSON प्रकार | गो कंक्रीट टाइप |
|---|---|
| बूलियन | bool |
| संख्या | फ्लोट64 या इंट |
| तार | तार |
| शून्य | शून्य |
बेसिक JSON एन्कोडिंग
json.Marshal पैकेज "encoding/json" से JSON के मान को एन्कोड करता है।
पैरामीटर एनकोड करने का मान है। लौटे मान JSON- एन्कोडेड इनपुट (सफलता पर), और एक त्रुटि (विफलता पर) का प्रतिनिधित्व करने वाले बाइट्स की एक सरणी है।
decodedValue := []string{"foo", "bar"}
// encode the value
data, err := json.Marshal(decodedValue)
// check if the encoding is successful
if err != nil {
panic(err)
}
// print out the JSON-encoded string
// remember that data is a []byte
fmt.Println(string(data))
// "["foo","bar"]"
अंतर्निहित डेटा प्रकारों के लिए एन्कोडिंग के कुछ मूल उदाहरण यहां दिए गए हैं:
var data []byte
data, _ = json.Marshal(1)
fmt.Println(string(data))
// 1
data, _ = json.Marshal("1")
fmt.Println(string(data))
// "1"
data, _ = json.Marshal(true)
fmt.Println(string(data))
// true
data, _ = json.Marshal(map[string]int{"London": 18, "Rome": 30})
fmt.Println(string(data))
// {"London":18,"Rome":30}
गो में JSON एन्कोडिंग कैसे काम करता है, यह समझने के लिए सरल चर एन्कोडिंग उपयोगी है। हालाँकि, वास्तविक दुनिया में, आप संभवतः अधिक जटिल डेटा को संरचित में संग्रहीत करेंगे।
बेसिक JSON डिकोडिंग
पैकेज "encoding/json" से json.Unmarshal दिए गए वैरिएबल द्वारा json.Unmarshal गए मान में JSON मान को डिकोड करता है।
मापदंडों को []bytes में डीकोड करने के लिए मूल्य है और डी-धारावाहिक मूल्य के लिए भंडारण के रूप में उपयोग करने के लिए एक चर है। लौटाया गया मान एक त्रुटि है (विफलता पर)।
encodedValue := []byte(`{"London":18,"Rome":30}`)
// generic storage for the decoded JSON
var data map[string]interface{}
// decode the value into data
// notice that we must pass the pointer to data using &data
err := json.Unmarshal(encodedValue, &data)
// check if the decoding is successful
if err != nil {
panic(err)
}
fmt.Println(data)
map[London:18 Rome:30]
ऊपर दिए गए उदाहरण में देखें कि हम पहले से ही कुंजी के प्रकार और मूल्य दोनों को जानते थे। पर यह मामला हमेशा नहीं होता। वास्तव में, ज्यादातर मामलों में JSON में मिश्रित मूल्य प्रकार होते हैं।
encodedValue := []byte(`{"city":"Rome","temperature":30}`)
// generic storage for the decoded JSON
var data map[string]interface{}
// decode the value into data
if err := json.Unmarshal(encodedValue, &data); err != nil {
panic(err)
}
// if you want to use a specific value type, we need to cast it
temp := data["temperature"].(float64)
fmt.Println(temp) // 30
city := data["city"].(string)
fmt.Println(city) // "Rome"
ऊपर के अंतिम उदाहरण में हमने डिकोड किए गए मूल्य को संग्रहीत करने के लिए एक सामान्य मानचित्र का उपयोग किया। हमें एक map[string]interface{} उपयोग करना चाहिए क्योंकि हम जानते हैं कि चाबियाँ तार हैं, लेकिन हम पहले से उनके मूल्यों के प्रकार को नहीं जानते हैं।
यह एक बहुत ही सरल तरीका है, लेकिन यह बेहद सीमित है। वास्तविक दुनिया में, आप आमतौर पर एक JSON को कस्टम-परिभाषित struct प्रकार में डिकोड करेंगे।
एक फाइल से JSON डेटा को डिकोड करना
JSON डेटा को फ़ाइलों से भी पढ़ा जा सकता है।
चलिए मान लेते हैं कि हमारे पास data.json नामक एक फाइल है जिसमें निम्नलिखित सामग्री है:
[
{
"Name" : "John Doe",
"Standard" : 4
},
{
"Name" : "Peter Parker",
"Standard" : 11
},
{
"Name" : "Bilbo Baggins",
"Standard" : 150
}
]
निम्न उदाहरण फ़ाइल को पढ़ता है और सामग्री को डीकोड करता है:
package main
import (
"encoding/json"
"fmt"
"log"
"os"
)
type Student struct {
Name string
Standard int `json:"Standard"`
}
func main() {
// open the file pointer
studentFile, err := os.Open("data.json")
if err != nil {
log.Fatal(err)
}
defer studentFile.Close()
// create a new decoder
var studentDecoder *json.Decoder = json.NewDecoder(studentFile)
if err != nil {
log.Fatal(err)
}
// initialize the storage for the decoded data
var studentList []Student
// decode the data
err = studentDecoder.Decode(&studentList)
if err != nil {
log.Fatal(err)
}
for i, student := range studentList {
fmt.Println("Student", i+1)
fmt.Println("Student name:", student.Name)
fmt.Println("Student standard:", student.Standard)
}
}
फ़ाइल data.json गो एक्जीक्यूटेबल प्रोग्राम की एक ही डायरेक्टरी में होना चाहिए। गो में फ़ाइलों के साथ काम करने के बारे में अधिक जानकारी के लिए गो फ़ाइल I / O प्रलेखन पढ़ें।
डिकोडिंग के लिए अनाम संरचनाओं का उपयोग करना
अनाम संरचना का उपयोग करने के साथ लक्ष्य केवल उस जानकारी को डीकोड करना है जिसके बारे में हम अपने ऐप को केवल एक फ़ंक्शन में उपयोग किए जाने वाले प्रकार के साथ लिटाने के बिना करते हैं।
jsonBlob := []byte(`
{
"_total": 1,
"_links": {
"self": "https://api.twitch.tv/kraken/channels/foo/subscriptions?direction=ASC&limit=25&offset=0",
"next": "https://api.twitch.tv/kraken/channels/foo/subscriptions?direction=ASC&limit=25&offset=25"
},
"subscriptions": [
{
"created_at": "2011-11-23T02:53:17Z",
"_id": "abcdef0000000000000000000000000000000000",
"_links": {
"self": "https://api.twitch.tv/kraken/channels/foo/subscriptions/bar"
},
"user": {
"display_name": "bar",
"_id": 123456,
"name": "bar",
"staff": false,
"created_at": "2011-06-16T18:23:11Z",
"updated_at": "2014-10-23T02:20:51Z",
"logo": null,
"_links": {
"self": "https://api.twitch.tv/kraken/users/bar"
}
}
}
]
}
`)
var js struct {
Total int `json:"_total"`
Links struct {
Next string `json:"next"`
} `json:"_links"`
Subs []struct {
Created string `json:"created_at"`
User struct {
Name string `json:"name"`
ID int `json:"_id"`
} `json:"user"`
} `json:"subscriptions"`
}
err := json.Unmarshal(jsonBlob, &js)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v", js)
आउटपुट: {Total:1 Links:{Next:https://api.twitch.tv/kraken/channels/foo/subscriptions?direction=ASC&limit=25&offset=25} Subs:[{Created:2011-11-23T02:53:17Z User:{Name:bar ID:123456}}]}
सामान्य मामले के लिए यह भी देखें: http://stackoverflow.com/documentation/go/994/json/4111/encoding-decoding-go-structs
JSON संरचना क्षेत्रों को कॉन्फ़िगर करना
निम्नलिखित उदाहरण पर विचार करें:
type Company struct {
Name string
Location string
}
कुछ फ़ील्ड्स छिपाएँ / छोड़ें
Revenue और Sales निर्यात करने के लिए, लेकिन उन्हें एन्कोडिंग / डिकोडिंग से छिपाएं, json:"-" उपयोग करें json:"-" या चर को लोअरकेस अक्षर से शुरू करने के लिए नाम बदलें। ध्यान दें कि यह चर को पैकेज के बाहर दिखाई देने से रोकता है।
type Company struct {
Name string `json:"name"`
Location string `json:"location"`
Revenue int `json:"-"`
sales int
}
खाली फील्ड्स को नजरअंदाज करें
Location को JSON में शामिल किए जाने से रोकने के लिए जब इसे इसके शून्य मान पर सेट किया जाए, तो json टैग में जोड़ें ,omitempty ।
type Company struct {
Name string `json:"name"`
Location string `json:"location,omitempty"`
}
निजी क्षेत्रों के साथ मार्कशीट की संरचना
एक अच्छे डेवलपर के रूप में आपने निर्यातित और गैर-निर्यातित दोनों क्षेत्रों के साथ निम्नलिखित संरचना बनाई है:
type MyStruct struct {
uuid string
Name string
}
खेल के मैदान में उदाहरण: https://play.golang.org/p/Zk94Il2ANZ
अब आप Marshal() इस संरचना को मान्य JSON में संग्रहित करना चाहते हैं जैसे कि etcd। हालांकि, बाद से uuid निर्यात नहीं किया है, json.Marshal() यह छोड़ देता है। क्या करें? अनाम संरचना और json.MarshalJSON() इंटरफ़ेस का उपयोग करें! यहाँ एक उदाहरण है:
type MyStruct struct {
uuid string
Name string
}
func (m MyStruct) MarshalJSON() ([]byte, error {
j, err := json.Marshal(struct {
Uuid string
Name string
}{
Uuid: m.uuid,
Name: m.Name,
})
if err != nil {
return nil, err
}
return j, nil
}
खेल के मैदान में उदाहरण: https://play.golang.org/p/Bv2k9GgbzE
गो स्ट्रक्चर्स का उपयोग करके एन्कोडिंग / डिकोडिंग
मान लेते हैं कि हमारे पास निम्नलिखित struct जो City प्रकार को परिभाषित करती है:
type City struct {
Name string
Temperature int
}
हम encoding/json पैकेज का उपयोग करके सिटी मान को एनकोड / डिकोड कर सकते हैं।
सबसे पहले, हमें गो मेटाडेटा का उपयोग करने की आवश्यकता है ताकि एनकोडर को संरचनात्मक क्षेत्रों और JSON कुंजियों के बीच पत्राचार बता सकें।
type City struct {
Name string `json:"name"`
Temperature int `json:"temp"`
// IMPORTANT: only exported fields will be encoded/decoded
// Any field starting with a lower letter will be ignored
}
इस उदाहरण को सरल रखने के लिए, हम फ़ील्ड और कुंजियों के बीच एक स्पष्ट पत्राचार की घोषणा करेंगे। हालाँकि, आप json: में बताए अनुसार , json: मेटाडाटा के कई वेरिएंट का उपयोग कर सकते हैं।
महत्वपूर्ण: केवल निर्यात किए गए फ़ील्ड (कैपिटल नाम वाले फ़ील्ड) क्रमबद्ध / deserialized होंगे। उदाहरण के लिए, यदि आप फील्ड टी एम्परेशन का नाम देते हैं तो इसे अनदेखा कर दिया जाएगा भले ही आप json मेटाडेटा सेट करें।
एन्कोडिंग
City संरचना को एनकोड करने के लिए, json.Marshal उपयोग मूल उदाहरण के रूप में करें:
// data to encode
city := City{Name: "Rome", Temperature: 30}
// encode the data
bytes, err := json.Marshal(city)
if err != nil {
panic(err)
}
fmt.Println(string(bytes))
// {"name":"Rome","temp":30}
डिकोडिंग
City संरचना को डिकोड करने के लिए, json.Unmarshal उपयोग मूल उदाहरण के रूप में करें:
// data to decode
bytes := []byte(`{"name":"Rome","temp":30}`)
// initialize the container for the decoded data
var city City
// decode the data
// notice the use of &city to pass the pointer to city
if err := json.Unmarshal(bytes, &city); err != nil {
panic(err)
}
fmt.Println(city)
// {Rome 30}
