• JSON (JavaScript Object Notation) : format texte d’échange de données structurées, lisible par l’humain comme par la machine.
• Issu de la syntaxe de JavaScript, mais indépendant de tout langage : tous savent le lire et l’écrire.
• Normes : RFC 8259 (IETF, 2017) et ECMA-404 — même grammaire.
• Type de média application/json · extension .json.
• Encodage UTF-8 obligatoire entre systèmes ; sans BOM (marque d’ordre des octets).

Où le rencontre-t-on ?

• API web : requêtes et réponses des services en ligne.
• Configuration : package.json, settings.json de VS Code…
• Stockage : bases documentaires, colonnes jsonb de PostgreSQL, journaux, carnets Jupyter.

Objets et tableaux contiennent d’autres valeurs et s’imbriquent librement. Ni date, ni binaire (page 2).

{"titre":"Candide","tags":["conte"]}

{
  "titre": "Candide",
  "tags": [
    "conte"
  ]
}

Même donnée : les espaces entre les éléments n’ont aucun sens. Compact pour transmettre, indenté pour lire.

{                                  1
  "titre": "Candide",              2
  "annee": 1759,                   3
  "disponible": true,              4
  "prix": null,                    
  "auteur": {                      5
    "nom": "Voltaire",             
    "naissance": 1694              6
  },                               
  "tags": ["conte", "philosophie"] 7
}                                  

1. 1Objet racine, entre accolades { }.
2. 2Membre : une clé (chaîne entre guillemets doubles), :, puis une valeur — ici une chaîne.
3. 3Nombre : sans guillemets. Une virgule sépare les membres.
4. 4Littéraux true, false, null : minuscules, sans guillemets.
5. 5Une valeur peut être un objet imbriqué…
6. 6Pas de virgule après le dernier membre.
7. 7… ou un tableau : liste ordonnée entre crochets [ ].

1. Chaînes et clés entre guillemets doubles : "nom", jamais 'nom'.
2. Toute clé est une chaîne : {"a": 1}, jamais {a: 1}.
3. Une virgule entre deux éléments, jamais après le dernier.
4. Deux-points entre la clé et sa valeur.
5. true, false, null en minuscules, sans guillemets.
6. Ni undefined, ni NaN, ni Infinity, ni fonction.
7. Nombres en base 10, sans + initial ni zéro de tête.
8. Dans une chaîne, échapper ", \ et les caractères de contrôle.
9. Aucun commentaire : ni // ni /* */.
10. Une seule valeur racine ; des clés uniques dans chaque objet.

L’ordre des clés d’un objet ne porte aucun sens ; l’ordre des éléments d’un tableau, si.

1. Indenter pour voir la structure : jq . f, py -m json.tool f, ou Maj+Alt+F dans VS Code.
2. Lire la position donnée par le message : ligne, colonne ou caractère.
3. Regarder juste avant : l’erreur réelle précède souvent l’endroit signalé.
4. Vérifier dans l’ordre : virgules, guillemets, paires { } et [ ], littéraux.
5. Fichier venu d’ailleurs : BOM en tête ? encodage autre qu’UTF-8 ?

Messages d’erreur types : page 6.

Atouts

• Grammaire minuscule : six types, quelques signes.
• Lisible à l’œil nu, facile à écrire à la main.
• Natif dans les navigateurs ; analyseurs dans tous les langages.
• Plus léger que XML pour la plupart des données.

Limites

• Ni commentaires, ni dates, ni binaire.
• Précision des nombres laissée aux analyseurs.
• Clés répétées dans chaque objet : volumineux en masse.
• Aucune validation intégrée : il faut un schéma (page 4).

Clés en double : la plupart des analyseurs gardent la dernière valeur (Python, JavaScript) ; d’autres signalent une erreur ou conservent toutes les paires. Résultat imprévisible : les proscrire.

Ordre des membres sans signification : {"a":1,"b":2} = {"b":2,"a":1}. Ne jamais s’y fier.

À échapper obligatoirement : le guillemet ", la barre oblique inverse \ et les caractères de contrôle U+0000 à U+001F (saut de ligne, tabulation…).

! Invalides : \' \x41 \0 \a. Pas de retour à la ligne brut dans une chaîne : écrire \n.

En UTF-8, "été" et "\u00e9t\u00e9" sont la même chaîne.

