区分大小写的JSON Unmarshal结构（json区分大小写吗）

25-02-09 21

对于想了解区分大小写的JSONUnmarshal结构的读者，本文将是一篇不可错过的文章，我们将详细介绍json区分大小写吗，并且为您提供关于GojsonMarshal&UnMarshal的一点小tri

对于想了解区分大小写的JSON Unmarshal结构的读者，本文将是一篇不可错过的文章，我们将详细介绍json区分大小写吗，并且为您提供关于Go json Marshal & UnMarshal 的一点小 trick、go json 解析 Marshal 和 Unmarshal、Go 的 json 解析：Marshal 与 Unmarshal、GoLang中的Marshall和UnMarshall JSON内容的有价值信息。

本文目录一览：

区分大小写的JSON Unmarshal结构（json区分大小写吗）
Go json Marshal & UnMarshal 的一点小 trick
go json 解析 Marshal 和 Unmarshal
Go 的 json 解析：Marshal 与 Unmarshal
GoLang中的Marshall和UnMarshall JSON内容

区分大小写的JSON Unmarshal结构（json区分大小写吗）

有什么办法可以使json.Unmarshal 不接受不区分大小写的匹配？我收到带有标签的JSON，例如“ e”和“ E”，并想解组带有标签“
e”的对象，但忽略带有“ E”的对象。现在，我发现的唯一解决方案是定义一个包含两个标签的结构，然后简单地忽略标签“
E”，但是我正在寻找一种更清洁的解决方案。

从官方文档：

为了将JSON解组到结构中，Unmarshal将传入的对象键与Marshal使用的键（结构字段名称或其标记）进行匹配，希望使用精确匹配，但还要接受不区分大小写的匹配。

答案1

小编典典

不幸的是，标准json库当前不支持此功能。

根据https://golang.org/pkg/encoding/json/#Unmarshal

Unmarshal将传入的对象键与Marshal使用的键（结构字段名称或其标记）进行匹配，更喜欢完全匹配，但也接受不区分大小写的匹配

无法关闭此行为。

Go json Marshal & UnMarshal 的一点小 trick

在编写 Web Service 等涉及数据序列化和反序列化的场景，对于 JSON 类型的数据，在 Go 中我们经常会使用到 encoding/json Package。最近微有所感，小水一篇

omitempty

JSON 数据的 UnMarshal 我们经常会配合 Struct Tags 使用，让 Struct 的 Filed 与 JSON 数据的指定 property 绑定。

如果要序列化为 Go Struct 的 JSON 数据对应的 Fields 相关的 JSON properties 是缺失的，我们经常会用 omitempty 标记 Go Fields，序列化时，JSON 数据中缺少的属性将会被设置为 Go 中对应的 zero-value，比如：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  string `json:"age,omitempty"`
    Weak bool   `json:"weak,omitempty"`
}

func main() {
    jsonData := `{"name":"ShanSan"}`
    req := Person{}
    _ = json.Unmarshal([]byte(jsonData), &req)
    fmt.Printf("%+v", req)
    fmt.Println(req.Age)
}
// output
// {Name:ShanSan Age: Weak:false}
//

Go Playground Link

但上面的例子对于一些场景的处理可能会有问题。看下下面这个例子：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  string `json:"age,omitempty"`
    Weak bool   `json:"weak,omitempty"`
}

func main() {
    jsonData := `{"name":"ShanSan", "age": ""}`
    req := Person{}
    _ = json.Unmarshal([]byte(jsonData), &req)
    fmt.Printf("%+v", req)
    fmt.Println(req.Age)
}
// output
// {Name:ShanSan Age: Weak:false}
//

可以看到 age 为 "" 时，和缺省时的结果是一样的。很显然，上面的写法，缺省的字段和空字段是没有被区分开的。对于一些数据的 Update 操作，比如我们只想 Update Name 字段，对应的 JSON 数据为 {"name":"ShanSan"}，执行上述的反序列化动作，Age 字段会被设置为 empty string，Waek 也被设置为了 false，这显然不是我们想看到的。

