JSON vs YAML : Comparaison complète et guide de choix

# JSON vs YAML : Comparaison complète et guide de choix

JSON et YAML sont deux formats de sérialisation populaires. Ce guide compare leurs avantages, inconvénients et cas d'usage.

Vue d'ensemble

JSON (JavaScript Object Notation)

Avantages :

• Syntaxe simple et stricte
• Parse rapide
• Support universel
• Compact
• Validation facile

Inconvénients :

• Moins lisible
• Pas de commentaires
• Verbeux pour humains
• Syntaxe rigide

YAML (YAML Ain't Markup Language)

Avantages :

• Très lisible
• Supporte commentaires
• Syntaxe concise
• Types avancés
• Ancres et références

Inconvénients :

• Parse plus lent
• Indentation stricte
• Erreurs subtiles
• Moins universel

Comparaison syntaxe

Objet simple

JSON :

{
  "nom": "Alice",
  "age": 30,
  "ville": "Paris"
}

YAML :

nom: Alice
age: 30
ville: Paris

Tableau

JSON :

{
  "fruits": ["pomme", "banane", "orange"]
}

YAML :

fruits:
  - pomme
  - banane
  - orange

ou :

fruits: [pomme, banane, orange]

Objet imbriqué

JSON :

{
  "utilisateur": {
    "nom": "Alice",
    "adresse": {
      "ville": "Paris",
      "code": "75001"
    }
  }
}

YAML :

utilisateur:
  nom: Alice
  adresse:
    ville: Paris
    code: "75001"

Fonctionnalités avancées

Commentaires

JSON :

{
  "_comment": "Pas de commentaires natifs",
  "nom": "Alice"
}

YAML :

# Ceci est un commentaire
nom: Alice  # Commentaire inline

Multi-ligne

JSON :

{
  "description": "Première ligne\nDeuxième ligne\nTroisième ligne"
}

YAML :

# Style literal (|)
description: |
  Première ligne
  Deuxième ligne
  Troisième ligne

# Style folded (>)
bio: >
  Ce texte très long
  sera replié en une
  seule ligne.

Ancres et références (YAML uniquement)

defaults: &defaults
  timeout: 30
  retry: 3

prod:
  <<: defaults

  host: prod.example.com

dev:
  <<: defaults
  host: dev.example.com
  timeout: 60

Performance

Benchmark parsing

import json
import yaml
import time

data = {"users": [{"name": f"User{i}", "age": i} for i in range(1000)]}

# JSON
json_str = json.dumps(data)
start = time.time()
json.loads(json_str)
json_time = time.time() - start

# YAML
yaml_str = yaml.dump(data)
start = time.time()
yaml.safe_load(yaml_str)
yaml_time = time.time() - start

print(f"JSON: {json_time:.4f}s")
print(f"YAML: {yaml_time:.4f}s")
# JSON est typiquement 5-10x plus rapide

Taille fichier

JSON :

• Plus compact sans indentation
• Verbeux avec formatage

YAML :

• Plus lisible
• Généralement plus court
• Pas de guillemets/accolades

Cas d'usage

JSON préférable

APIs REST

// Response API

   fetch('/api/users')
     .then(res => res.json())
     .then(data => console.log(data));

Data exchange

- Format universel

- Parse rapide

- Validation stricte

Configuration simple

{

     "port": 3000,
     "host": "localhost",
     "debug": true
   }

Mobile/Web apps

- Support natif navigateurs

- Compact

- Performance

YAML préférable

Configuration complexe

# docker-compose.yml

   version: '3'
   services:
     web:
       image: nginx
       ports:
         - "80:80"
     db:
       image: postgres
       environment:
         POSTGRES_PASSWORD: secret

CI/CD pipelines

# .github/workflows/test.yml

   name: Tests
   on: [push, pull_request]
   jobs:
     test:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v2
         - run: npm test

Infrastructure as Code

# Kubernetes deployment

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: myapp
   spec:
     replicas: 3
     template:
       spec:
         containers:
         - name: app
           image: myapp:latest

Documentation configuration

- Lisible par humains

- Commentaires explicatifs

- Maintenance facile

Conversion

JSON vers YAML

import json
import yaml

# Charger JSON
with open('config.json') as f:
    data = json.load(f)

# Sauver en YAML
with open('config.yaml', 'w') as f:
    yaml.dump(data, f, default_flow_style=False)

YAML vers JSON

import json
import yaml

# Charger YAML
with open('config.yaml') as f:
    data = yaml.safe_load(f)

# Sauver en JSON
with open('config.json', 'w') as f:
    json.dump(data, f, indent=2)

CLI tools

# yq (YAML processor)
yq eval -o=json file.yaml > file.json

# jq (JSON processor)
jq -r . file.json | yq eval -P - > file.yaml

# Python one-liner
python -c "import sys,yaml,json; json.dump(yaml.safe_load(sys.stdin), sys.stdout, indent=2)" < file.yaml > file.json

Sécurité

JSON

Sécurisé par design :

• Pas d'exécution code
• Parse sûr natif
• Validation stricte

Risques mineurs :

• Injection dans génération dynamique
• DoS avec structures profondes

YAML

Risques potentiels :

# ⚠️ DANGEREUX - yaml.load
data = yaml.load(input)  # Peut exécuter code Python

# ✅ SÛR - yaml.safe_load
data = yaml.safe_load(input)  # Limité types de base

Toujours utiliser safe_load !

Validation

JSON Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "nom": {"type": "string"},
    "age": {"type": "number"}
  },
  "required": ["nom"]
}

YAML Schema

Moins standardisé, mais possible :

from yamale import make_schema, make_data, validate

schema = make_schema('schema.yaml')
data = make_data('data.yaml')
validate(schema, data)

Support écosystème

JSON

• Langages : Universel (tous)
• Bases de données : PostgreSQL, MongoDB, etc.
• APIs : Standard de facto
• Outils : Nombreux

YAML

• Langages : Bon support (Python, Ruby, Go, etc.)
• DevOps : Kubernetes, Docker, CI/CD
• Config : Ansible, Terraform
• Outils : Moins nombreux

Guide de choix

Choisir JSON si :

• ✅ API ou data exchange
• ✅ Performance critique
• ✅ Support universel requis
• ✅ Validation stricte
• ✅ Parse par navigateur
• ✅ Configuration simple

Choisir YAML si :

• ✅ Configuration complexe
• ✅ Lisibilité humaine prioritaire
• ✅ Commentaires nécessaires
• ✅ DevOps/infrastructure
• ✅ CI/CD pipelines
• ✅ Édition manuelle fréquente

Hybride possible

// Développement: YAML lisible
// Production: JSON rapide

// Build step
const yaml = require('js-yaml');
const fs = require('fs');

const config = yaml.load(fs.readFileSync('config.yaml'));
fs.writeFileSync('config.json', JSON.stringify(config));

Conclusion

JSON :

• Rapide, universel, strict
• Idéal APIs et data exchange
• Moins lisible par humains

YAML :

• Lisible, flexible, commentaires
• Idéal configuration et DevOps
• Parse plus lent

Recommandation :

• APIs/Web : JSON
• Config/DevOps : YAML
• Data storage : JSON
• Documentation : YAML

Choisissez selon votre besoin spécifique !