Chemins Windows : "C:\\Users\\docs" — ou "C:/Users/docs", accepté par la plupart des programmes.

• Espaces permis entre les éléments : espace, tabulation, saut de ligne, retour chariot — et eux seuls.
• Retrait conventionnel : 2 ou 4 espaces. Une ligne vide finale est d’usage, non requise.
• La racine peut être n’importe quelle valeur : 42 ou "ok" forment un document JSON (RFC 8259) ; d’anciens analyseurs n’acceptent qu’un objet ou un tableau.
• Taille, profondeur, longueur des chaînes : chaque analyseur fixe ses propres limites.

valeur   = objet / tableau / chaîne / nombre
         / "true" / "false" / "null"
objet    = "{" [ membre *( "," membre ) ] "}"
membre   = chaîne ":" valeur
tableau  = "[" [ valeur *( "," valeur ) ] "]"
chaîne   = guillemet *caractère guillemet
nombre   = [ "-" ] entier [ fraction ] [ exposant ]
entier   = "0" / ( chiffre-1-à-9 *chiffre )
fraction = "." 1*chiffre
exposant = ( "e" / "E" ) [ "-" / "+" ] 1*chiffre

Notation ABNF simplifiée d’après RFC 8259 : / ou · [ ] facultatif · * zéro, une ou plusieurs fois · 1* au moins une fois. Des espaces peuvent entourer chaque signe { } [ ] : ,.

Un seul type numérique : 1, 1.0 et 1e0 expriment la même quantité ; certains langages les distinguent (Python : int et float).

Précision

• La norme ne fixe aucune limite ; la plupart des analyseurs utilisent des doubles IEEE 754 (64 bits).
• Entiers exacts garantis de −(2⁵³−1) à 2⁵³−1 = 9007199254740991 (RFC 8259, § 6).
• ! Au-delà, arrondi silencieux : en JavaScript, 9007199254740993 devient 9007199254740992.
• Réels : arrondi binaire — 0.1 + 0.2 donne 0.30000000000000004.
• → Identifiants longs en chaîne ; montants en centimes entiers ou en chaîne décimale : "19.90".

! Ne jamais lire du JSON avec eval() : exécution de code arbitraire. Utiliser JSON.parse().

• Texte JSON échangé : UTF-8, sans BOM ; un analyseur peut ignorer un BOM reçu, sans y être tenu.
• Tout caractère Unicode peut figurer tel quel dans une chaîne, sauf ", \ et les caractères de contrôle.
• ! Même aspect, octets différents : « é » s’écrit en un point de code (U+00E9) ou en deux (e + accent combinant U+0301). Normaliser (NFC) avant de comparer clés et valeurs.
• Longueur d’une chaîne : un émoji compte 2 en JavaScript (UTF-16), 1 en Python.

• Même donnée, textes différents : ordre des clés, espaces, 1.0 et 1, "\u00e9" et "é".
• Comparer les données, pas le texte : jq -S . a.json > a2.json, idem pour b, puis diff a2.json b2.json.
• Signature, empreinte (hachage) : sérialisation canonique JCS (RFC 8785) — clés triées, forme des nombres et des chaînes fixée.

{
  "id": "cmd-2026-00042",
  "statut": "expediee",
  "creeLe": "2026-09-29T14:30:00Z",
  "client": { "id": "c-1187", "nom": "Exemple SARL" },
  "lignes": [
    { "sku": "LIV-001", "quantite": 2, "prix": "12.50" },
    { "sku": "LIV-007", "quantite": 1, "prix": "8.00" }
  ],
  "total": { "montant": "33.00", "devise": "EUR" },
  "remarque": null
}

Identifiants en chaînes · statut lisible · date ISO avec fuseau · montants exacts avec devise · clé remarque présente mais vide.

• Un seul style de nommage : camelCase (dateCreation) ou snake_case (date_creation) ; clés sans accent ni espace.
• Un champ, un type : quantite est toujours un nombre, jamais tantôt 2, tantôt "2".
• Listes : nom au pluriel ; tableau vide [] plutôt que null.
• Booléens nommés comme une question : estActif, enStock.
• Unité dans le nom : poidsKg, dureeSec, tailleOctets.
• Énumérations en chaînes lisibles : "statut": "expediee" plutôt que "statut": 3.
• Dates ISO 8601 avec fuseau : Z (UTC) ou +02:00.
• Montants : valeur exacte et code de devise ISO 4217 (EUR, USD).
• Imbrication modérée : au-delà de trois ou quatre niveaux, aplatir ou référencer.
• ! Clé absente (non fournie) et valeur null (vide) ne disent pas la même chose : fixer la convention et la documenter.