nil 一下

我们可以指针类型（pointer type）对上面的情况区分一下：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name *string `json:"name"`
    Age  *string `json:"age,omitempty"`
    Weak *bool   `json:"weak,omitempty"`
}

func main() {
    jsonData := `{"name":"ShanSan"}`
    jsonDataEmptyAge := `{"name":"ShanSan", "age": ""}`
    req := Person{}
    reqEmptyAge := Person{}
    _ = json.Unmarshal([]byte(jsonData), &req)
    _ = json.Unmarshal([]byte(jsonDataEmptyAge), &reqEmptyAge)
    fmt.Printf("%+v", req)
    fmt.Printf("%+v", reqEmptyAge)
}
// {Name:0xc000010390 Age:<nil> Weak:<nil>}{Name:0xc0000103c0 Age:0xc0000103d0 Weak:<nil>}

emmm，缺省的字段为 nil 了。

Marshal 的时候

序列化 struct 的时候，如果使用了 omitempty，也会出现类似上面反序列化的情况，对于缺省的 field 或者 zero-value，序列化得到的 JSON 数据也会缺省相关属性，此时我们也可以通过 pointer 保留相关字段，如下：

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string `json:"name"`
    Score int    `json:"score,omitempty"`
}

type StudentWithPointer struct {
    Name  string `json:"name"`
    Score *int   `json:"score,omitempty"`
}

func main() {
    student := Student{
        Name:  "ShanSan",
        Score: 0,
    }

    score := 0
    studentWithPointer := StudentWithPointer{
        Name:  "ShanSan",
        Score: &score,
    }

    data, _ := json.Marshal(student)
    dataWithPointer, _ := json.Marshal(studentWithPointer)
    fmt.Println(string(data))
    fmt.Println(string(dataWithPointer))
}
// {"name":"ShanSan"}
// {"name":"ShanSan","score":0}

Go Playground

参考

encoding/json
Differentiate between empty and not-set fields with JSON in Golang
Go''s "omitempty" explained

本文由博客一文多发平台 OpenWrite 发布！

go json 解析 Marshal 和 Unmarshal

Decoder:

package main
import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "strings"
)
func main ( ) {
    const jsonStream = `
        { "Name" : "Ed" , "Text" : "Knock knock." }
        { "Name" : "Sam" , "Text" : "Who''s there?" }
        { "Name" : "Ed" , "Text" : "Go fmt." }
        { "Name" : "Sam" , "Text" : "Go fmt who?" }
        { "Name" : "Ed" , "Text" : "Go fmt yourself!" }
    `
    type Message struct {
        Name , Text string
    }
    dec := json. NewDecoder ( strings. NewReader ( jsonStream ) )
    for {
        var m Message
        if err := dec. Decode ( & m ) ; err == io. EOF {
            break
        } else if err != nil {
            log . Fatal ( err )
        }
        fmt. Printf ( "%s: %s \n " , m. Name , m. Text )
    }
}

Marshal:

package main
import (
    "encoding/json"
    "fmt"
    "os"
)
func main ( ) {
    type ColorGroup struct {
        ID     int
        Name   string
        Colors [ ] string
    }
    group := ColorGroup {
        ID :     1 ,
        Name :   "Reds" ,
        Colors : [ ] string { "Crimson" , "Red" , "Ruby" , "Maroon" } ,
    }
    b , err := json. Marshal ( group )
    if err != nil {
        fmt. Println ( "error:" , err )
    }
    os. Stdout . Write ( b )
}

RawMessage :

