Parsing JSON : définition et exemples dans 7 langages

Qu'est-ce que JSON

JSON (JavaScript Object Notation) est un format texte d'échange de données, commode à la fois pour la lecture humaine et pour le traitement machine. Malgré son origine JavaScript, le format est depuis longtemps devenu un standard indépendant du langage et s'utilise pratiquement partout où des applications doivent échanger des données structurées.

Exemple de base d'un document JSON :

{
  "id": 42,
  "name": "Anna",
  "is_active": true,
  "roles": ["admin", "editor"],
  "profile": {
    "city": "Paris",
    "age": 29
  }
}

Le format se construit à partir de quelques types simples : les objets (paires « clé — valeur »), les tableaux, les chaînes, les nombres, les booléens et null. C'est cette simplicité qui explique son omniprésence.

Qu'est-ce que le parsing JSON et à quoi il sert

Le parsing JSON (l'analyse syntaxique) est le processus qui transforme un texte JSON en une structure de données propre à un langage de programmation : objet, dictionnaire, tableau, liste, etc. Le parseur prend une chaîne de caractères et la transforme en objets vivants, manipulables dans le code.

Le processus inverse — transformer les objets du programme en chaîne JSON — s'appelle la sérialisation (ou marshalling). Parsing et sérialisation vont presque toujours de pair.

Le parsing intervient dans des tâches typiques :

• Travail avec les API — réception et envoi de données par HTTP (nous y revenons en détail plus bas).
• Fichiers de configuration — beaucoup d'outils stockent leurs réglages en JSON (package.json, tsconfig.json, etc.).
• Stockage et échange de données — logs, messages dans les files (Kafka, RabbitMQ), documents dans les bases NoSQL (MongoDB).
• Communication entre services dans une architecture microservices.
• Sauvegarde de l'état d'une application dans des fichiers ou le localStorage du navigateur.

Le parsing JSON lors de l'utilisation d'API

Le scénario le plus fréquent où un développeur rencontre le parsing JSON est l'interaction avec une API. L'écrasante majorité des API web modernes (REST, et souvent d'autres styles) échangent leurs données précisément au format JSON.

Le cycle typique de travail avec une API ressemble à ceci :

1. Le client envoie une requête HTTP vers un endpoint de l'API.
2. Le serveur répond avec un corps de réponse sous forme de chaîne JSON.
3. Le client parse cette chaîne, la transforme en objets et continue de travailler avec les données.
4. À l'envoi de données (POST, PUT), le client fait l'inverse : il sérialise ses objets en JSON.

Sans l'étape de parsing, la réponse du serveur reste un simple texte, impossible à exploiter commodément par programme. C'est pourquoi le parsing est un maillon obligatoire de presque toute intégration avec un service externe.

Voir aussi : l'article « Extraction de données via API » — il détaille la construction des requêtes vers les API, le traitement des réponses, le travail avec les en-têtes, les codes de statut, la pagination et l'authentification. Le présent article se concentre sur l'étape d'analyse des données JSON elles-mêmes, partie intégrante de ce processus.

Exemples de parsing JSON dans différents langages

Voici des exemples d'analyse de JSON dans les langages populaires. Dans chaque cas, on analyse la même chaîne, puis on extrait la valeur d'un champ imbriqué.

Python

La bibliothèque standard fournit le module json. La méthode loads analyse une chaîne, load — le contenu d'un fichier.

import json

data_str = '{"name": "Anna", "profile": {"city": "Paris", "age": 29}}'

# Parsing de la chaîne en dictionnaire
data = json.loads(data_str)

print(data["name"])              # Anna
print(data["profile"]["city"])   # Paris

# Opération inverse — la sérialisation
back_to_str = json.dumps(data, ensure_ascii=False)

JavaScript

En JavaScript, le parsing est intégré au langage via l'objet global JSON. C'est le format « natif » de l'écosystème.

const dataStr = '{"name": "Anna", "profile": {"city": "Paris", "age": 29}}';

// Parsing de la chaîne en objet
const data = JSON.parse(dataStr);

console.log(data.name);            // Anna
console.log(data.profile.city);    // Paris

// Opération inverse
const backToStr = JSON.stringify(data);

Avec fetch, le parsing de la réponse d'une API tient en une ligne :

const response = await fetch("https://api.example.com/users/42");
const user = await response.json(); // la réponse est déjà parsée en objet
console.log(user.name);

Java

La bibliothèque standard n'a pas de parseur intégré, on utilise donc habituellement des bibliothèques — par exemple Jackson ou Gson. Exemple avec Jackson :

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        String dataStr = "{\"name\": \"Anna\", \"profile\": {\"city\": \"Paris\"}}";

        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = mapper.readTree(dataStr);

        System.out.println(node.get("name").asText());                  // Anna
        System.out.println(node.get("profile").get("city").asText());   // Paris
    }
}