! GeoJSON (RFC 7946) écrit les positions [longitude, latitude] : l’inverse de l’usage courant.

• Listes : envelopper le tableau dans un objet — {"donnees": […], "suivant": …} — pour ajouter plus tard pagination et métadonnées sans rien casser.
• Ajouter un champ facultatif : sans risque. Retirer, renommer ou changer le type d’un champ : rupture → nouvelle version.
• Clients tolérants : ignorer les champs inconnus au lieu d’échouer.

Codes de réponse utiles

charset=utf-8 est superflu : JSON est en UTF-8 et RFC 8259 ne définit aucun paramètre charset.

{
  "type": "https://example.com/erreurs/stock",
  "title": "Stock insuffisant",
  "status": 409,
  "detail": "Il reste 1 exemplaire de LIV-007.",
  "instance": "/commandes/cmd-2026-00042"
}

Type de média : application/problem+json. Des membres supplémentaires sont permis.

JSON Pointer (RFC 6901)

JSON Patch (RFC 6902) · application/json-patch+json

[
  { "op": "test", "path": "/statut", "value": "expediee" },
  { "op": "replace", "path": "/statut", "value": "livree" },
  { "op": "add", "path": "/lignes/-",
    "value": { "sku": "LIV-009", "quantite": 1 } },
  { "op": "remove", "path": "/remarque" }
]

Opérations : add remove replace move copy test, appliquées dans l’ordre ; si l’une échoue, le patch entier échoue. /lignes/- : après le dernier élément.

JSON Merge Patch (RFC 7396) · application/merge-patch+json

On envoie un objet partiel : ses membres remplacent ceux de la cible, null supprime la clé, un tableau est remplacé en entier. Ex. {"statut": "livree", "remarque": null}.

• Décrire la structure attendue : types, champs obligatoires, valeurs permises.
• Valider automatiquement données reçues, fichiers de configuration, réponses d’API.
• Documenter, générer formulaires, code et tests ; OpenAPI 3.1 décrit les données des API en JSON Schema.
• Un schéma est lui-même un document JSON. Version en vigueur : 2020-12 (précédente : 2019-09).

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://example.com/schemas/commande.json",
  "title": "Commande",
  "type": "object",
  "required": ["id", "statut", "lignes"],
  "properties": {
    "id": { "type": "string", "pattern": "^cmd-\\d{4}-\\d{5}$" },
    "statut": {
      "enum": ["en-attente", "expediee", "livree", "annulee"]
    },
    "creeLe": { "type": "string", "format": "date-time" },
    "lignes": {
      "type": "array",
      "minItems": 1,
      "items": { "$ref": "#/$defs/ligne" }
    },
    "remarque": { "type": ["string", "null"], "maxLength": 500 }
  },
  "$defs": {
    "ligne": {
      "type": "object",
      "required": ["sku", "quantite"],
      "properties": {
        "sku": { "type": "string", "minLength": 1 },
        "quantite": { "type": "integer", "minimum": 1 },
        "prix": { "$ref": "#/$defs/decimal" }
      },
      "additionalProperties": false
    },
    "decimal": { "type": "string", "pattern": "^\\d+\\.\\d{2}$" }
  }
}

Dans une chaîne JSON, la barre oblique inverse d’une expression régulière se double : \\d pour \d.

Tous types

Chaînes

Nombres

Objets

Tableaux

Combiner et réutiliser

• Sans additionalProperties: false, une clé mal orthographiée ("quantitee") passe inaperçue.
• required se place dans l’objet parent, pas dans la propriété.
• pattern non ancré : "[0-9]+" accepte "abc1" → écrire "^[0-9]+$".
• format n’est qu’une annotation par défaut : activer son contrôle dans le validateur.
• integer accepte 1.0 : un nombre sans partie décimale est un entier.
• oneOf échoue si deux branches conviennent : anyOf suffit souvent.
• Anciens schémas (draft-04, draft-07) : definitions → $defs ; items en liste → prefixItems ; exclusiveMinimum booléen → nombre.

