Bagaimanakah Saya Boleh Menghuraikan Integer dan Terapung Dengan Tepat daripada JSON di Golang?

Menghuraikan Integer sebagai Integer dan Terapung sebagai Terapung dalam JSON Menggunakan Golang

Dalam aplikasi Golang yang menerima aliran rekod JSON untuk dimajukan ke stor data (InfluxDB), adalah penting untuk mengekalkan jenis data asal integer dan nilai apungan kepada elakkan konflik jenis dan pastikan operasi tulis berjaya. Walaupun penghurai Ruby JSON dengan mudah melaksanakan tugas ini, pakej pengekodan/json di Golang pada mulanya menghuraikan semua nombor sebagai terapung, yang berpotensi membawa kepada kegagalan taip dan penulisan.

Penyelesaian Menggunakan Nilai JSON Tersuai

Untuk meniru gelagat penghurai Ruby JSON, satu pendekatan ialah menggunakan Go generik mekanisme untuk nilai JSON tersuai. Dalam kaedah ini, nombor JSON diwakili sebagai tatasusunan bait (json.RawMessage) dan dihuraikan menggunakan strconv.ParseInt dan strconv.ParseFloat. Ini membolehkan penukaran integer dan terapung yang tepat:

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)
    }
}

Output:

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

Menggunakan json.Nombor Jenis

Pendekatan alternatif melibatkan penggunaan jenis Go json.Number, yang membolehkan penghuraian yang cekap bagi kedua-dua integer dan terapung terus daripada data JSON:

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)
    }
}

Output:

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

Kaedah ini menyediakan penyelesaian yang berkesan untuk mengekalkan jenis data asal integer dan terapung semasa Penghuraian JSON dalam Golang, memastikan pengendalian data yang tepat dan boleh dipercayai.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Menghuraikan Integer dan Terapung Dengan Tepat daripada JSON di Golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!