La conversion YAML vers JSON est l'une des taches de format de donnees les plus courantes pour les developpeurs. Que vous geriez des manifestes Kubernetes, des fichiers Docker Compose ou des pipelines CI/CD, vous devez frequemment convertir entre YAML et JSON. Ce guide complet couvre les outils de conversion, le processus d'analyse, les exemples de code et les bonnes pratiques.
Essayez notre convertisseur YAML vers JSON / JSON vers YAML gratuit en ligne.
Qu'est-ce que YAML ?
YAML (YAML Ain't Markup Language) est un langage de serialisation de donnees convivial, largement utilise pour les fichiers de configuration. Un analyseur YAML lit la structure basee sur l'indentation et la convertit en structures de donnees natives.
YAML utilise l'indentation par espaces (jamais de tabulations) pour denoter la structure. Il prend en charge les types scalaires, les sequences (tableaux) et les mappings (dictionnaires). Les fonctionnalites avancees incluent les ancres et alias, les chaines multi-lignes et les documents multiples separes par ---. La syntaxe YAML est un surensemble de JSON.
YAML est le format prefere pour Kubernetes, Ansible, Docker Compose, GitHub Actions, OpenAPI et de nombreux outils cloud-natifs. Sa lisibilite superieure a JSON en fait le choix ideal pour les fichiers edites par des humains.
YAML vs JSON : Differences cles
Comprendre les differences entre YAML et JSON aide a choisir le bon format :
| Caracteristique | YAML | JSON |
|---|---|---|
| Syntaxe | Basee sur l'indentation | Delimitee par des accolades |
| Commentaires | Oui avec # | Non |
| Types | Chaines, entiers, flottants, booleens, null, dates | Chaines, nombres, booleens, null, tableaux, objets |
| Lisibilite | Tres lisible | Plus verbeux |
| Vitesse | Plus lent | Plus rapide |
Comment fonctionne la conversion YAML vers JSON
Un convertisseur YAML vers JSON effectue un processus d'analyse et de serialisation en plusieurs etapes.
Etape 1 : Analyse lexicale — L'analyseur YAML identifie les tokens : niveaux d'indentation, separateurs, indicateurs de blocs, ancres et alias.
Etape 2 : Construction de l'AST — Les tokens sont assembles en un arbre syntaxique abstrait representant la structure hierarchique.
Etape 3 : Structures de donnees natives — L'AST est converti en structures natives du langage avec resolution de types.
Etape 4 : Serialisation JSON — Les structures sont serialisees en JSON. Les commentaires YAML sont supprimes.
Exemples de code YAML vers JSON
JavaScript / Node.js (js-yaml)
La bibliotheque js-yaml est l'analyseur YAML le plus populaire pour JavaScript :
// ===== YAML to JSON (Node.js) =====
const yaml = require('js-yaml');
const fs = require('fs');
// Parse YAML string to JavaScript object
const yamlString = `
server:
host: localhost
port: 8080
ssl: true
database:
name: myapp
replicas:
- host: db1.example.com
port: 5432
- host: db2.example.com
port: 5432
# Connection pool settings
pool:
min: 5
max: 20
`;
const data = yaml.load(yamlString);
const json = JSON.stringify(data, null, 2);
console.log(json);
// {
// "server": {
// "host": "localhost",
// "port": 8080,
// "ssl": true
// },
// "database": {
// "name": "myapp",
// "replicas": [
// { "host": "db1.example.com", "port": 5432 },
// { "host": "db2.example.com", "port": 5432 }
// ],
// "pool": { "min": 5, "max": 20 }
// }
// }
// ===== JSON to YAML =====
const jsonData = { name: 'app', version: '2.0', features: ['auth', 'logging'] };
const yamlOutput = yaml.dump(jsonData, { indent: 2 });
console.log(yamlOutput);
// name: app
// version: '2.0'
// features:
// - auth
// - logging
// ===== Read YAML file and convert to JSON =====
const fileContent = fs.readFileSync('config.yaml', 'utf8');
const config = yaml.load(fileContent);
fs.writeFileSync('config.json', JSON.stringify(config, null, 2));
// ===== Handle multi-document YAML =====
const multiDoc = `
---
name: doc1
---
name: doc2
`;
const docs = yaml.loadAll(multiDoc);
console.log(JSON.stringify(docs, null, 2));
// [{ "name": "doc1" }, { "name": "doc2" }]Python (PyYAML)
Utilisez toujours yaml.safe_load() pour eviter l'execution de code arbitraire :
import yaml
import json
# ===== YAML to JSON =====
yaml_string = """
server:
host: localhost
port: 8080
ssl: true
database:
name: myapp
replicas:
- host: db1.example.com
port: 5432
- host: db2.example.com
port: 5432
pool:
min: 5
max: 20
"""
# Always use safe_load (prevents arbitrary code execution)
data = yaml.safe_load(yaml_string)
json_output = json.dumps(data, indent=2, ensure_ascii=False)
print(json_output)
# ===== JSON to YAML =====
json_string = '{"name": "app", "version": "2.0", "features": ["auth", "logging"]}'
json_data = json.loads(json_string)
yaml_output = yaml.dump(json_data, default_flow_style=False, allow_unicode=True)
print(yaml_output)
# ===== File conversion =====
# YAML file to JSON file
with open('config.yaml', 'r') as yf:
config = yaml.safe_load(yf)
with open('config.json', 'w') as jf:
json.dump(config, jf, indent=2)
# JSON file to YAML file
with open('data.json', 'r') as jf:
data = json.load(jf)
with open('data.yaml', 'w') as yf:
yaml.dump(data, yf, default_flow_style=False)
# ===== Handle multi-document YAML =====
multi_yaml = """
---
name: doc1
type: config
---
name: doc2
type: data
"""
docs = list(yaml.safe_load_all(multi_yaml))
print(json.dumps(docs, indent=2))
# ===== Preserve key order (Python 3.7+) =====
# dict maintains insertion order by default
ordered = yaml.safe_load(yaml_string)
print(json.dumps(ordered, indent=2)) # keys stay in YAML orderBash / CLI (yq)
Pour la conversion en ligne de commande, yq est l'outil le plus efficace :
# ===== yq: YAML processor (like jq for YAML) =====
# Convert YAML file to JSON
yq -o=json config.yaml
# Convert YAML to JSON and save to file
yq -o=json config.yaml > config.json
# Convert JSON to YAML
yq -P config.json
# Convert JSON to YAML and save
yq -P config.json > config.yaml
# Extract a specific field from YAML as JSON
yq -o=json '.server.port' config.yaml
# ===== Python one-liner =====
# YAML to JSON (stdin)
cat config.yaml | python3 -c \
'import sys,yaml,json; json.dump(yaml.safe_load(sys.stdin),sys.stdout,indent=2)'
# YAML to JSON (file)
python3 -c \
'import yaml,json; print(json.dumps(yaml.safe_load(open("config.yaml")),indent=2))'
# JSON to YAML
cat data.json | python3 -c \
'import sys,yaml,json; print(yaml.dump(json.load(sys.stdin),default_flow_style=False))'
# ===== Ruby one-liner =====
ruby -ryaml -rjson -e 'puts JSON.pretty_generate(YAML.load($stdin.read))' < config.yaml
# ===== Pipe YAML from curl to JSON =====
curl -s https://raw.githubusercontent.com/example/repo/main/config.yaml | \
yq -o=json
# ===== Validate YAML before converting =====
yamllint config.yaml && yq -o=json config.yamlGo (gopkg.in/yaml.v3)
En Go, gopkg.in/yaml.v3 fournit une analyse YAML robuste :
package main
import (
"encoding/json"
"fmt"
"log"
"gopkg.in/yaml.v3"
)
func main() {
// YAML input string
yamlData := []byte(`
server:
host: localhost
port: 8080
ssl: true
database:
name: myapp
replicas:
- host: db1.example.com
port: 5432
- host: db2.example.com
port: 5432
`)
// Parse YAML into interface{}
var data interface{}
err := yaml.Unmarshal(yamlData, &data)
if err != nil {
log.Fatalf("YAML parse error: %v", err)
}
// Convert map[string]interface{} keys for JSON compatibility
data = convertMapKeys(data)
// Marshal to JSON
jsonData, err := json.MarshalIndent(data, "", " ")
if err != nil {
log.Fatalf("JSON marshal error: %v", err)
}
fmt.Println(string(jsonData))
}
// convertMapKeys recursively converts map[interface{}]interface{}
// to map[string]interface{} for JSON compatibility
func convertMapKeys(v interface{}) interface{} {
switch v := v.(type) {
case map[string]interface{}:
result := make(map[string]interface{})
for key, val := range v {
result[key] = convertMapKeys(val)
}
return result
case []interface{}:
for i, val := range v {
v[i] = convertMapKeys(val)
}
return v
default:
return v
}
}Conversion JSON vers YAML
La direction inverse est tout aussi importante pour stocker des donnees API en configuration YAML.
Les commentaires sont perdus lors de la conversion aller-retour YAML-JSON-YAML. Utilisez ruamel.yaml pour les preserver.
Bonnes pratiques : indentation de 2 espaces, eviter le style flow, citer les chaines ambigues, valider la sortie.
Pieges YAML courants
La flexibilite de YAML introduit plusieurs pieges :
Tabulations vs espaces — YAML interdit les tabulations pour l'indentation.
Piege des booleens — yes, no, on, off sont interpretes comme des booleens. Citez ces valeurs.
# The YAML boolean trap - these all become true or false in JSON!
# YAML 1.1 boolean values (case-insensitive):
is_active: yes # â true
is_active: no # â false
is_active: on # â true
is_active: off # â false
is_active: y # â true
is_active: n # â false
is_active: true # â true
is_active: false # â false
# Real-world problems:
countries:
- US # string "US" â
- GB # string "GB" â
- NO # boolean false â (Norway disappears!)
- FR # string "FR" â
# Fix: always quote ambiguous values
countries:
- "US"
- "GB"
- "NO" # string "NO" â
- "FR"
# Version numbers are also problematic:
version: 1.0 # â float 1 (not string "1.0")
version: "1.0" # â string "1.0" âChaines multi-lignes — | preserve les retours a la ligne, > les remplace par des espaces.
# YAML multiline string variants
# Literal block scalar (|) - preserves newlines
description: |
This is line one.
This is line two.
This is line three.
# JSON: "This is line one.\nThis is line two.\nThis is line three.\n"
# Folded block scalar (>) - replaces newlines with spaces
description: >
This is a long
paragraph that will
be folded into one line.
# JSON: "This is a long paragraph that will be folded into one line.\n"
# Chomping indicators:
keep_trailing: |+ # Keep ALL trailing newlines
text
strip_trailing: |- # Strip ALL trailing newlines
text
clip_trailing: | # Keep exactly ONE trailing newline (default)
textCaracteres speciaux — Les deux-points et crochets dans les valeurs doivent etre cites.
Ancres et alias — Completement developpes lors de la conversion JSON.
# YAML anchors and aliases
# Define an anchor with &
defaults: &default_settings
adapter: postgres
host: localhost
port: 5432
# Reuse with alias *
development:
database:
<<: *default_settings # Merge key: inherits all defaults
database: myapp_dev
production:
database:
<<: *default_settings # Same defaults
database: myapp_prod
host: db.production.com # Override specific values
# After JSON conversion (anchors fully expanded):
# {
# "defaults": { "adapter": "postgres", "host": "localhost", "port": 5432 },
# "development": {
# "database": {
# "adapter": "postgres", "host": "localhost",
# "port": 5432, "database": "myapp_dev"
# }
# },
# "production": {
# "database": {
# "adapter": "postgres", "host": "db.production.com",
# "port": 5432, "database": "myapp_prod"
# }
# }
# }Nombres et dates — 1.0 devient un flottant, pas la chaine "1.0".
Bonnes pratiques YAML
Suivez ces pratiques pour un YAML propre et maintenable :
Indentation coherente — 2 espaces, conformement aux conventions Kubernetes.
Citer les chaines — En cas de doute, utilisez des guillemets.
Eviter le piege des booleens — Faites attention aux codes pays et valeurs de bascule.
Validation par schema — Validez avec JSON Schema.
Utiliser yamllint — Integrez-le dans votre pipeline CI/CD.
# .yamllint.yml configuration example
---
extends: default
rules:
line-length:
max: 120
allow-non-breakable-words: true
indentation:
spaces: 2
indent-sequences: true
comments:
min-spaces-from-content: 1
truthy:
check-keys: true
allowed-values: ['true', 'false']
document-start:
present: true
trailing-spaces: enable
new-line-at-end-of-file: enable
# Run yamllint:
# yamllint .
# yamllint config.yaml
# yamllint -d "{extends: default}" config.yamlCommentaires judicieux — N'oubliez pas qu'ils sont perdus lors de la conversion en JSON.
Questions frequemment posees
Quelle est la difference entre YAML et JSON ?
YAML utilise l'indentation, supporte les commentaires et offre des fonctionnalites avancees. JSON utilise des delimiteurs, ne supporte pas les commentaires et a des types plus limites. YAML est prefere pour la configuration, JSON pour les API.
Comment convertir YAML en JSON ?
Utilisez des outils en ligne, yq en CLI, ou des bibliotheques : js-yaml en JavaScript, PyYAML en Python, gopkg.in/yaml.v3 en Go. Toutes les methodes analysent le YAML puis serialisent en JSON.
Quand utiliser YAML ou JSON ?
YAML pour les fichiers de configuration edites par des humains. JSON pour les API et l'echange de donnees entre services.
Maitriser la conversion YAML vers JSON est essentiel pour le DevOps moderne. Utilisez notre outil gratuit et validateur YAML pour optimiser votre flux de travail.
Convertissez YAML en JSON et JSON en YAML instantanement avec notre outil gratuit.