Comment normaliser au mieux les données JSON dans les structures API dans Go

L'éditeur php Xigua apporte ici un guide simplifié sur la façon de normaliser les données JSON dans les structures API dans Go. Dans les applications Web modernes, travailler avec des données JSON est une tâche courante. En tant que langage back-end puissant, le langage Go offre un moyen concis et flexible de traiter les données JSON. Cet article expliquera comment utiliser les structures du langage Go pour normaliser les données JSON afin qu'elles puissent être mieux traitées et manipulées. Que vous soyez débutant ou développeur expérimenté, cet article vous fournira des conseils utiles et des exemples pratiques. commençons!

Contenu de la question

Je suis assez nouveau et j'essaie de déterminer s'il existe un moyen plus propre d'accomplir la normalisation des données json du front-end (js) vers mon API. Pour m'assurer que les types corrects sont utilisés lors de la création de variables à partir de la structure (model.expense), je vide la charge utile dans une carte, puis je normalise et sauvegarde dans la structure. Si quelqu'un pouvait m'apprendre une meilleure façon de gérer cela, je lui en serais très reconnaissant ! Merci d'avance!

Modèle de tarification :

type expense struct {
    id        primitive.objectid   `json:"_id,omitempty" bson:"_id,omitempty"`
    name      string               `json:"name"`
    frequency int                  `json:"frequency"`
    startdate *time.time           `json:"startdate"`
    enddate   *time.time           `json:"enddate,omitempty"`
    cost      primitive.decimal128 `json:"cost"`
    paid      []string             `json:"paid,omitempty"`
}

Contrôleur problématique :

func InsertOneExpense(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.Header().Set("Allow-Control-Allow-Methods", "POST")

    var expense map[string]interface{}
    json.NewDecoder(r.Body).Decode(&expense)

    var expenseName string
    if name, ok := expense["name"]; ok {
        expenseName = fmt.Sprintf("%v", name)
    } else {
        json.NewEncoder(w).Encode("missing required name")
    }

    var expenseFrequency int
    if frequency, ok := expense["frequency"]; ok {
        expenseFrequency = int(frequency.(float64))
    } else {
        expenseFrequency = 1
    }

    // Handle startDate normalization
    var expenseStartDate *time.Time
    if startDate, ok := expense["startDate"]; ok {
        startDateString := fmt.Sprintf("%v", startDate)
        startDateParsed, err := time.Parse("2006-01-02 15:04:05", startDateString)

        if err != nil {
            log.Fatal(err)
        }

        expenseStartDate = &startDateParsed
    } else {
        json.NewEncoder(w).Encode("missing required startDate")
    }

    // Handle endDate normalization
    var expenseEndDate *time.Time
    if endDate, ok := expense["endDate"]; ok {
        endDateString := fmt.Sprintf("%v", endDate)
        endDateParsed, err := time.Parse("2006-01-02 15:04:05", endDateString)

        if err != nil {
            log.Fatal(err)
        }

        expenseEndDate = &endDateParsed
    } else {
        expenseEndDate = nil
    }

    // Handle cost normaliztion
    var expenseCost primitive.Decimal128
    if cost, ok := expense["cost"]; ok {
        costString := fmt.Sprintf("%v", cost)
        costPrimitive, err := primitive.ParseDecimal128(costString)

        if err != nil {
            log.Fatal(err)
        }

        expenseCost = costPrimitive
    } else {
        json.NewEncoder(w).Encode("missing required cost")
        return
    }

    normalizedExpense := model.Expense{
        Name:      expenseName,
        Frequency: expenseFrequency,
        StartDate: expenseStartDate,
        EndDate:   expenseEndDate,
        Cost:      expenseCost,
    }

    // Do more things with the struct var...
}

Workaround

Vous pouvez définir l'interface json.unmarshaljson puis valider manuellement les données si nécessaire. Essayez quelque chose comme ceci :

package main

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

type CoolStruct struct {
    MoneyOwed string `json:"money_owed"`
}

// UnmarshalJSON the json package will delegate deserialization to our code if we implement the json.UnmarshalJSON interface
func (c *CoolStruct) UnmarshalJSON(data []byte) error {
    // get the body as a map[string]*[]byte
    raw := map[string]*json.RawMessage{}
    if err := json.Unmarshal(data, &raw); err != nil {
        return fmt.Errorf("unable to unmarshal raw meessage map: %w", err)
    }

    // if we don't know the variable type sent we can unmarshal to an interface
    var tempHolder interface{}
    err := json.Unmarshal(*raw["money_owed"], &tempHolder)
    if err != nil {
        return fmt.Errorf("unable to unmarshal custom value from raw message map: %w", err)
    }

    // the unmarshalled interface has an underlying type use go's typing
    // system to determine type conversions / normalizations required
    switch tempHolder.(type) {
    case int64:
        // once we determine the type of the we just assign the value
        // to the receiver's field
        c.MoneyOwed = strconv.FormatInt(tempHolder.(int64), 10)
    // we could list all individually or as a group; driven by requirements
    case int, int32, float32, float64:
        c.MoneyOwed = fmt.Sprint(tempHolder)
    case string:
        c.MoneyOwed = tempHolder.(string)
    default:
        fmt.Printf("missing type case: %T\n", tempHolder)
    }
    // success; struct is now populated
    return nil
}

func main() {
    myJson := []byte(`{"money_owed": 123.12}`)
    cool := CoolStruct{}
    // outside of your struct you marshal/unmarshal as normal
    if err := json.Unmarshal(myJson, &cool); err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", cool)
}

Sortie : {moneyowed:123.12}
Lien aire de jeux : https://www.php.cn/link/87ca4eb840b6f78e3b6d6b418c0fef40

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!