Techniques d'encodage et de décodage des types de structure dans les fonctions Golang

Golang est un langage de programmation très puissant qui fournit de nombreux types et fonctions intégrés pour aider les programmeurs à écrire rapidement du code efficace. Parmi eux, le type de structure est très couramment utilisé. Lorsqu'il s'agit de communication réseau, de stockage et de transmission de données, etc., nous devons généralement encoder des données de type structure en données binaires ou les sérialiser en une chaîne au format JSON pour la transmission. Cet article présentera quelques techniques de codage et de décodage pour le type de structure des fonctions Golang.

1. Définition du type de structure

En Golang, la définition du type de structure nécessite l'utilisation du mot-clé type et du mot-clé struct. Par exemple, ce qui suit définit un type de structure Personne, qui contient deux champs : Nom et Âge :

type Person struct {
    Name string
    Age int
}

2. Encodage et décodage JSON

JSON est un format d'échange de données léger, facile à lire et à écrire. Dans Golang, nous pouvons utiliser les fonctions Marshal() et Unmarshal() dans le package json pour implémenter l'encodage et le décodage JSON des types de structure.

• Encodage JSON

Lors de l'encodage, nous devons convertir le type de structure en un tableau d'octets de type []byte, ce qui peut être réalisé via la fonction json.Marshal(). Par exemple, l'exemple suivant encode une instance p du type Person dans une chaîne au format JSON :

p := Person{"Tina", 28}
jsonData, _ := json.Marshal(p)
fmt.Println(string(jsonData))   // {"Name":"Tina","Age":28}

• Décodage JSON

Lors du décodage, nous devons analyser la chaîne JSON dans un type de structure. Ceci peut être réalisé grâce à la fonction json.Unmarshal(). Par exemple, l'exemple suivant décode la chaîne JSON jsonStr en une instance de type Personne :

jsonStr := `{"Name":"Tina", "Age": 28}`
var p Person
_ = json.Unmarshal([]byte(jsonStr), &p)
fmt.Println(p)  // {Tina 28}

3. Encodage et décodage de séquence d'octets

Dans le processus de communication réseau ou de stockage de données, nous devons également sérialiser le type de structure en octet séquence. Par exemple, pour sérialiser l'instance de type Personne p dans la séquence d'octets byteData :

buf := new(bytes.Buffer)
binary.Write(buf, binary.LittleEndian, &p)
byteData := buf.Bytes()
fmt.Printf("%x
", byteData)   // 54696e61001c0000

Nous utilisons les fonctions bytes.Buffer et binaire.Write() pour sérialiser le type de structure p dans la séquence d'octets byteData. Le deuxième paramètre de la fonction binaire.Write() spécifie la méthode de traitement de l'ordre des octets, ici le format LittleEndian est utilisé.

De même, nous pouvons également utiliser la fonction binaire.Read() pour désérialiser byteData sous la même forme, par exemple :

var q Person
err := binary.Read(bytes.NewReader(byteData), binary.LittleEndian, &q)
if err != nil {
    fmt.Println(err)
}
fmt.Println(q)  // {Tina 28}

4. Encodage et décodage Gob

Gob est un format d'encodage fourni avec Golang et utilisé dans les appels RPC et souvent utilisé lors de la transmission de données. Dans Golang, le package gob est également fourni pour l'encodage et le décodage Gob.

• Gob Encoding

Nous pouvons utiliser la fonction gob.NewEncoder() pour créer une instance d'encodeur, puis utiliser sa méthode Encode() pour encoder le type de structure dans une séquence d'octets. Par exemple, encoder une instance p du type Person dans une séquence d'octets byteData :

var byteData bytes.Buffer
enc := gob.NewEncoder(&byteData)
err := enc.Encode(&p)
if err != nil {
    fmt.Println(err)
}
fmt.Printf("%x
", byteData.Bytes())   // 026864073544696e61001c

Nous utilisons les fonctions bytes.Buffer et gob.NewEncoder() pour encoder le type de structure p dans une séquence d'octets byteData.

• Décodage Gob

Lors du décodage, nous devons également utiliser le package gob. Créez une instance de décodeur et utilisez sa méthode Decode() pour décoder une séquence d'octets. Par exemple, décodez le byteData codé dans l'exemple ci-dessus en une instance q de type Personne :

dec := gob.NewDecoder(&byteData)
var q Person
err := dec.Decode(&q)
if err != nil {
    fmt.Println(err)
}
fmt.Println(q)  // {Tina 28}

Résumé

Le type de structure est un type de données couramment utilisé dans Golang. Lorsqu'il s'agit de communication réseau, de stockage et de transmission de données, nous le faisons souvent. Le type de structure doit être codé en données binaires ou sérialisé en chaîne pour la transmission. Cet article présente certaines techniques de codage et de décodage pour les types de structure des fonctions Golang, notamment le codage et le décodage JSON, le codage et le décodage de séquences d'octets et le codage et décodage Gob. Ces techniques peuvent nous aider à effectuer les tâches de transfert et de stockage de données rapidement et efficacement.

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!