Heim >Backend-Entwicklung >Golang >Wie kann ich die Typzusicherung nach dem Unmarshalling von JSON in interface{} in Go effizient handhaben?

Wie kann ich die Typzusicherung nach dem Unmarshalling von JSON in interface{} in Go effizient handhaben?

Patricia Arquette
Patricia ArquetteOriginal
2024-12-24 15:56:11608Durchsuche

How Can I Efficiently Handle Type Assertion After Unmarshalling JSON into interface{} in Go?

Unmarshalling into Interface{} for Type Assertion in Golang

In diesem Szenario werden JSON-Strings über RabbitMQ übertragen. Diese Zeichenfolgen stellen Instanzen zweier verschiedener Strukturen dar: Somthing1 und Somthing2. Das Ziel besteht darin, die JSON-Strings wieder in ihre jeweiligen Strukturen zu entmarshallieren und Typzusicherungen auszuführen.

Das Problem

Auf den ersten Blick scheint es, als ob das Unmarshalling in eine Schnittstelle{} und das anschließende Anwenden von Typzusicherungen erforderlich wäre sollte reichen. Beim Unmarshalling ist die Eingabevariable jedoch vom Typ „map[string]interface{}“. Dies ist nicht wie erwartet und Versuche, diesen Typ einzuschalten oder ihn den gewünschten Strukturen neu zuzuweisen, schlagen fehl.

Die Lösung

Die JSON-Bibliothek in Golang entmarshallt in Standardtypen wie bool, float64 und map[string]interface{}. Um die gewünschten Strukturen zu erhalten, müssen Sie das Unmarshalieren direkt in sie durchführen oder manuell aus der Map[string]-Schnittstelle{} konvertieren.

Direktes Unmarshalieren verwenden

Der bevorzugte Ansatz ist das direkte Unmarshalieren in die Strukturen:

func typeAssert(msg string) {
    var job Somthing1
    json.Unmarshal([]byte(msg), &job)

    // ...

    var stats Somthing2
    json.Unmarshal([]byte(msg), &stats)

    // ...
}

Verwenden einer Unpacker-Struktur

If Ein direktes Unmarshalling ist nicht möglich. Sie können eine Unpacker-Struktur verwenden, um das Unmarshalling zu handhaben und eine Schnittstelle für den Zugriff auf die Daten bereitzustellen:

type Unpacker struct {
    Data       interface{}
}

func (u *Unpacker) UnmarshalJSON(b []byte) error {
    // Attempt to unmarshal into both types
    smth1 := &Something1{}
    err := json.Unmarshal(b, smth1)

    if err == nil && smth1.Thing != "" {
        u.Data = smth1
        return nil
    }

    smth2 := &Something2{}
    err = json.Unmarshal(b, smth2)
    if err != nil {
        return err
    }

    u.Data = smth2
    return nil
}

Dann können Sie den Unpacker verwenden, um auf die entmarshallten Daten zuzugreifen:

func typeAssert(msg string) {
    unpacker := &Unpacker{}
    json.Unmarshal([]byte(msg), unpacker)

    switch v := unpacker.Data.(type) {
    case Something1:
        // ...

    case Something2:
        // ...

    default:
        // Handle unknown type
    }
}

Das obige ist der detaillierte Inhalt vonWie kann ich die Typzusicherung nach dem Unmarshalling von JSON in interface{} in Go effizient handhaben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn