La conversion YAML a JSON es una de las tareas de formato de datos mas comunes para los desarrolladores. Ya sea gestionando manifiestos de Kubernetes, archivos Docker Compose o pipelines CI/CD, frecuentemente necesitas convertir entre YAML y JSON. Esta guia completa cubre herramientas de conversion, el proceso de analisis, ejemplos de codigo y mejores practicas.
Prueba nuestro convertidor gratuito YAML a JSON / JSON a YAML en linea.
Que es YAML?
YAML (YAML Ain't Markup Language) es un lenguaje de serializacion de datos amigable para humanos, ampliamente utilizado para archivos de configuracion. Un analizador YAML lee la estructura basada en indentacion y la convierte en estructuras de datos nativas.
YAML usa indentacion con espacios (nunca tabulaciones) para denotar estructura. Soporta tipos escalares, secuencias (arrays) y mappings (diccionarios). Las caracteristicas avanzadas incluyen anclas y alias, cadenas multi-linea y multiples documentos separados por ---. YAML es un superconjunto de JSON.
YAML es el formato preferido para Kubernetes, Ansible, Docker Compose, GitHub Actions y muchas herramientas cloud-native. Su legibilidad superior a JSON lo hace ideal para archivos editados frecuentemente por humanos.
YAML vs JSON: Diferencias clave
Comprender las diferencias ayuda a elegir el formato correcto:
| Caracteristica | YAML | JSON |
|---|---|---|
| Sintaxis | Basada en indentacion | Delimitada por llaves |
| Comentarios | Si con # | No |
| Tipos | Cadenas, enteros, flotantes, booleanos, null, fechas | Cadenas, numeros, booleanos, null, arrays, objetos |
| Legibilidad | Muy legible | Mas verboso |
| Velocidad | Mas lento | Mas rapido |
Como funciona la conversion YAML a JSON
Un convertidor YAML a JSON realiza un proceso de analisis y serializacion en multiples pasos.
Paso 1: Analisis lexico — El analizador YAML identifica tokens: niveles de indentacion, separadores e indicadores de bloque.
Paso 2: Construccion del AST — Los tokens se ensamblan en un arbol de sintaxis abstracta.
Paso 3: Estructuras de datos nativas — El AST se convierte en estructuras nativas con resolucion de tipos.
Paso 4: Serializacion JSON — Las estructuras se serializan como JSON. Los comentarios YAML se descartan.
Ejemplos de codigo YAML a JSON
JavaScript / Node.js (js-yaml)
La biblioteca js-yaml es el analizador YAML mas popular para 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)
Use siempre yaml.safe_load() para prevenir ejecucion de codigo arbitrario:
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)
Para conversion en linea de comandos, yq es la herramienta mas eficiente:
# ===== 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 proporciona analisis YAML robusto:
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 a YAML
La direccion inversa es igualmente importante para almacenar datos de API como configuracion YAML.
Los comentarios se pierden en la conversion ida y vuelta. Use ruamel.yaml para preservarlos.
Mejores practicas: indentacion de 2 espacios, evitar estilo flow, citar cadenas ambiguas, validar la salida.
Trampas comunes de YAML
La flexibilidad de YAML introduce varias trampas:
Tabulaciones vs espacios — YAML prohibe tabulaciones para indentacion.
Trampa de booleanos — yes, no, on, off se interpretan como booleanos.
# 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" ✓Cadenas multi-linea — | preserva saltos de linea, > los reemplaza por espacios.
# 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 especiales — Dos puntos y corchetes en valores deben citarse.
Anclas y alias — Se expanden completamente en la conversion a 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"
# }
# }
# }Numeros y fechas — 1.0 se convierte en flotante, no en cadena "1.0".
Mejores practicas YAML
Siga estas practicas para YAML limpio y mantenible:
Indentacion consistente — 2 espacios, siguiendo convenciones de Kubernetes.
Citar cadenas defensivamente — En caso de duda, use comillas.
Evitar la trampa de booleanos — Cuidado con codigos de pais y valores de conmutacion.
Validacion por esquema — Validar con JSON Schema.
Usar yamllint — Integrarlo en el 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.yamlComentarios inteligentes — Se pierden al convertir a JSON.
Preguntas frecuentes
Cual es la diferencia entre YAML y JSON?
YAML usa indentacion, soporta comentarios y ofrece funciones avanzadas. JSON usa delimitadores, no soporta comentarios y tiene tipos mas limitados. YAML es preferido para configuracion, JSON para APIs.
Como convierto YAML a JSON?
Use herramientas en linea, yq en CLI o bibliotecas: js-yaml en JavaScript, PyYAML en Python, gopkg.in/yaml.v3 en Go.
Cuando usar YAML o JSON?
YAML para archivos de configuracion editados por humanos. JSON para APIs e intercambio de datos entre servicios.
Dominar la conversion YAML a JSON es esencial para el DevOps moderno. Use nuestra herramienta gratuita y validador YAML para optimizar su flujo de trabajo.
Convierte YAML a JSON y JSON a YAML al instante con nuestra herramienta gratuita.