So unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golang

                                                        O Im Folgenden finden Sie das lSo unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golanglang-Tutorial

, um die Methode zur Verwendung von JSON-Zeitpartitionen vorzustellen und die Verwendung von JSON-Zeitpartitionen in So unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golanglang zu verdeutlichen. Ich hoffe, dass es Freunden, die es benötigen, hilfreich sein wird!

Vor ein paar Wochen arbeitete ich an einem So unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golanglang-Mikroservice und musste Unterstützung für CURP-Operationen mithilfe von JSON-Daten hinzufügen. Normalerweise würde ich eine Struktur für die Entität mit allen definierten Feldern und „ohne leere“ Eigenschaften erstellen. wie unten gezeigt

type Article struct {
   Id   string      `json:"id"`
   Name string      `json:"name,omitempty"`
   Desc string      `json:"desc,omitempty"`
}

Probleme

Aber diese Darstellung bringt ernsthafte Probleme mit sich, insbesondere bei Aktualisierungs- oder Bearbeitungsvorgängen.Angenommen, die JSON-Daten der Aktualisierungsanforderung sehen beispielsweise so aus

{"id":"1234","name":"xyz","desc":""}

Achten Sie auf den leeren desc Schauen wir uns nun an, wie diese Anforderungsdaten nach der Entsperrung in So unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golang aussehen. Die Beschreibung hier ist offensichtlich eine leere Zeichenfolge, die von unserem Programm abgeleitet wird Wenn der Client jedoch den vorhandenen Wert von Desc nicht ändern möchte, ist es in diesem Fall falsch, erneut eine Beschreibungszeichenfolge zu senden, sodass die angeforderten JSON-Daten möglicherweise so aussehen: „name“: „xyz“}

Wir entpacken es in unsere Struktur

func Test_JSON1(t *testing.T) {         
   jsonData:=`{"id":"1234","name":"xyz","desc":""}`
   req:=Article{}
   _=json.Unmarshal([]byte(jsonData),&req)
   fmt.Printf("%+v",req)
}Output:
=== RUN   Test_JSON1
{Id:1234 Name:xyz Desc:}

Nun, Desc wird immer noch ein leerer String-Abruf sein, also wie unterscheidet man nicht gesetzte Felder von leeren Feldern? Kurze Antwort: Zeiger? Lösung

Inspiriert von einigen vorhandenen So unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golanglang-Bibliotheken, wie z. B.

go-github

Wir können das Strukturfeld wie unten gezeigt in den Zeigertyp ändern.

func Test_JSON2(t *testing.T) {         
   jsonData:=`{"id":"1234","name":"xyz"}`
   req:=Article{}
   _=json.Unmarshal([]byte(jsonData),&req)
   fmt.Printf("%+v",req)
}Output:
=== RUN   Test_JSON2
{Id:1234 Name:xyz Desc:}

Dadurch fügen wir dem Feld einen zusätzlichen Status hinzu nicht im ursprünglichen JSON vorhanden ist, ist das Strukturfeld leer (

nil

).

Wenn das Feld hingegen existiert und null ist, ist der Zeiger nicht null und das Feld enthält null

HINWEIS – Ich habe das Feld „

Id

“ nicht in einen Zeigertyp geändert, da dies nicht der Fall ist. Bei leerem Status ist eine ID erforderlich, ähnlich der ID in der Datenbank.Versuchen wir es noch einmal.

type Article struct {
   Id    string      `json:"id"`
   Name *string      `json:"name,omitempty"`
   Desc *string      `json:"desc,omitempty"`
}

Ausgabe

func Test_JSON_Empty(t *testing.T) {
   jsonData := `{"id":"1234","name":"xyz","desc":""}`
   req := Article{}
   _ = json.Unmarshal([]byte(jsonData), &req)
   fmt.Printf("%+v\n", req)
   fmt.Printf("%s\n", *req.Name)
   fmt.Printf("%s\n", *req.Desc)
}
func Test_JSON_Nil(t *testing.T) {
   jsonData := `{"id":"1234","name":"xyz"}`
   req := Article{}
   _ = json.Unmarshal([]byte(jsonData), &req)
   fmt.Printf("%+v\n", req)
   fmt.Printf("%s\n", *req.Name)
}

Da desc auf einen leeren String gesetzt ist, erhalten wir ihn in Desc

bekam einen Zeiger ungleich Null und enthielt einen leeren String-Wert. Im zweiten Fall wurde das Feld nicht gesetzt, und wir Ich habe einen leeren String-Zeiger erhalten.

Wir können also zwischen den beiden Aktualisierungen unterscheiden. Dieser Ansatz funktioniert nicht nur für Strings, sondern ist auch auf alle anderen Datentypen anwendbar, einschließlich Ganzzahlen, verschachtelte Strukturen usw. Diese Methode gilt jedoch auch hat einige Probleme.

Null-Sicherheit: In So unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golanglang bedeutet dies, dass ein String- oder Integer-Typ niemals einen Standardwert haben kann. Diese Datentypen sind standardmäßig auf Null gesetzt, wenn sie nicht manuell festgelegt werden. Der Zugriff auf die Daten dieser Zeiger ohne Überprüfung der NULL-Zulässigkeit kann zum Absturz der Anwendung führen.

=== RUN   Test_JSON_Empty
{Id:1234 Name:0xc000088540 Desc:0xc000088550}
Name: xyz
Desc: 
--- PASS: Test_JSON_Empty (0.00s)=== RUN   Test_JSON_Nil
{Id:1234 Name:0xc00005c590 Desc:<nil>}
Name: xyz
--- PASS: Test_JSON_Nil (0.00s)

Dieses Problem kann leicht gelöst werden, indem immer nach Nullzeigern gesucht wird Sehen Sie ausführlich aus.

Druckbarkeit

: Wie Sie vielleicht bei der Ausgabe zeigerbasierter Lösungen bemerkt haben, wird der Wert des Zeigers nicht als Hexadezimalwert gedruckt, was in der Anwendung von geringem Nutzen ist. Dies kann auch durch die Wiederverwendung der Stringer-Schnittstelle überwunden werden kümmert sich um Zeiger.github.com/guregu/null

github.com/google/go-github

Originaladresse: https://medium.com/@arpitkh96/differentiate-between-empty -and- not-set-fields-with-json-in-golang-957bb2c5c065

Übersetzungsadresse: https://learnku.com/go/t/49332

Das obige ist der detaillierte Inhalt vonSo unterscheiden Sie zwischen leeren Feldern und nicht gesetzten Feldern bei der Verwendung von JSON in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!