package main
import (
    "encoding/json"
    "fmt"
    "log"
)
func main ( ) {
    type Color struct {
        Space string
        Point json. RawMessage // delay parsing until we know the color space
    }
    type RGB struct {
        R uint8
        G uint8
        B uint8
    }
    type YCbCr struct {
        Y   uint8
        Cb int8
        Cr int8
    }
    var j = [ ] byte ( ` [
        { "Space" : "YCbCr" , "Point" : { "Y" : 255 , "Cb" : 0 , "Cr" : - 10 } } ,
        { "Space" : "RGB" ,   "Point" : { "R" : 98 , "G" : 218 , "B" : 255 } }
    ] ` )
    var colors [ ] Color
    err := json. Unmarshal ( j , & colors )
    if err != nil {
        log . Fatalln ( "error:" , err )
    }
    for _ , c := range colors {
        var dst interface { }
        switch c. Space {
        case "RGB" :
            dst = new ( RGB )
        case "YCbCr" :
            dst = new ( YCbCr )
        }
        err := json. Unmarshal ( c. Point , dst )
        if err != nil {
            log . Fatalln ( "error:" , err )
        }
        fmt. Println ( c. Space , dst )
    }
}

Unmarshal:

package main
import (
    "encoding/json"
    "fmt"
)
func main ( ) {
    var jsonBlob = [ ] byte ( ` [
        { "Name" : "Platypus" , "Order" : "Monotremata" } ,
        { "Name" : "Quoll" ,     "Order" : "Dasyuromorphia" }
    ] ` )
    type Animal struct {
        Name  string
        Order string
    }
    var animals [ ] Animal
    err := json. Unmarshal ( jsonBlob , & animals )
    if err != nil {
        fmt. Println ( "error:" , err )
    }
    fmt. Printf ( "%+v" , animals )
}

Go 的 json 解析：Marshal 与 Unmarshal

简介
Json (Javascript Object Nanotation) 是一种数据交换格式，常用于前后端数据传输。任意一端将数据转换成 json 字符串，另一端再将该字符串解析成相应的数据结构，如 string 类型，strcut 对象等。

go 语言本身为我们提供了 json 的工具包”encoding/json”。
更多的使用方式，可以参考：https://studygolang.com/articles/6742

实现
Json Marshal：将数据编码成 json 字符串
看一个简单的例子

