Pergi dengan contoh Json Marshal dan Unmarshal

Di GO, pakej pengekodan/JSON digunakan untuk mengendalikan siri dan deserialization JSON. 1. Bidang struktur perlu diakses dengan huruf besar dalam huruf pertama. Tetapkan nama utama melalui JSON: "Nama". OmitEmpty Omits Fields Apabila nilai adalah sifar. JSON: "-" mengabaikan bidang; 2. Gunakan json.marshal untuk menukar struktur, peta atau slice ke rentetan json, dan gunakan json.unmarshal untuk menghuraikan data json ke dalam pembolehubah; 3. Apabila deserializing untuk antara muka {}, nombor lalai ke jenis Float64 dan perlu ditukar melalui penegasan jenis; 4. Struktur bersarang boleh bersiri secara normal, dan struktur tertanam akan diperluaskan; 5. Sentiasa periksa kesilapan dalam marshal dan unmarshal. Masalah biasa termasuk kesilapan format JSON, jenis ketidakcocokan, dan bidang yang tidak dieksport. Betul menggunakan tag struct dan struktur data boleh fleksibel mengendalikan pelbagai senario JSON.

Dalam bahasa Go, pakej encoding/json menyediakan sokongan untuk siriisasi (marshal) dan deserialization (unmarshal) data JSON. Berikut adalah beberapa contoh biasa untuk menunjukkan cara menggunakan json.Marshal dan json.Unmarshal .

✅ marshal dan unmarshal struktur asas

 Pakej utama

import (
    "Pengekodan/JSON"
    "FMT"
    "Log"
)

taipkan orang struct {
    Nama String `Json:" Nama "`
    Umur int `json:" umur "`
    E -mel rentetan `json:" e -mel, omitempty "`
}

func main () {
    // Contoh 1: Struktur Marshal → Json
    p: = orang {
        Nama: "Alice",
        Umur: 30,
        E -mel: "alice@example.com",
    }

    data, err: = json.marshal (p)
    jika err! = nil {
        log.fatal (err)
    }
    fmt.printf ("Hasil Marshal: %s \ n", data)

    // Contoh 2: Unmarshal JSON → Struktur jsondata: = `{" name ":" bob "," umur ": 25," e -mel ":" bob@example.com "}`
    var p2 orang
    err = json.unmarshal ([] byte (jsondata), & p2)
    jika err! = nil {
        log.fatal (err)
    }
    fmt.printf ("Hasil unmarshal: %v \ n", p2)
}

Output:

 Hasil Marshal: {"Name": "Alice", "Umur": 30, "E -mel": "Alice@example.com"}
Hasil Unmarshal: {Nama: Bob Umur: 25 E -mel: bob@example.com}

Notis:

• json:"name" Menentukan nama utama medan di JSON.
• omitempty bermakna bahawa jika medan adalah nilai sifar (seperti rentetan kosong, 0, nih, dll), ia ditinggalkan semasa siri.

✅ Marshal dan Unmarshal yang mengendalikan peta

 // peta marshal → json
M: = Map [String] Interface {} {
    "Nama": "Charlie",
    "Umur": 35,
    "tags": [] string {"go", "dev"},
}
data, _: = json.marshal (m)
fmt.printf ("peta ke json: %s \ n", data)

// unmarshal json → peta
var m2 peta [string] antara muka {}
jsondata: = `{" name ":" David "," umur ": 28," aktif ": true}`
json.unmarshal ([] byte (jsondata), & m2)
fmt.printf ("json to map: %v \ n", m2)

// Nota: Nombor dalam peta menyelesaikan float64 secara lalai
jika umur, ok: = m2 ["umur"]. (float64); ok {
    fmt.println ("umur:", int (umur))
}

Output:

 Peta ke json: {"umur": 35, "nama": "charlie", "tags": ["go", "dev"]}
JSON TO MAP: Peta [Umur: 28 Nama: David Aktif: Benar]
Umur: 28

⚠️ Nota: Apabila json.Unmarshal parses ke interface{} , nombornya adalah float64 secara lalai, dan ketegasan jenis diperlukan.

