Golang membantah json

Menukar objek kepada json dalam golang adalah perkara yang sangat biasa, saya percaya kebanyakan pembangun golang akan menemuinya. Artikel ini akan berkongsi kaedah dan teknik tentang cara menukar objek kepada json dalam golang.

1. Menggunakan pakej pengekodan/json

Mula-mula, mari lihat pakej pengekodan/json yang disediakan dalam pustaka standard golang. Pakej ini menyediakan fungsi dan jenis yang sangat ringkas dan mudah digunakan yang membolehkan kita menukar objek kepada rentetan berformat json atau menukar rentetan berformat json menjadi objek.

Perlu diambil perhatian bahawa objek mesti boleh dieksport (iaitu huruf pertama huruf besar), jika tidak pakej json tidak boleh mengakses medannya.

Berikut ialah contoh kod mudah yang menggunakan pengekodan/pakej json untuk menukar objek Pelajar kepada rentetan format json:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string
    Age   int
    Score float64
}

func main() {
    s := Student{
        Name:  "Tom",
        Age:   18,
        Score: 90.5,
    }
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))
}

Output:

{"Name":"Tom","Age":18,"Score":90.5}

Seperti yang anda boleh lihat, pakej json menyediakan Fungsi Marshal boleh menyerikan objek struktur ke dalam rentetan format json.

Untuk objek yang kompleks, kita juga boleh mensirikannya dengan mudah ke dalam rentetan format json. Sebagai contoh, tatasusunan berikut terdiri daripada berbilang objek Pelajar:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string
    Age   int
    Score float64
}

func main() {
    students := []Student{
        {Name: "Tom", Age: 18, Score: 90.5},
        {Name: "Jerry", Age: 19, Score: 96.5},
        {Name: "Alice", Age: 17, Score: 85.5},
    }
    b, err := json.Marshal(students)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))
}

Output:

[{"Name":"Tom","Age":18,"Score":90.5},{"Name":"Jerry","Age":19,"Score":96.5},{"Name":"Alice","Age":17,"Score":85.5}]

Begitu juga, kita boleh menggunakan fungsi Unmarshal yang disediakan oleh pakej json untuk menghuraikan rentetan format json ke dalam objek . Contohnya:

package main

import (
    "encoding/json"
    "fmt"
)

type Point struct {
    X int `json:"x"`
    Y int `json:"y"`
}

type Line struct {
    Start Point `json:"start"`
    End   Point `json:"end"`
}

func main() {
    jsonStr := `
    {
        "start": {
            "x": 1,
            "y": 2
        },
        "end": {
            "x": 3,
            "y": 4
        }
    }`
    var line Line
    err := json.Unmarshal([]byte(jsonStr), &line)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", line)
}

Output:

main.Line{Start:main.Point{X:1, Y:2}, End:main.Point{X:3, Y:4}}

Dalam kod sampel ini, kami mentakrifkan objek Garisan, yang mengandungi dua objek Titik. Gunakan fungsi Unmarshal yang disediakan oleh pakej json untuk menghuraikan rentetan format json ke dalam objek Line dan kemudian mengeluarkannya.

2. Sesuaikan siri json dan penyahserikatan melalui teg struktur

Jika kita ingin menyesuaikan output dalam format json, seperti mengubah suai nama medan , apa yang perlu dilakukan? Pada masa ini, tag struct dalam golang berguna.

Dalam golang, teg struct ialah cara untuk menganotasi medan struct, yang boleh dicapai dengan menambahkan rentetan selepas jenis medan. Apabila menggunakan pesirilan pakej json dan penyahserilan, kita boleh menggunakan tag struct untuk mengawal proses penyirian dan penyahserikatan.

Berikut ialah kod sampel ringkas yang menunjukkan cara menggunakan tag struct untuk mengawal proses pensirilan json dan penyahserikatan:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Score float64
}

func main() {
    s := Student{
        Name:  "Tom",
        Age:   18,
        Score: 90.5,
    }
    fmt.Println("*** 序列化 ***")
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))

    fmt.Println("*** 反序列化 ***")
    jsonStr := `{"name":"Tom","age":18,"Score":90.5}`
    var student Student
    err = json.Unmarshal([]byte(jsonStr), &student)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", student)
}

Output:

*** 序列化 ***
{"name":"Tom","age":18,"Score":90.5}
*** 反序列化 ***
main.Student{Name:"Tom", Age:18, Score:90.5}

Di sini, kami akan Medan Nama dalam objek Pelajar ditandakan sebagai "nama", supaya apabila disiri menggunakan fungsi json.Marshal, namanya akan ditukar kepada "nama". Begitu juga, apabila deserialisasi menggunakan fungsi json.Unmarshal, "nama" akan diiktiraf secara automatik sebagai medan Nama.

Melalui bentuk teg struct, kita juga boleh mengawal keterlihatan medan dalam output json. Contohnya:

package main

import (
    "encoding/json"
    "fmt"
)

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

func main() {
    s := Student{
        Age:   18,
        Score: 90.5,
    }
    fmt.Println("*** 序列化 ***")
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))

    fmt.Println("*** 反序列化 ***")
    jsonStr := `{"name":"Tom","age":18,"Score":90.5}`
    var student Student
    err = json.Unmarshal([]byte(jsonStr), &student)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", student)
}

Output:

*** 序列化 ***
{"age":18,"Score":90.5}
*** 反序列化 ***
main.Student{Name:"Tom", Age:18, Score:90.5}

Di sini kita menandakan medan Nama sebagai "penghilangan", yang bermaksud bahawa jika nilai medan Nama adalah sifar (iaitu ""), maka apabila json adalah output Abaikan sahaja medan ini.

3. Gunakan perpustakaan pihak ketiga

Apabila kita perlu melakukan pensirilan dan penyahsirilan json yang lebih kompleks, perpustakaan standard golang mungkin sedikit lemah. Pada masa ini, kami boleh menggunakan beberapa perpustakaan pihak ketiga untuk membantu kami mencapai operasi yang lebih fleksibel.

Berikut ialah kod sampel yang menggunakan pustaka pihak ketiga untuk pensirilan json dan penyahsirilan Kod sampel ini menggunakan pakej json-iterator/go, yang kini merupakan salah satu perpustakaan golang json yang terpantas.

package main

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

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

func main() {
    student := Student{
        Name:  "Tom",
        Age:   18,
        Score: 0,
    }
    fmt.Println("*** 序列化 ***")
    json := jsoniter.ConfigCompatibleWithStandardLibrary
    b, err := json.Marshal(student)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))

    fmt.Println("*** 反序列化 ***")
    jsonStr := `{"name":"Tom","age":18}`
    err = json.Unmarshal([]byte(jsonStr), &student)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", student)
}

Output:

*** 序列化 ***
{"name":"Tom","age":18}
*** 反序列化 ***
main.Student{Name:"Tom", Age:18, Score:0}

Perlu diambil perhatian bahawa walaupun menggunakan perpustakaan pihak ketiga boleh mencapai operasi json yang lebih fleksibel, ia juga mungkin menimbulkan masalah seperti penurunan prestasi atau peningkatan kerumitan kod perlu dibuat berdasarkan senario tertentu.

Artikel ini memperkenalkan beberapa kaedah dan teknik untuk menukar objek kepada json dalam golang saya harap artikel ini dapat membantu pembaca.

Atas ialah kandungan terperinci Golang membantah json. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!