Travailler avec JSON en Go : parsing et sérialisation en pratique

Travailler avec JSON en Go : parsing et sérialisation en pratique

JSON (JavaScript Object Notation) est l'un des formats d'échange de données les plus populaires en développement web. En langage Go (Golang), le travail avec JSON est implémenté via le package standard encoding/json, qui fournit des outils puissants et pratiques pour la sérialisation (conversion de structures de données en JSON) et la désérialisation (parsing de JSON en structures Go). Dans cet article, nous allons détailler comment travailler avec JSON en Go à l'aide d'exemples pratiques.

Bases : sérialisation de structures en JSON

La façon la plus courante de travailler avec JSON en Go est d'utiliser des structures avec des tags. Les tags permettent de définir les noms des champs en JSON, qui peuvent différer des noms des champs en Go. Regardons un exemple de base de sérialisation :

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype User struct {\n    ID       int    `json:"id"`\n    Name     string `json:"name"`\n    Email    string `json:"email"`\n    IsActive bool   `json:"is_active"`\n}\n\nfunc main() {\n    user := User{\n        ID:       1,\n        Name:     "Ivan Petrov",\n        Email:    "ivan@example.com",\n        IsActive: true,\n    }\n\n    jsonData, err := json.Marshal(user)\n    if err != nil {\n        fmt.Println("Erreur de sérialisation :", err)\n        return\n    }\n\n    fmt.Println(string(jsonData))\n    // Sortie : {"id":1,"name":"Ivan Petrov","email":"ivan@example.com","is_active":true}\n}

Notez que nous utilisons les tags json:"nom_du_champ" pour contrôler les noms des clés en JSON. C'est particulièrement pratique lorsqu'il faut respecter certaines normes de nommage (par exemple, snake_case en JSON et CamelCase en Go).

Parsing de JSON en structures Go

La désérialisation (parsing) de données JSON en structures s'effectue à l'aide de la fonction json.Unmarshal. Il est important que la structure corresponde à la structure de l'objet JSON. Continuons avec notre exemple :

func main() {\n    jsonString := `{"id":2,"name":"Maria Sidorova","email":"maria@example.com","is_active":false}`\n\n    var user User\n    err := json.Unmarshal([]byte(jsonString), &user)\n    if err != nil {\n        fmt.Println("Erreur de parsing :", err)\n        return\n    }\n\n    fmt.Printf("ID : %d, Nom : %s, Email : %s, Actif : %t\\n",\n        user.ID, user.Name, user.Email, user.IsActive)\n    // Sortie : ID : 2, Nom : Maria Sidorova, Email : maria@example.com, Actif : false\n}

Important : La fonction json.Unmarshal reçoit toujours un pointeur vers la structure (&user), sinon les modifications ne seront pas conservées.

Gestion des structures imbriquées et des tableaux

Les données JSON réelles contiennent souvent des objets imbriqués et des tableaux. Go permet de traiter élégamment ces cas à l'aide de structures imbriquées :

type Address struct {\n    City    string `json:"city"`\n    Street  string `json:"street"`\n    ZipCode string `json:"zip_code"`\n}\n\ntype Employee struct {\n    ID      int      `json:"id"`\n    Name    string   `json:"name"`\n    Skills  []string `json:"skills"`\n    Address Address  `json:"address"`\n}\n\nfunc main() {\n    jsonData := `{\n        "id": 101,\n        "name": "Alexei Ivanov",\n        "skills": ["Go", "Python", "Docker"],\n        "address": {\n            "city": "Moscou",\n            "street": "Tverskaya, 10",\n            "zip_code": "101000"\n        }\n    }`\n\n    var emp Employee\n    err := json.Unmarshal([]byte(jsonData), &emp)\n    if err != nil {\n        fmt.Println("Erreur :", err)\n        return\n    }\n\n    fmt.Printf("Employé : %s, Ville : %s, Compétences : %v\\n",\n        emp.Name, emp.Address.City, emp.Skills)\n    // Sortie : Employé : Alexei Ivanov, Ville : Moscou, Compétences : [Go Python Docker]\n}

Pour les tableaux en Go, on utilise des slices ([]string), et pour les objets imbriqués, des structures séparées. Lors du parsing d'un tableau d'objets JSON, on peut