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

Memelihara Jenis Data dalam Penghuraian JSON: Integer sebagai Integer, Terapung sebagai Terapung

Di Golang, menghuraikan rekod JSON yang mengandungi campuran integer dan nilai apungan memerlukan pengendalian yang teliti untuk mengekalkan jenis data asal. Walau bagaimanapun, pelaksanaan semasa menggunakan pakej pengekodan/json menghuraikan semua nombor sebagai terapung, yang berpotensi membawa kepada konflik taip dalam storan data.

Untuk menyelesaikan isu ini, kami boleh menggunakan beberapa pendekatan:

1. Pengendalian Nilai JSON Tersuai:

Kami boleh memanfaatkan mekanisme Go untuk nilai JSON tersuai untuk mengenal pasti dan mengendalikan integer dan terapung dengan sewajarnya.

package main

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

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)
        i, err := strconv.ParseInt(s, 10, 64)
        if err == nil {
            parsed[key] = i
            continue
        }
        f, err := strconv.ParseFloat(s, 64)
        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)
    }
}

2. json.Jenis Nombor:

Go menyediakan jenis json.Number yang direka khusus untuk mengendalikan nombor JSON. Ini membolehkan kami menghuraikan nombor sebagai terapung dan kemudian mengekstrak integer atau terapung seperti yang diperlukan.

package main

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

func main() {
    str := `{"a":123,"b":12.3,"c":"123","d":"12.3","e":true}`
    var parsed map[string]interface{}
    d := json.NewDecoder(strings.NewReader(str))
    d.UseNumber()
    err := d.Decode(&parsed)
    if err != nil {
        panic(err)
    }
    for key, val := range parsed {
        n, ok := val.(json.Number)
        if !ok {
            continue
        }
        if i, err := n.Int64(); err == nil {
            parsed[key] = i
            continue
        }
        if f, err := n.Float64(); err == nil {
            parsed[key] = f
            continue
        }
    }
    for key, val := range parsed {
        fmt.Printf("%T: %v %v\n", val, key, val)
    }
}

Pendekatan ini menyediakan cara yang fleksibel untuk menghuraikan dan mengekalkan nilai integer dan apungan dalam JSON, memastikan perwakilan data yang betul dalam pemprosesan seterusnya.

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