Traitement JSON en Go (Golang) : guide complet avec exemples

Traitement JSON en Go (Golang) : guide complet

Go (Golang) est un langage de programmation compilé moderne développé chez Google. L'un de ses points forts est la prise en charge intégrée du format JSON via le package standard encoding/json. Contrairement à de nombreux autres langages où l'installation de bibliothèques tierces est nécessaire, le traitement JSON en Go est disponible "prêt à l'emploi" et se distingue par ses hautes performances et son typage strict.

Dans cet article, nous allons détailler tous les aspects du travail avec JSON en Go : de l'analyse simple aux scénarios complexes avec des types personnalisés et le traitement en flux.

Les bases : encodage et décodage JSON

Le package encoding/json fournit deux fonctions principales : json.Marshal() pour sérialiser les structures Go en JSON et json.Unmarshal() pour désérialiser le JSON en structures.

Exemple : sérialisation d'une structure en JSON

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string `json:"name"`    Age   int    `json:"age"`    Email string `json:"email,omitempty"`}

func main() {    user := User{        Name:  "Иван Петров",        Age:   30,        Email: "ivan@example.com",    }

    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Println("Ошибка сериализации:", err)        return    }

    fmt.Println(string(jsonData))    // Вывод: {"name":"Иван Петров","age":30,"email":"ivan@example.com"}

Exemple : désérialisation JSON en structure

func main() {    jsonString := `{"name":"Анна Смирнова","age":25,"email":"anna@example.com"}`        var user User    err := json.Unmarshal([]byte(jsonString), &user)    if err != nil {        fmt.Println("Ошибка десериализации:", err)        return    }

    fmt.Printf("Имя: %s, Возраст: %d, Email: %s", user.Name, user.Age, user.Email)}

Étiquettes de structure (Struct Tags)

Les étiquettes de structure en Go permettent de contrôler la façon dont les champs sont sérialisés en JSON. C'est un mécanisme puissant pour personnaliser les noms de champs, ignorer les valeurs vides et d'autres options.

Options principales des étiquettes :

• json:"name" — définit le nom du champ en JSON
• json:"-" — exclut complètement le champ du JSON
• json:"name,omitempty" — ignore le champ s'il contient une valeur nulle (0, "", false, nil)
• json:"name,string" — convertit de force un champ numérique en chaîne

Exemple avec différentes étiquettes :

type Product struct {    ID          int     `json:"id"`    Title       string  `json:"title"`    Description string  `json:"description,omitempty"`    Price       float64 `json:"price,string"`    SecretKey   string  `json:"-"`}

func main() {    product := Product{        ID:          101,        Title:       "Ноутбук",        Description: "",        Price:       899.99,        SecretKey:   "sk-12345",    }

    jsonData, _ := json.MarshalIndent(product, "", "  ")    fmt.Println(string(jsonData))    // Вывод:    // {    //   "id": 101,    //   "title": "Ноутбук",    //   "price": "899.99"    // }}

Travail avec des données JSON arbitraires (interface{})

Parfois, la structure des données JSON est inconnue à l'avance. Dans ce cas, on peut utiliser le type interface{} ou map[string]interface{}.

func main() {    jsonString := `{"name":"Тест","values":[1,2,3],"active":true,"metadata":{"version":2}}`        var data map[string]interface{}    err := json.Unmarshal([]byte(jsonString), &data)    if err != nil {        fmt.Println("Ошибка:", err)        return    }

    // Доступ к значениям с приведением типов    name := data["name"].(string)    values := data["values"].([]interface{})