Golang-JSON-Escape-Zeichen

In Golang ist JSON ein häufig verwendetes Datenaustauschformat. Es kann strukturierte Daten problemlos in das JSON-Format serialisieren und auch aus Daten im JSON-Format wieder in den ursprünglichen Datentyp deserialisieren. Bei der Verwendung von JSON müssen Sie manchmal einige Sonderzeichen maskieren, um Fehler in der JSON-Zeichenfolge zu vermeiden. Wie kann man also JSON-Zeichen in Golang entkommen? In diesem Artikel wird es Ihnen ausführlich vorgestellt.

json in Golang

In Golang können Sie das Paket „encoding/json“ verwenden, um JSON-Daten zu verarbeiten. Dieses Paket stellt Marshal- und Unmarshal-Funktionen bereit, die jeden Datentyp in Golang in eine JSON-Formatzeichenfolge konvertieren und eine JSON-Formatzeichenfolge zurück in den ursprünglichen Datentyp in Golang konvertieren können. Das Folgende ist ein einfaches Beispiel:

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{
        Name: "Tom",
        Age:  20,
    }
    data, _ := json.Marshal(p)
    fmt.Println(string(data))

    var newPerson Person
    json.Unmarshal(data, &newPerson)
    fmt.Println(newPerson)
}

Das Ausgabeergebnis lautet:

{"name":"Tom","age":20}
{Tom 20}

Wie Sie sehen können, wird durch Serialisieren der Personenstrukturinstanz in eine Zeichenfolge im JSON-Format und anschließendes Deserialisieren und Wiederherstellen in einer neuen Personeninstanz Folgendes implementiert: Prozess der Konvertierung des Golang-Datentyps in das JSON-Format und der anschließenden Rückkonvertierung in den Golang-Datentyp in die entgegengesetzte Richtung.

Escape-Zeichen in JSON-Strings

In JSON-Strings gibt es einige Zeichen, die maskiert werden müssen, da sonst Syntaxfehler auftreten. Zu den gängigen Escape-Zeichen gehören:

if Wenn Sie in der keine Escape-Zeichen verwenden JSON-Zeichenfolge, aber doppelte Anführungszeichen und andere Sonderzeichen direkt in die Zeichenfolge schreiben, tritt der folgende Fehler auf:

Escape-Zeichen	Bedeutung
"	doppelte Anführungszeichen
	Backslash
/	Schrägstrich
b	Rücktaste
f	Seitenwechsel
n	Zeilenvorschub
r	Enter
t	horizontal

{"name": "Tom", "introduction": "I'm a "programmer""}

In der obigen JSON-Zeichenfolge befinden sich die doppelten Anführungszeichen im letzten Wort. Nach „Programmierer“ wird kein Escape-Zeichen verwendet, was dazu führt Der JSON-Encoder erkennt diese Zeichenfolge nicht korrekt. Dieser Fehler kann wie folgt behandelt werden:

{"name":"Tom","introduction":"I'm a "programmer""}

In der obigen Zeichenfolge verwendete der Programmierer doppelte Anführungszeichen ("), um die letzten doppelten Anführungszeichen innerhalb eines Wortes zu maskieren, wodurch JSON-Encoderfehler vermieden wurden.

Json-Escape-Zeichenverarbeitung

In Golang können Sie json.Marshal für die Json-Escape-Zeichenverarbeitung verwenden. Diese Funktion maskiert alle erforderlichen Zeichen, einschließlich grundlegender Escape-Zeichen und Unicode-Codepunkte.

Wenn Sie beispielsweise die folgende Struktur:

type Person struct {
    Name   string `json:"name"`
    Gender string `json:"gender"`
}

in die folgende JSON-Formatzeichenfolge konvertieren müssen:

{"name":"Tom","gender":"He said, "I'm the best!""}

, können Sie den folgenden Code verwenden:

p := Person{
    Name:   "Tom",
    Gender: `He said, "I'm the best!"`,
}
data, _ := json.Marshal(p)
fmt.Println(string(data))

Das Ausgabeergebnis lautet:

{"name":"Tom","gender":"He said, "I'm the best!""}

Wie Sie sehen können , JSON verwenden Wenn die .Marshal-Funktion die p-Instanz in eine JSON-formatierte Zeichenfolge serialisiert, werden die doppelten Anführungszeichen automatisch durch „escaped“ ersetzt, wodurch der Fehler des JSON-Encoders vermieden wird.

Zusätzlich zu den üblichen Escape-Zeichen stellt der JSON bereit von golang. Die Marshal-Funktion kann auch Steuerzeichen und Multibyte-Zeichen verarbeiten. Wir können die Zeichen verarbeiten, die vor der Serialisierung der Strukturdaten in eine JSON-Formatzeichenfolge umgewandelt werden müssen:

p := Person{
    Name:   "Tom",
    Gender: `He said, "I'm the best!"`,
}

// 处理多字节字符
p.Gender = strings.Replace(p.Gender, "！", "\uff01", -1)

// 处理控制字符
p.Gender = strings.Replace(p.Gender, "
", "\u0001", -1)

data, _ := json.Marshal(p)
fmt.Println(string(data))

Verwenden Sie im obigen Code zuerst golang. Die strings.Replace-Funktion in der Standardbibliothek ersetzt die Multibyte-Zeichen in der Zeichenfolge durch die entsprechenden UTF-8-Codepunkte. Anschließend verwendet Marshal die Serialisierung des p Instanz in eine Zeichenfolge im JSON-Format, und das Ausgabeergebnis ist:

{"name":"Tom","gender":"He said, "I'm the best!\uff01""}

Sie können sehen, dass wir in der JSON-Zeichenfolge die Zeichen, die mit Escapezeichen versehen werden müssen, in die entsprechenden Escape-Zeichen umwandeln.

Zusammenfassung

In Golang können Sie Strukturdaten einfach in eine JSON-Formatzeichenfolge konvertieren und die Zeichen, die maskiert werden müssen, automatisch maskieren. Dadurch können Fehler in JSON-Zeichenfolgen vermieden und die Richtigkeit von JSON-Daten sichergestellt werden zur Konvertierung von Multibyte-Zeichen und Steuerzeichen

Das obige ist der detaillierte Inhalt vonGolang-JSON-Escape-Zeichen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!