快捷導(dǎo)航

Go json反序列化“null“的問題解決

更新時(shí)間：2023年03月14日 11:03:43 作者：NJU_lemon

本文主要介紹了Go json反序列化“null“的問題解決，文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

func mergeContent(inputJson string, inputMap map[string]interface{}) (map[string]interface{}, error) {
	jsonMap := make(map[string]interface{})
	if inputJson != "" {
		decoder := jsoniter.NewDecoder(strings.NewReader(inputJson))
		decoder.UseNumber()
		if err := decoder.Decode(&jsonMap); err != nil {
			return nil, err
		}
	}
	//merge
	for k, v := range inputMap {
		jsonMap[k] = v
	}
	return jsonMap, nil
}

看上去是不是一段很健康的代碼?
結(jié)合標(biāo)題再看看呢?
如果輸入的json字符串是"null"會(huì)發(fā)生什么呢?

實(shí)驗(yàn)

func main(){
	inputMap := make(map[string]interface{})
	inputMap["test"] = 1
	outputMap, err := mergeContent("null", inputMap)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	fmt.Printf("output:%+v\n", outputMap)
}

不出意外的話,要出意外了

它說我給一個(gè)nil map賦值了,但我明明在反序列化之前給jsonMap初始化了的,原來,jsoniter這個(gè)庫(kù)【其他庫(kù)沒測(cè)】在進(jìn)行json序列化時(shí)，會(huì)把nil【即指針類型（比如slice、map和*T）的未初始化時(shí)的形態(tài)】序列化為字符串"null"，反序列化時(shí)會(huì)把字符串"null"，如果目標(biāo)類型是指針類型，則會(huì)反序列化為nil

其他測(cè)試

知道現(xiàn)象和原因之后,我又測(cè)試了些其他的東西
需要注意的是fmt很多時(shí)候打印nil的指針類型時(shí)不會(huì)輸出nil，比如nil的slice和map，會(huì)打印成[]和map[]；

package main

import (
   "fmt"
   jsoniter "github.com/json-iterator/go"
)

type Marshaler struct {
   A map[string]interface{}
   B []string
   C [10]int
   D *string
   E *EE
   F string
   g string
}
type EE struct {
   EEE []string
}

func main() {
   mal := Marshaler{
      E: &EE{},
   }
   mal1 := &Marshaler{}
   e1 := &EE{}
   e2 := EE{EEE: []string{}}
   var t1 *string
   var t2 []int
   var t3 map[string]interface{}
   var t4 = make([]string, 0)
   res1, _ := jsoniter.MarshalToString(mal)
   res2, _ := jsoniter.MarshalToString(mal1)
   res3, _ := jsoniter.MarshalToString(e1)
   res4, _ := jsoniter.MarshalToString(e2)
   res5, _ := jsoniter.MarshalToString(t1)
   res6, _ := jsoniter.MarshalToString(t2)
   res7, _ := jsoniter.MarshalToString(t3)
   res8, _ := jsoniter.MarshalToString(t4)
   fmt.Printf("res1: %+v\n", res1)
   fmt.Printf("res2: %+v\n", res2)
   fmt.Printf("res3: %+v\n", res3)
   fmt.Printf("res4: %+v\n", res4)
   fmt.Printf("res5: %+v\n", res5)
   fmt.Printf("res6: %+v\n", res6)
   fmt.Printf("res7: %+v\n", res7)
   fmt.Printf("res8: %+v\n", res8)

   params := make(map[string]interface{})
   if err := jsoniter.Unmarshal([]byte(res6), &params); err != nil {
      fmt.Println("null Unmarshal err:", err)
   } else {
      fmt.Printf("null Unmarshal map:  %+v\n", params)
   }

   if err := jsoniter.Unmarshal([]byte(res6), &mal); err != nil {
      fmt.Println("null Unmarshal err:", err)
   } else {
      fmt.Printf("null Unmarshal Marshaler: %+v\n", mal)
   }

   if err := jsoniter.Unmarshal([]byte(res6), &mal1); err != nil {
      fmt.Println("null Unmarshal err:", err)
   } else {
      fmt.Printf("null Unmarshal Marshaler: %+v\n", mal1)
   }

   if err := jsoniter.Unmarshal([]byte(res6), &t4); err != nil {
      fmt.Println("null Unmarshal err:", err)
   } else {
      fmt.Printf("null Unmarshal []string: %+v\n", t4)
      fmt.Println(t4 == nil)
   }
}

輸出：

res1: {"A":null,"B":null,"C":[0,0,0,0,0,0,0,0,0,0],"D":null,"E":{"EEE":null},"F"
:""}
res2: {"A":null,"B":null,"C":[0,0,0,0,0,0,0,0,0,0],"D":null,"E":null,"F":""}
res3: {"EEE":null}
res4: {"EEE":[]}
res5: null
res6: null
res7: null
res8: []
//下面的打印不夠準(zhǔn)確，看debug截圖
null Unmarshal map: map[]
null Unmarshal Marshaler: {A:map[] B:[] C:[0 0 0 0 0 0 0 0 0 0] D:<nil> E:0xc000
004510 F: g:}
null Unmarshal Marshaler: <nil>
null Unmarshal []string: []
true

補(bǔ)充說明

默認(rèn)的反序列化是用float64來接數(shù)字類型的，原來的數(shù)字太大會(huì)出現(xiàn)精度丟失問題

"null"用int或float32等基礎(chǔ)數(shù)字類型來接會(huì)變成默認(rèn)值0

很多json庫(kù)在反序列化時(shí)都會(huì)存在精度丟失問題，比如int64的最后幾位變成0，是因?yàn)椴幻鞔_json字符串代表的struct的場(chǎng)景下，用map[string]interface{}來接反序列化之后的內(nèi)容，會(huì)默認(rèn)用float64來接數(shù)字類型，“int64是將64bit的數(shù)據(jù)全部用來存儲(chǔ)數(shù)據(jù)，但是float64需要表達(dá)的信息更多，因此float64單純用于數(shù)據(jù)存儲(chǔ)的位數(shù)將小于64bit，這就導(dǎo)致了float64可存儲(chǔ)的最大整數(shù)是小于int64的。”，理論上數(shù)值超過9007199254740991就可能會(huì)出現(xiàn)精度缺失，反序列化時(shí)需要針對(duì)數(shù)字類型單獨(dú)處理【用struct來接，并且保證類型能對(duì)應(yīng)上就不會(huì)有以上問題】：