type Stu struct {
    Name  string `json:"name"` Age int HIgh bool sex string Class *Class `json:"class"` } type Class struct { Name string Grade int } func main() { //实例化一个数据结构，用于生成json字符串 stu := Stu{ Name: "张三", Age: 18, HIgh: true, sex: "男", } //指针变量 cla := new(Class) cla.Name = "1班" cla.Grade = 3 stu.Class=cla //Marshal失败时err!=nil jsonStu, err := json.Marshal(stu) if err != nil { fmt.Println("生成json字符串错误") } //jsonStu是[]byte类型，转化成string类型便于查看 fmt.Println(string(jsonStu)) }

结果：

{"name":"张三","Age":18,"HIgh":true,"class":{"Name":"1班","Grade":3}}

从结果中可以看出

只要是可导出成员（变量首字母大写），都可以转成 json。因成员变量 sex 是不可导出的，故无法转成 json。

如果变量打上了 json 标签，如 Name 旁边的 json:"name" ，那么转化成的 json key 就用该标签 “name”，否则取变量名作为 key，如 “Age”，“HIgh”。

bool 类型也是可以直接转换为 json 的 value 值。Channel， complex 以及函数不能被编码 json 字符串。当然，循环的数据结构也不行，它会导致 marshal 陷入死循环。

指针变量，编码时自动转换为它所指向的值，如 cla 变量。
（当然，不传指针，Stu struct 的成员 Class 如果换成 Class struct 类型，效果也是一模一样的。只不过指针更快，且能节省内存空间。）

最后，强调一句：json 编码成字符串后就是纯粹的字符串了。

上面的成员变量都是已知的类型，只能接收指定的类型，比如 string 类型的 Name 只能赋值 string 类型的数据。
但有时为了通用性，或使代码简洁，我们希望有一种类型可以接受各种类型的数据，并进行 json 编码。这就用到了 interface {} 类型。

前言：
interface {} 类型其实是个空接口，即没有方法的接口。go 的每一种类型都实现了该接口。因此，任何其他类型的数据都可以赋值给 interface {} 类型。

type Stu struct {
    Name  interface{} `json:"name"` Age interface{} HIgh interface{} sex interface{} Class interface{} `json:"class"` } type Class struct { Name string Grade int } func main() { //与前面的例子一样 ...... }

结果：

{"name":"张三","Age":18,"HIgh":true,"class":{"Name":"1班","Grade":3}}

从结果中可以看出，无论是 string，int，bool，还是指针类型等，都可赋值给 interface {} 类型，且正常编码，效果与前面的例子一样。

补充：
在实际项目中，编码成 json 串的数据结构，往往是切片类型。如下定义了一个 [] StuRead 类型的切片

//正确示范

//方式1：只声明，不分配内存
var stus1 []*StuRead //方式2：分配初始值为0的内存 stus2 := make([]*StuRead,0) //错误示范 //new()只能实例化一个struct对象，而[]StuRead是切片，不是对象 stus := new([]StuRead) stu1 := StuRead{成员赋值...} stu2 := StuRead{成员赋值...} //由方式1和2创建的切片，都能成功追加数据 //方式2最好分配0长度，append时会自动增长。反之指定初始长度，长度不够时不会自动增长，导致数据丢失 stus1 := appen(stus1,stu1,stu2) stus2 := appen(stus2,stu1,stu2) //成功编码 json1,_ := json.Marshal(stus1) json2,_ := json.Marshal(stus2)

解码时定义对应的切片接受即可

Json Unmarshal：将 json 字符串解码到相应的数据结构
我们将上面的例子进行解码

type StuRead struct {
    Name  interface{} `json:"name"` Age interface{} HIgh interface{} sex interface{} Class interface{} `json:"class"` Test interface{} } type Class struct { Name string Grade int } func main() { //json字符中的"引号，需用\进行转义，否则编译出错 //json字符串沿用上面的结果，但对key进行了大小的修改，并添加了sex数据 data:="{\"name\":\"张三\",\"Age\":18,\"high\":true,\"sex\":\"男\",\"CLASS\":{\"naME\":\"1班\",\"GradE\":3}}" str:=[]byte(data) //1.Unmarshal的第一个参数是json字符串，第二个参数是接受json解析的数据结构。 //第二个参数必须是指针，否则无法接收解析的数据，如stu仍为空对象StuRead{} //2.可以直接stu:=new(StuRead),此时的stu自身就是指针 stu:=StuRead{} err:=json.Unmarshal(str,&stu) //解析失败会报错，如json字符串格式不对，缺"号，缺}等。 if err!=nil{ fmt.Println(err) } fmt.Println(stu) }

结果：

{张三 18 true <nil> map[naME:1班 GradE:3] <nil>}

总结：

json 字符串解析时，需要一个 “接收体” 接受解析后的数据，且 Unmarshal 时接收体必须传递指针。否则解析虽不报错，但数据无法赋值到接受体中。如这里用的是 StuRead {} 接收。

解析时，接收体可自行定义。json 串中的 key 自动在接收体中寻找匹配的项进行赋值。匹配规则是：

先查找与 key 一样的 json 标签，找到则赋值给该标签对应的变量 (如 Name)。
没有 json 标签的，就从上往下依次查找变量名与 key 一样的变量，如 Age。或者变量名忽略大小写后与 key 一样的变量。如 HIgh，Class。第一个匹配的就赋值，后面就算有匹配的也忽略。
(前提是该变量必需是可导出的，即首字母大写)。
不可导出的变量无法被解析（如 sex 变量，虽然 json 串中有 key 为 sex 的 k-v，解析后其值仍为 nil, 即空值）

当接收体中存在 json 串中匹配不了的项时，解析会自动忽略该项，该项仍保留原值。如变量 Test，保留空值 nil。

你一定会发现，变量 Class 貌似没有解析为我们期待样子。因为此时的 Class 是个 interface {} 类型的变量，而 json 串中 key 为 CLASS 的 value 是个复合结构，不是可以直接解析的简单类型数据（如 “张三”，18，true 等）。所以解析时，由于没有指定变量 Class 的具体类型，json 自动将 value 为复合结构的数据解析为 map [string] interface {} 类型的项。也就是说，此时的 struct Class 对象与 StuRead 中的 Class 变量没有半毛钱关系，故与这次的 json 解析没有半毛钱关系。

让我们看一下这几个 interface {} 变量解析后的类型

func main() { //与前边json解析的代码一致 ... fmt.Println(stu) //打印json解析前变量类型 err:=json.Unmarshal(str,&stu) fmt.Println("--------------json 解析后-----------") ... fmt.Println(stu) //打印json解析后变量类型 } //利用反射，打印变量类型 func printType(stu *StuRead){ nameType:=reflect.TypeOf(stu.Name) ageType:=reflect.TypeOf(stu.Age) highType:=reflect.TypeOf(stu.HIgh) sexType:=reflect.TypeOf(stu.sex) classType:=reflect.TypeOf(stu.Class) testType:=reflect.TypeOf(stu.Test) fmt.Println("nameType:",nameType) fmt.Println("ageType:",ageType) fmt.Println("highType:",highType) fmt.Println("sexType:",sexType) fmt.Println("classType:",classType) fmt.Println("testType:",testType) }

结果：

nameType: <nil>
ageType: <nil> highType: <nil> sexType: <nil> classType: <nil> testType: <nil> --------------json 解析后----------- nameType: string ageType: float64 highType: bool sexType: <nil> classType: map[string]interface {} testType: <nil>

从结果中可见

interface {} 类型变量在 json 解析前，打印出的类型都为 nil，就是没有具体类型，这是空接口（interface {} 类型）的特点。

json 解析后，json 串中 value，只要是” 简单数据”，都会按照默认的类型赋值，如” 张三” 被赋值成 string 类型到 Name 变量中，数字 18 对应 float64，true 对应 bool 类型。

“简单数据”：是指不能再进行二次 json 解析的数据，如”name”:” 张三” 只能进行一次 json 解析。
“复合数据”：类似”CLASS\”:{\”naME\”:\”1 班 \”,\”GradE\”:3} 这样的数据，是可进行二次甚至多次 json 解析的，因为它的 value 也是个可被解析的独立 json。即第一次解析 key 为 CLASS 的 value，第二次解析 value 中的 key 为 naME 和 GradE 的 value

对于” 复合数据”，如果接收体中配的项被声明为 interface {} 类型，go 都会默认解析成 map [string] interface {} 类型。如果我们想直接解析到 struct Class 对象中，可以将接受体对应的项定义为该 struct 类型。如下所示：

type StuRead struct {
...
//普通struct类型
Class Class `json:"class"`
//指针类型
Class *Class `json:"class"`
}

stu 打印结果

Class类型：{张三 18 true <nil> {1班 3} <nil>} *Class类型：{张三 18 true <nil> 0xc42008a0c0 <nil>}

可以看出，传递 Class 类型的指针时，stu 中的 Class 变量存的是指针，我们可通过该指针直接访问所属的数据，如 stu.Class.Name/stu.Class.Grade

Class 变量解析后类型

classType: main.Class
classType: *main.Class

解析时，如果接受体中同时存在 2 个匹配的项，会发生什么呢？
测试 1

type StuRead struct {
    NAme interface{} Name interface{} NAMe interface{} `json:"name"` }

结果 1:

//当存在匹配的json标签时，其对应的项被赋值。
//切记：匹配的标签可以没有，但有时最好只有一个哦
{<nil> <nil> 张三}

测试 2

type StuRead struct {
    NAme interface{} Name interface{} NAMe interface{} `json:"name"` NamE interface{} `json:"name"` }

结果 2

//当匹配的json标签有多个时，标签对应的项都不会被赋值。
//忽略标签项，从上往下寻找第一个没有标签且匹配的项赋值
{张三 <nil> <nil> <nil>}

测试 3

type StuRead struct {
    NAme interface{} Name interface{} }

结果 3

//没有json标签时，从上往下，第一个匹配的项会被赋值哦
{张三 <nil>}

测试 4

type StuRead struct {
    NAMe interface{} `json:"name"` NamE interface{} `json:"name"` }

结果 4

//当相同的json标签有多个，且没有不带标签的匹配项时，报错了哦
# command-line-arguments
src/test/b.go:48: stu.Name undefined (type *StuRead has no field or method Name, but does have NAMe)

可见，与前边说过的匹配规则是一致的。

如果不想指定 Class 变量为具体的类型，仍想保留 interface {} 类型，但又希望该变量可以解析到 struct Class 对象中，这时候该怎么办呢？

这种需求是很可能存在的，例如笔者我就碰到了

办法还是有的，我们可以将该变量定义为 json.RawMessage 类型

type StuRead struct {
    Name  interface{} Age interface{} HIgh interface{} Class json.RawMessage `json:"class"` //注意这里 } type Class struct { Name string Grade int } func main() { data:="{\"name\":\"张三\",\"Age\":18,\"high\":true,\"sex\":\"男\",\"CLASS\":{\"naME\":\"1班\",\"GradE\":3}}" str:=[]byte(data) stu:=StuRead{} _:=json.Unmarshal(str,&stu) //注意这里：二次解析！ cla:=new(Class) json.Unmarshal(stu.Class,cla) fmt.Println("stu:",stu) fmt.Println("string(stu.Class):",string(stu.Class)) fmt.Println("class:",cla) printType(&stu) //函数实现前面例子有 }

结果

stu: {张三 18 true [123 34 110 97 77 69 34 58 34 49 231 143 173 34 44 34 71 114 97 100 69 34 58 51 125]}
string(stu.Class): {"naME":"1班","GradE":3}
class: &{1班 3}
nameType: string
ageType: float64
highType: bool
classType: json.RawMessage

从结果中可见

接收体中，被声明为 json.RawMessage 类型的变量在 json 解析时，变量值仍保留 json 的原值，即未被自动解析为 map [string] interface {} 类型。如变量 Class 解析后的值为：{“naME”:”1 班”,”GradE”:3}

从打印的类型也可以看出，在第一次 json 解析时，变量 Class 的类型是 json.RawMessage。此时，我们可以对该变量进行二次 json 解析，因为其值仍是个独立且可解析的完整 json 串。我们只需再定义一个新的接受体即可，如 json.Unmarshal (stu.Class,cla)

GoLang中的Marshall和UnMarshall JSON内容

我有一个示例json文件，其结构如下

{
  "method":"brute_force","bc":"select * from blah;","gc":[
    "select sum(year) from blah;","select count(*) from table;"
      ]
}

我正在尝试编写一个go程序，该程序可以读取此文件并操作json内容。

package main 
import (
    "fmt"
    "encoding/json"
    "io/ioutil"
    )


type Response2 struct {
    method string
    bc string
    gc []string
}

func main() {
    file,_ := ioutil.ReadFile("config.json")
    fmt.Printf("%s",string(file))

        res := &Response2{}


        json.Unmarshal([]byte(string(file)),&res)
        fmt.Println(res)

        fmt.Println(res.method)
        fmt.Println(res.gc)

}

res.method和res.gc不打印任何内容。我不知道怎么了。

关于区分大小写的JSON Unmarshal结构和json区分大小写吗的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Go json Marshal & UnMarshal 的一点小 trick、go json 解析 Marshal 和 Unmarshal、Go 的 json 解析：Marshal 与 Unmarshal、GoLang中的Marshall和UnMarshall JSON内容等相关知识的信息别忘了在本站进行查找喔。

本文标签：