php-Editor Shinichi hat eine interessante Technik eingeführt, die darin besteht, JSON-Schlüssel mit einfachen Anführungszeichen zu entmarshalieren. Dieser Tipp kann Entwicklern helfen, bei der Verarbeitung von JSON-Daten flexibler zu sein und Analysefehler zu vermeiden, die durch die Einbeziehung einfacher Anführungszeichen verursacht werden. Durch den Einsatz einiger einfacher Tricks und Funktionen können Entwickler diese Situation leicht bewältigen und eine korrekte Analyse und Verarbeitung von JSON-Daten sicherstellen. Diese Technik ist sehr nützlich für Entwickler, die häufig mit JSON-Daten arbeiten, und kann die Entwicklungseffizienz und Codequalität verbessern.
Ich bin darüber sehr verwirrt. Ich muss einige in JSON serialisierte Daten (aus einer französischen Datenbank) laden, wobei einige Schlüssel einfache Anführungszeichen haben.
Dies ist eine vereinfachte Version:
package main
import (
"encoding/json"
"fmt"
)
type product struct {
name string `json:"nom"`
cost int64 `json:"prix d'achat"`
}
func main() {
var p product
err := json.unmarshal([]byte(`{"nom":"savon", "prix d'achat": 170}`), &p)
fmt.printf("product cost: %d\nerror: %s\n", p.cost, err)
}
// product cost: 0
// error: %!s(<nil>)Unmarshalling verursacht keinen Fehler, aber „prix d'achat“ (p.cost) wird nicht korrekt analysiert.
Wenn ich das Marshalling auf map[string]any aufnehme, wird der Schlüssel „prix d'achat“ wie erwartet analysiert:
package main
import (
"encoding/json"
"fmt"
)
func main() {
blob := map[string]any{}
err := json.Unmarshal([]byte(`{"nom":"savon", "prix d'achat": 170}`), &blob)
fmt.Printf("blob: %f\nerror: %s\n", blob["prix d'achat"], err)
}
// blob: 170.000000
// error: %!s(<nil>)Ich habe die json.marshal Dokumentation zum Struktur-Tagging überprüft, kann aber keine Probleme mit den Daten feststellen, die ich verarbeiten möchte.
Übersehe ich hier etwas Offensichtliches? Wie analysiere ich JSON-Schlüssel, die einfache Anführungszeichen enthalten, mithilfe von Struktur-Tags?
Vielen Dank für deine Einblicke!
Ich habe in der Dokumentation nichts gefunden, aber der json-Encoder behandelt einfache Anführungszeichen als reservierte Zeichen in Tag-Namen.
func isvalidtag(s string) bool {
if s == "" {
return false
}
for _, c := range s {
switch {
case strings.containsrune("!#$%&()*+-./:;<=>?@[]^_{|}~ ", c):
// backslash and quote chars are reserved, but
// otherwise any punctuation chars are allowed
// in a tag name.
case !unicode.isletter(c) && !unicode.isdigit(c):
return false
}
}
return true
}Ich denke, es ist vernünftig, die Frage hier zu stellen. In der Zwischenzeit müssen Sie json.unmarshaler und/oder json.marshaler implementieren. Das ist ein Anfang:
func (p *Product) UnmarshalJSON(b []byte) error {
type product Product // revent recursion
var _p product
if err := json.Unmarshal(b, &_p); err != nil {
return err
}
*p = Product(_p)
return unmarshalFieldsWithSingleQuotes(p, b)
}
func unmarshalFieldsWithSingleQuotes(dest interface{}, b []byte) error {
// Look through the JSON tags. If there is one containing single quotes,
// unmarshal b again, into a map this time. Then unmarshal the value
// at the map key corresponding to the tag, if any.
var m map[string]json.RawMessage
t := reflect.TypeOf(dest).Elem()
v := reflect.ValueOf(dest).Elem()
for i := 0; i < t.NumField(); i++ {
tag := t.Field(i).Tag.Get("json")
if !strings.Contains(tag, "'") {
continue
}
if m == nil {
if err := json.Unmarshal(b, &m); err != nil {
return err
}
}
if j, ok := m[tag]; ok {
if err := json.Unmarshal(j, v.Field(i).Addr().Interface()); err != nil {
return err
}
}
}
return nil
}Probieren Sie es auf dem Spielplatz aus: https://www.php.cn/link/9b47b8678d84ea8a0f9fe6c4ec599918一个>
Das obige ist der detaillierte Inhalt vonUnmarshalieren von JSON-Schlüsseln, die einfache Anführungszeichen enthalten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
