JSON के साथ काम करना सरल और स्पष्ट लग सकता है, आपके पास कुछ संरचना है, आप इसे JSON में बदल सकते हैं - एक सामान्य एकीकृत भाषा और अपनी संरचना में वापस। सरल सही? ?

ठीक है, हाँ, लेकिन ऐसा तब तक है जब तक आपको मार्शल/अनमर्शल फ़ंक्शंस से कुछ अजीब व्यवहार का सामना नहीं करना पड़ता।

संकट ?

यह सब तब शुरू हुआ जब मैं जेडब्ल्यूटी टोकन से एन्कोडेड पेलोड को पढ़ने की कोशिश कर रहा था, नीचे एक उदाहरण है जो समस्या को दर्शाता है

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    ID      int64   `json:"id"`
    PostIDs []int64 `json:"post_ids"`
}

func main() {
    u := User{
        ID:      1,
        PostIDs: []int64{1, 2, 3},
    }

    b, err := json.Marshal(u)
    if err != nil {
        panic(err)
    }

    m := make(map[string]interface{})
    if err = json.Unmarshal(b, &m); err != nil {
        panic(err)
    }

    userID, ok := m["id"].(int64)
    fmt.Printf("id: %d\nOk:%t\n", userID, ok)

    fmt.Println() // spliter

    postIDs, ok := m["id"].([]int64)
    fmt.Printf("post_ids: %v\nOk:%t\n", postIDs, ok)
}

बस मार्शलिंग और अनमर्शलिंग बैक आउट स्ट्रक्चर, इसलिए इससे समान मान वापस आने की उम्मीद है!

दुर्भाग्य से, ऐसा नहीं हुआ, उपरोक्त कोड आउटपुट देता है

// Result
id: 0
Ok:false

post_ids: []
Ok:false

एक बार जब मैंने वह आउटपुट देखा, तो मैं ? समस्या प्रकार रूपांतरणों के साथ हो सकती है, इसलिए मैं यह जांचने गया कि ये इंटरफ़ेस किस प्रकार के हैं

    fmt.Printf("id: %T\n", m["id"])
    fmt.Printf("post_ids: %T\n", m["post_ids"])

// Result
id: float64
post_ids: []interface {}

इसलिए जैसा कि हम देख सकते हैं, JSON ने int64 को फ्लोट64 के रूप में पार्स किया है, जिससे डेटा पढ़ने पर समस्याएं पैदा होती हैं।

वास्तव में इस समस्या को ठीक करने के 2 तरीके हैं

? समाधान 01 (कठिन तरीका)

फ्लोट64 के प्रकार के दावे का उपयोग करें, ध्यान दें कि []इंटरफ़ेस{} को तुरंत []फ्लोट64 पर मैप नहीं किया जा सकता है, इसलिए हमें प्रत्येक तत्व को पुनरावृत्त करना होगा और इसे परिवर्तित करना होगा

        // Parse UserID
    userID, _ := m["id"].(float64)
    fmt.Printf("id: %f\n", userID)

    fmt.Println() // spliter

    // Parse PostIDs
    postIDsArr, _ := m["post_ids"].([]interface{})
    postIDs := make([]int64, len(postIDsArr))
    for i, v := range postIDsArr {
        id, _ := v.(float64) // NOTICE: direct conversion to int64 won't work here!
        postIDs[i] = int64(id)
    }

    fmt.Printf("post_ids: %v\n", postIDs)

// Result
id: 1.000000

post_ids: [1 2 3]

? समाधान 02 (आसान तरीका)

इसे वापस एक संरचना में पार्स करें

    b, err = json.Marshal(m) // m = map[string]interface{}
    if err != nil {
        panic(err)
    }

    var u2 User
    if err := json.Unmarshal(b, &u2); err != nil {
        panic(err)
    }

    fmt.Println(u2.ID)
    fmt.Println(u2.PostIDs)

बेशक, आप सोच सकते हैं कि हमें समाधान 01 का उपयोग क्यों करना चाहिए, क्या समाधान 02 बेहतर नहीं है?

खैर यह निर्भर करता है, आप हमेशा किसी संरचना से एक विशेषता को पढ़ने के लिए एक संरचना नहीं बनाना चाहते हैं, इसलिए सही उत्तर है - यह निर्भर करता है!

मुझे लगता है कि आज के लेख के लिए बस इतना ही, काश आप कुछ नया सीखते, मेरे साथी गोफर?.