Tableaux et objets JSON : structure et imbrication pour débutants
L’essentiel : JSON ne propose que deux conteneurs : l'objet pour les champs nommés, le tableau pour les listes ordonnées. Apprenez à les combiner, à choisir le bon, et à corriger les trois erreurs les plus fréquentes : faux tableaux à clés numériques, virgule finale et apostrophes.

JSON ne vous donne que deux conteneurs : l'objet porte des champs nommés, le tableau porte des listes ordonnées — et presque chaque payload malformé s'explique par des guillemets, des virgules, ou une liste écrite comme un faux objet.
Un : JSON n'a que deux conteneurs
Quelle que soit la complexité d'une réponse d'API, tout se ramène à deux conteneurs et six types de valeurs. Un objet est une collection de paires clé/valeur enveloppée d'accolades {} ; un tableau est une liste ordonnée de valeurs enveloppée de crochets []. Une valeur peut être une chaîne, un nombre, true, false, null — ou encore un objet ou un tableau. Des objets dans des tableaux, des tableaux dans des objets : cette récursion constitue toute la puissance d'expression de JSON.
{
"user": { "name": "Ada", "active": true },
"roles": ["admin", "editor"],
"lastLogin": null,
"loginCount": 42
}
Cette constatation a une conséquence pratique : face à un payload déroutant, ne le lisez pas caractère par caractère. Vérifiez d'abord si le caractère le plus externe est { ou [. Si c'est un objet, lisez-le comme des champs nommés ; si c'est un tableau, lisez-le comme une liste, puis descendez niveau par niveau. Le diagramme grammatical de json.org tient sur une seule page précisément parce que deux structures plus la récursion couvrent tout.
Deux : écrire des objets, quatre règles dures
Les objets sont l'endroit où les débutants commettent le plus d'erreurs, mais les règles se réduisent à quatre :
- Les clés doivent être des chaînes entre guillemets doubles.
{name: "Ada"}et{'name': 'Ada'}sont tous deux invalides ; il faut écrire{"name": "Ada"}. Les littéraux d'objets JavaScript autorisent les clés nues et les apostrophes, JSON non — c'est la confusion la plus courante entre les deux. - Séparez les paires par des virgules, et ne laissez jamais de virgule après la dernière.
{"a": 1, "b": 2,}échoue avecUnexpected token }à l'accolade fermante. - Les clés devraient être uniques. RFC 8259 formule cela comme SHOULD, pas MUST : les clés dupliquées ne provoquent pas d'erreur, mais garder la première ou la dernière valeur dépend de l'implémentation, et les langages divergent. Ne vous y fiez jamais.
- L'ordre des clés n'a pas de signification.
{"a":1,"b":2}et{"b":2,"a":1}sont le même objet ; les outils de diff et les fonctions de comparaison ignorent l'ordre des clés. Si l'ordre compte, les données appartiennent à un tableau.
Trois : écrire des tableaux, l'ordre est une donnée
Les tableaux stockent les valeurs par position, et l'indexation commence à 0 : dans ["admin", "editor"], la chaîne "editor" est [1]. Cet ordre est significatif — c'est la différence essentielle entre tableaux et objets. Des résultats de recherche classés par pertinence, des entrées de journal ordonnées par date : cette information ne vit que dans la séquence, et la convertir en objet la détruit.
Deux recommandations pratiques. D'abord, gardez les éléments homogènes : [{"id":1},{"id":2}] est bien plus facile à consommer que [1, "text", true], qui est légal mais oblige chaque consommateur à tester les types à chaque étape. Ensuite, un tableau vide [] est une valeur parfaitement valide — quand un champ de liste n'a pas encore de contenu, émettez [] plutôt que null, afin que le consommateur n'ait pas à vérifier l'existence puis le vide.
[
{ "city": "Tokyo", "population": 13960000 },
{ "city": "Delhi", "population": 16780000 }
]
Quatre : l'imbrication, les quatre formes des vrais payloads
Les données réelles ne sont que ces deux conteneurs imbriqués l'un dans l'autre, et les motifs se ramènent à quatre formes :
| Forme | À quoi cela ressemble | Usage typique |
|---|---|---|
| Objet contenant un tableau | {"tags": ["a","b"]} |
Champ de liste d'une entité |
| Tableau d'objets | [{"id":1},{"id":2}] |
Listes d'enregistrements, résultats paginés |
| Objet contenant un objet | {"db": {"host": "..."}} |
Configuration groupée, blocs d'adresse |
| Tableau de tableaux | [[1,2],[3,4]] |
Matrices, lignes de table |
Une réponse d'API typique utilise un objet comme enveloppe et un tableau comme contenu :
{
"code": 0,
"data": {
"items": [
{ "id": 1, "title": "first" },
{ "id": 2, "title": "second" }
],
"page": 1,
"total": 2
}
}
Ne vous imbrichez pas pour le plaisir. Au-delà de trois ou quatre niveaux, les chemins d'accès deviennent illisibles et le code consommateur gonfle en parallèle. Les champs qui voyagent toujours ensemble appartiennent à un sous-objet : remplacez addrCity et addrZip par address: {city, zip}.
Cinq : objet ou tableau, une table de décision
| Question | Réponse | Pourquoi |
|---|---|---|
| Chaque valeur a-t-elle un nom ? | Objet | Accès par clé ; ajouter ou retirer des champs ne casse rien |
| Est-ce une liste d'enregistrements semblables ? | Tableau | L'ordre compte ; on peut mapper et filtrer |
| Besoin d'une recherche rapide par clé ? | Objet indexé par identifiant | Accès O(1) au lieu d'un parcours |
| Plusieurs attributs d'une même entité ? | Objet | Les attributs n'ont pas d'ordre inhérent |
| Une collection croissante d'éléments semblables ? | Tableau | La longueur s'étire librement |
Un anti-pattern mérite une mention spéciale : imiter un tableau avec un objet dont les clés sont "0", "1", "2". Cela se parse sans erreur, mais vous perdez la sémantique de longueur et les outils d'itération d'un vrai tableau, et les consommateurs doivent trier Object.keys avant de lire quoi que ce soit. Si les clés sont des numéros séquentiels, écrivez un vrai tableau. L'inverse vaut aussi : une liste de paires clé/valeur comme [{"key":"theme","value":"dark"}] est inférieure à l'objet {"theme": "dark"} — sauf si les clés sont réellement dynamiques et ne peuvent être déclarées à l'avance.
Six : trois erreurs fréquentes et leurs messages
| Forme fautive | Erreur typique | Correctif |
|---|---|---|
Virgule finale {"a":1,} |
Unexpected token } |
Supprimer la dernière virgule |
Apostrophes / clés nues {name:'Ada'} |
Unexpected token ' / Expected property name |
Guillemets doubles pour clés et chaînes, toujours |
Littéraux Python True / None |
Unexpected token T |
Remplacer par true / null |
| Faux tableau à clés numériques | Pas d'erreur, sémantique fausse | Réécrire en vrai tableau |
Deux habitudes de débogage : les parseurs signalent généralement une position après le caractère fautif, donc quand vous voyez position 42, regardez un ou deux caractères en arrière ; et pour un JSON immense sur une seule ligne, formatez-le d'abord — les numéros de ligne et de colonne battent les décalages de caractères à chaque fois. Le catalogue complet des erreurs se trouve dans la table de correspondance des erreurs JSON, et le flux de triage pas à pas dans comment corriger les erreurs d'analyse JSON.
Sept : après l'écriture, vérifiez la structure
Un JSON écrit à la main doit toujours passer par un parseur avant livraison. La vérification la plus légère tient en une ligne de commande :
python3 -m json.tool config.json > /dev/null && echo OK
jq empty config.json && echo OK
En ligne, collez le contenu dans la page formateur et validateur JSON — les erreurs de syntaxe reviennent avec ligne et colonne. Passez à la vue arborescente pour voir le type de chaque niveau d'un coup d'œil : si un nombre a été interprété comme chaîne, si les longueurs de tableaux correspondent. Et quand le public n'est pas technique, un payload tableau-d'objets peut être déplié en lignes et colonnes sur la page JSON vers table, ce qui vérifie au passage que vos données forment bien une liste d'enregistrements régulière.
Les questions sur le champ qui devrait être un tableau, ou sur la refonte d'une imbrication devenue trop profonde, relèvent de la modélisation de types — la lecture suivante est six types, précision numérique et pièges d'encodage.
Les tableaux et objets JSON peuvent-ils être convertis l'un en l'autre ?
Oui, mais pas sans perte. Convertir un objet en tableau signifie généralement transformer les clés en valeurs et perdre l'accès par clé ; convertir un tableau en objet exige d'inventer une clé pour chaque élément, et l'origine de ces clés est un nouveau problème de conception. Décidez selon la façon dont le consommateur lit les données, pas selon la commodité syntaxique.
Les clés d'objet peuvent-elles être dupliquées ?
Syntaxiquement oui — RFC 8259 dit seulement que les clés DEVRAIENT être uniques. Mais JavaScript garde la dernière valeur quand certaines bibliothèques de la famille C gardent la première : le comportement diffère selon les parseurs. En signature, diff ou hachage, les clés dupliquées provoquent des désaccords directs. Évitez-les côté producteur, et traitez les doublons d'une source inconnue comme un risque côté consommateur.
Un tableau peut-il contenir des valeurs de types différents ?
Syntaxiquement oui : [1, "a", true] est un JSON valide. Mais les tableaux hétérogènes forcent des vérifications de type à chaque position du code consommateur, et ils sont difficiles à exprimer dans un schéma. Sauf pour les matrices et tuples où la position est la sémantique, gardez les tableaux homogènes.
Pourquoi {name:'json'} échoue-t-il à la validation ?
Parce que JSON exige des guillemets doubles autour de chaque clé et de chaque valeur de type chaîne. {name:'json'} est un littéral d'objet JavaScript, pas du JSON. Remplacez-le par {"name": "json"} et la validation passe. Les apostrophes, clés nues et commentaires appartiennent aux dialectes comme JSON5/JSONC, qui exigent leurs propres parseurs plutôt que JSON.parse standard.