✅ Proses kepingan dan tatasusunan

 orang: = [] orang {
    {Nama: "Alice", Umur: 30},
    {Nama: "Bob", Umur: 25},
}

// Slice Marshal
data, _ = json.marshal (orang)
fmt.printf ("Slice to JSON: %s \ n", data)

// array unmarshal json → slice
jsondata: = `[{" name ":" eve "," umur ": 22}, {" name ":" Frank "," usia ": 33}]`
var orang2 [] orang
json.unmarshal ([] byte (jsondata), & people2)
fmt.printf ("json to slice: %v \ n", people2)

Output:

 Slice to Json: [{"Name": "Alice", "Umur": 30}, {"Name": "Bob", "Umur": 25}]
Json to Slice: [{Name: Eve Umur: 22 E -mel:} {Nama: Frank Umur: 33 Email:}]

✅ Abaikan medan kosong (menggunakan omitempty)

 p: = orang {
    Nama: "Grace",
    Umur: 0, // nilai sifar // Tinggalkan kosong dalam e -mel}

data, _ = json.marshal (p)
fmt.printf ("dengan omitempty: %s \ n", data)

Output:

 Dengan OmitEmpty: {"Name": "Grace"}

Kerana Age adalah 0 (nilai sifar int), tetapi tidak ada omitempty , ia masih akan output.
Email mempunyai omitempty dan kosong, jadi ia ditinggalkan.

Sekiranya anda ingin menghilangkan nilai sifar, anda boleh menulisnya seperti ini:

 Umur int `json:" umur, omitempty "`

✅ struktur bersarang dan nama medan tersuai

 Taipkan Alamat Struct {
    City String `Json:" City "`
    Zip String `json:" zip "`
}

taipkan struct pengguna {
    Orang `json:" orang "` // Alamat Alamat Struktur Inline `JSON:" Alamat "`
    Rentetan kata laluan `json:"-"` // tidak terlibat dalam bersiri}

u: = pengguna {
    Orang: orang {nama: "Helen", umur: 29},
    Alamat: Alamat {City: "Beijing", Zip: "100000"},
    Kata Laluan: "Secret123",
}

data, _: = json.marshal (u)
fmt.printf ("Struct bersarang: %s \ n", data)

Output:

 Struct bersarang: {"orang": {"name": "Helen", "umur": 29}, "alamat": {"city": "beijing", "zip": "100000"}}

• Struktur tertanam akan diperluaskan.
• json:"-" bermaksud bahawa medan tidak akan bersiri atau deserialized.

✅ Cadangan pengendalian ralat

Apabila menggunakan json.Marshal dan json.Unmarshal , selalu periksa kesilapan :

 data, err: = json.marshal (somevalue)
jika err! = nil {
    Log.printf ("Ralat Marshal: %V", Err)
    Kembali
}

err = json.unmarshal (jsondata, & sasaran)
jika err! = nil {
    Log.printf ("Kesalahan Unmarshal: %V", Err)
    Kembali
}

Kesalahan biasa termasuk:

• Format JSON adalah haram
• Taipkan ketidakcocokan (seperti yang dijangkakan tetapi dapatkan rentetan)
• Bidang tidak boleh dieksport (medan struct mesti dipermodalkan untuk diakses oleh pakej JSON)

Ringkasan: Mata Utama

• Bidang struktur mesti dipermodalkan dalam huruf pertama yang akan diakses oleh pakej json .
• Gunakan json:"fieldName" untuk menyesuaikan nama kunci.
• omitempty boleh menghilangkan medan nilai kosong.
• json:"-" Abaikan bidang.
• map[string]interface{} dan []interface{} boleh digunakan untuk struktur dinamik, tetapi perhatikan untuk menaip pernyataan.
• Nombor ini float64 secara lalai dalam interface{} .

Pada dasarnya itu sahaja. Dalam perkembangan sebenar, menggabungkan struct tag dan struktur data yang munasabah boleh fleksibel mengendalikan kebanyakan senario JSON.

Atas ialah kandungan terperinci Pergi dengan contoh Json Marshal dan Unmarshal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!