Travailler avec JSON en Go : analyse et sérialisation des données

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction au travail avec JSON en Go

JSON (JavaScript Object Notation) est l'un des formats d'échange de données les plus populaires dans les applications web modernes, les microservices et les API. Le langage Go (Golang) offre une prise en charge intégrée puissante pour travailler avec JSON via le package encoding/json. Ce package permet de convertir facilement des données entre les structures Go et les chaînes JSON, et vice versa.

Dans cet article, nous allons détailler comment effectuer l'analyse (désérialisation) et la sérialisation de JSON en Go. Vous apprendrez à travailler avec des structures simples et imbriquées, à gérer les erreurs et à configurer les noms de champs. Ce contenu sera utile aussi bien aux débutants qu'aux développeurs expérimentés souhaitant systématiser leurs connaissances.

Bases de la sérialisation (Marshal) en Go

Conversion d'une structure Go en JSON

La sérialisation est le processus de conversion d'un objet Go (par exemple, une structure ou une slice) en une chaîne JSON. Pour cela, on utilise la fonction json.Marshal(). Voici un exemple simple :

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string    Age   int    Email string}

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))}

Sortie du programme :

{"Name":"Иван Петров","Age":30,"Email":"ivan@example.com"}

Notez que les noms des champs en JSON correspondent aux noms des champs de la structure. Mais il est souvent nécessaire de les modifier, par exemple, pour utiliser le style camelCase. Pour cela, on utilise les tags de structure.

Utilisation des tags pour configurer JSON

Les tags de structure permettent de définir comment un champ doit être sérialisé. Ajoutons des tags à notre exemple :

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

Maintenant, la sortie sera :

{"name":"Иван Петров","age":30,"email":"ivan@example.com"}

Options clés des tags :

json:"field_name" — définit le nom du champ en JSON.
omitempty — exclut le champ du JSON s'il a une valeur nulle (chaîne vide, 0, false, nil).
- — ignore complètement le champ lors de la sérialisation/désérialisation.

Sérialisation de slices et de maps

Le package encoding/json fonctionne parfaitement non seulement avec les structures, mais aussi avec les slices, les maps et les types simples :

// Slice de structuresusers := []User{    {Name: "Анна", Age: 25},    {Name: "Борис", Age: 35},}jsonUsers, _ := json.Marshal(users)fmt.Println(string(jsonUsers))// Sortie : [{"name":"Анна","age":25},{"name":"Борис","age":35}]

// Mapdata := map[string]interface{}{    "status": "ok",    "count":  42,}jsonMap, _ := json.Marshal(data)fmt.Println(string(jsonMap))// Sortie : {"count":42,"status":"ok"}

Analyse JSON (Unmarshal) en Go

Analyse de base dans une structure

La désérialisation (analyse) est le processus inverse : conversion d'une chaîne JSON en un objet Go. On utilise la fonction json.Unmarshal(). Important : la structure cible doit être exportée (champs commençant par une majuscule) ou avoir les tags correspondants.

jsonString := `{"name":"Мария","age":28,"email":"maria@example.com"}`

var user Usererr := json.Unmarshal([]byte(jsonString), &user)if err != nil {    fmt.Println("Ошибка парсинга:", err)    return}

fmt.Printf("Имя: %s, Возраст: %d", user.Name, user.Age)// Sortie : Имя: Мария, Возраст: 28