Le plus souvent, le JSON est analysé directement vers une classe typée (POJO) :

record Profile(String city, int age) {}
record User(String name, Profile profile) {}

User user = mapper.readValue(dataStr, User.class);
System.out.println(user.profile().city());

Go

La bibliothèque standard fournit le paquet encoding/json. Les données sont généralement analysées vers une structure avec des tags de champs.

package main

import (
    "encoding/json"
    "fmt"
)

type Profile struct {
    City string `json:"city"`
    Age  int    `json:"age"`
}

type User struct {
    Name    string  `json:"name"`
    Profile Profile `json:"profile"`
}

func main() {
    dataStr := `{"name": "Anna", "profile": {"city": "Paris", "age": 29}}`

    var user User
    json.Unmarshal([]byte(dataStr), &user)

    fmt.Println(user.Name)          // Anna
    fmt.Println(user.Profile.City)  // Paris
}

C#

Le .NET moderne inclut l'espace de noms System.Text.Json.

using System;
using System.Text.Json;

class Program
{
    static void Main()
    {
        string dataStr = "{\"name\": \"Anna\", \"profile\": {\"city\": \"Paris\"}}";

        using JsonDocument doc = JsonDocument.Parse(dataStr);
        JsonElement root = doc.RootElement;

        Console.WriteLine(root.GetProperty("name").GetString());                       // Anna
        Console.WriteLine(root.GetProperty("profile").GetProperty("city").GetString()); // Paris
    }
}

PHP

En PHP, le parsing est intégré au langage via les fonctions json_decode et json_encode.

<?php
$dataStr = '{"name": "Anna", "profile": {"city": "Paris", "age": 29}}';

// true — décoder en tableau associatif plutôt qu'en objet
$data = json_decode($dataStr, true);

echo $data["name"];             // Anna
echo $data["profile"]["city"];  // Paris

// Opération inverse
$backToStr = json_encode($data, JSON_UNESCAPED_UNICODE);

Rust

Dans l'écosystème Rust, le standard de fait est le crate serde associé à serde_json.

use serde::Deserialize;

#[derive(Deserialize)]
struct Profile {
    city: String,
    age: u32,
}

#[derive(Deserialize)]
struct User {
    name: String,
    profile: Profile,
}

fn main() {
    let data_str = r#"{"name": "Anna", "profile": {"city": "Paris", "age": 29}}"#;

    let user: User = serde_json::from_str(data_str).unwrap();

    println!("{}", user.name);          // Anna
    println!("{}", user.profile.city);  // Paris
}

Comparaison des approches

Deux grandes approches de l'analyse se dégagent :

• L'analyse dynamique — le JSON devient une structure universelle (dictionnaire, tableau, arbre de nœuds). Commode pour un travail rapide et souple, mais sans vérification des types à la compilation.
• L'analyse typée — le JSON est directement projeté sur des classes ou structures décrites à l'avance. Plus sûr et plus lisible, surtout dans les langages à typage strict (Java, Go, Rust, C#).

Problèmes fréquents et recommandations

Au parsing de JSON, quelques difficultés typiques méritent attention :

• JSON invalide. Si la chaîne est corrompue ou contient des erreurs de syntaxe, le parseur lève une exception. Entourez toujours l'analyse de données externes d'une gestion d'erreurs.
• Champs absents ou null. Ne supposez pas que toutes les clés attendues sont toujours présentes — l'API peut renvoyer un objet incomplet. Vérifiez l'existence des champs avant d'y accéder.
• Encodage. Le standard JSON repose sur UTF-8. Dans certains langages (Python, PHP), il faut passer des drapeaux explicites pour que les caractères accentués ne se transforment pas en séquences \u à la sérialisation.
• Gros documents. Pour les très gros fichiers, au lieu de charger tout l'objet en mémoire, on emploie une analyse en flux (streaming), qui lit les données par morceaux.
• Nombres et précision. Les grands entiers et les nombres à virgule flottante peuvent perdre en précision — c'est critique pour les données financières, qu'on transmet parfois sous forme de chaînes.

En résumé

Le parsing JSON est une compétence de base sans laquelle le travail avec les API modernes et l'échange de données entre systèmes sont presque impossibles. Le format lui-même est universel, et chaque langage répandu dispose d'outils pour l'analyser : parfois intégrés, parfois sous forme de bibliothèques populaires. Le principe est partout le même — transformer une chaîne de texte en objets commodes pour le code, et faire au besoin le chemin inverse.

Pour voir comment le parsing s'insère dans le cycle complet d'interaction avec des services externes, consultez l'article « Parsing d'API ».