Bagaimanakah Saya Boleh Mengekalkan Jenis Data Apabila Menghuraikan JSON dalam Go?

Memelihara Jenis Data dalam Penghuraian JSON

Satu cabaran yang dihadapi semasa menghuraikan data JSON dalam Golang ialah penukaran automatik nilai angka kepada terapung. Ini boleh menyebabkan ketidakkonsistenan dengan data asal, terutamanya apabila berurusan dengan nilai integer.

Untuk menangani isu ini, terdapat beberapa teknik untuk mengekalkan jenis data semasa penghuraian JSON.

Tersuai Nilai JSON

Satu pendekatan ialah menggunakan mekanisme nilai JSON tersuai yang disediakan oleh Go. Ini melibatkan mencipta jenis tersuai yang melaksanakan antara muka json.Marshaler dan json.Unmarshaler. Dengan mengatasi kaedah MarshalJSON dan UnmarshalJSON, anda boleh mengawal cara nilai berangka dikendalikan semasa bersiri dan penyahserikatan.

Go json.Number

Pilihan lain ialah menggunakan json .Jenis nombor yang diperkenalkan dalam Go 1.8. Secara lalai, nilai berangka dalam JSON dihuraikan sebagai float64. Walau bagaimanapun, dengan menggunakan json.Number dan memanggil kaedah Int64 atau Float64, anda boleh menukar nombor secara eksplisit masing-masing kepada nilai integer atau titik terapung.

Contoh Pelaksanaan

package main

import (
    "encoding/json"
    "fmt"
    "strconv"
    "strings"
)

type MyJSONNumber struct {
    json.Number
}

func (mn *MyJSONNumber) MarshalJSON() ([]byte, error) {
    if n, err := strconv.Atoi(string(mn.Number)); err == nil {
        return []byte(strconv.Itoa(n)), nil
    }
    return []byte(mn.Number), nil
}

func (mn *MyJSONNumber) UnmarshalJSON(b []byte) error {
    if n, err := strconv.Atoi(string(b)); err == nil {
        mn.Number = strconv.Itoa(n)
        return nil
    }
    mn.Number = string(b)
    return nil
}

func main() {
    str := `{"a":123,"b":12.3,"c":"123","d":"12.3","e":true}`
    var raw map[string]json.RawMessage
    err := json.Unmarshal([]byte(str), &raw)
    if err != nil {
        panic(err)
    }
    parsed := make(map[string]interface{}, len(raw))
    for key, val := range raw {
        s := string(val)
        jnum := MyJSONNumber{json.Number(s)}
        n, err := jnum.Int64()
        if err == nil {
            parsed[key] = n
            continue
        }
        f, err := jnum.Float64()
        if err == nil {
            parsed[key] = f
            continue
        }
        var v interface{}
        err = json.Unmarshal(val, &v)
        if err == nil {
            parsed[key] = v
            continue
        }
        parsed[key] = val
    }
    for key, val := range parsed {
        fmt.Printf("%T: %v %v\n", val, key, val)
    }
}

Output:

int64: a 123
float64: b 12.3
string: c 123
string: d 12.3
bool: e true

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mengekalkan Jenis Data Apabila Menghuraikan JSON dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!