Sans fichier, jq lit l’entrée standard. | enchaîne les filtres, comme dans le shell.

Fichier d’exemple : livres.json

{ "livres": [
  { "titre": "Candide", "auteur": "Voltaire",
    "annee": 1759, "tags": ["conte", "philosophie"] },
  { "titre": "Notre-Dame de Paris", "auteur": "Hugo",
    "annee": 1831, "tags": ["roman"] },
  { "titre": "Les Misérables", "auteur": "Hugo",
    "annee": 1862, "tags": ["roman"] }
] }

! Sous Windows PowerShell 5.1, les guillemets doubles d’un filtre sont mal transmis : mettre le filtre dans un fichier (jq -f) ou utiliser Git Bash.

• Traiter en flux, sans tout charger en mémoire : JSON Lines, jq --stream, ijson (Python).
• Réduire le volume : gzip (très efficace sur JSON) ou format binaire (CBOR, MessagePack).

Options de json.tool : --sort-keys, --compact, --no-ensure-ascii, --json-lines.

! ConvertTo-Json s’arrête à la profondeur 2 par défaut : plus bas, les objets deviennent du texte ("System.Collections.Hashtable") → toujours préciser -Depth.

! @(1) | ConvertTo-Json donne 1 : le pipeline déroule le tableau. ConvertTo-Json -InputObject @(1) donne [1].

! Windows PowerShell 5.1 : curl y désigne Invoke-WebRequest → taper curl.exe.

const obj = JSON.parse(texte);      // texte → valeur
const txt = JSON.stringify(obj);    // valeur → texte
JSON.stringify(obj, null, 2);       // indenté
JSON.stringify(obj, ["id", "nom"]); // ces clés seules
const d = JSON.parse(texte, (cle, val) =>  // « reviver »
  cle === "creeLe" ? new Date(val) : val);
const rep = await fetch(url);       // API web
const data = await rep.json();

Ce que devient chaque valeur avec JSON.stringify (ci-dessus). Au retour, JSON.parse rend les dates en chaînes (les convertir avec un reviver) et arrondit les entiers au-delà de 2⁵³.

import json

with open("f.json", encoding="utf-8") as f:
    data = json.load(f)                 # fichier → objets

texte = json.dumps(data, ensure_ascii=False, indent=2)
data = json.loads(texte)                # chaîne → objets

with open("sortie.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

• ensure_ascii=True par défaut : é s’écrit \u00e9 → ensure_ascii=False.
• ! NaN et Infinity acceptés et produits par défaut, hors norme → allow_nan=False.
• Clés converties en chaînes : {1: "a"} → {"1": "a"} ; l’aller-retour ne rend pas l’original.
• datetime, Decimal, set → TypeError : default=str, ou conversion explicite.
• parse_float=Decimal : décimaux exacts. sort_keys=True : sortie stable, comparable.
• Sous Windows, toujours encoding="utf-8" ; fichier avec BOM : "utf-8-sig".

! Sans fuseau, "2026-09-29T14:30:00" est ambiguë : JavaScript la lit en heure locale.

PHP : options JSON_PRETTY_PRINT, JSON_UNESCAPED_UNICODE, JSON_THROW_ON_ERROR (à combiner par |). Go : seuls les champs exportés (majuscule) sont sérialisés ; nom JSON fixé par la balise json:"titre".

Messages suivis de la position : line 1 column 9 (char 8) · at position 8 (line 1 column 9). Les libellés varient selon les versions.

• Données reçues = non fiables : valider types, bornes et structure (schéma) avant usage.
• Jamais eval() pour lire du JSON : JSON.parse, json.loads.
• ! Ne jamais fabriquer du JSON par concaténation de chaînes : un guillemet dans une valeur casse ou détourne le document. Toujours passer par le sérialiseur.
• Limiter taille et profondeur : un document démesuré ou très imbriqué épuise mémoire ou pile (Python : RecursionError).
• Clés en double : deux analyseurs peuvent retenir des valeurs différentes et contourner un contrôle → les refuser.
• JavaScript : fusion récursive d’objets reçus → pollution de prototype par les clés __proto__, constructor, prototype.
• JSON inséré dans une page HTML : échapper < en \u003c pour neutraliser </script>.
• Aucun secret (mot de passe, clé d’API, jeton) dans un JSON versionné : variables d’environnement ou coffre-fort.