Herramienta de Formato YAML
¿Qué es YAML?
El formateador YAML hace que los archivos YAML sean más fáciles de leer aplicando indentación, saltos de línea y estructura visible. YAML se usa en configuración CI, manifiestos Kubernetes, Docker Compose, generadores de sitios estáticos, localización, archivos OpenAPI y ajustes de aplicaciones. A diferencia de JSON, YAML depende mucho de indentación, marcadores de lista, dos puntos, comillas, anchors y cadenas multilínea; un pequeño error de formato puede crear una estructura distinta. La herramienta ayuda a leer, limpiar y detectar problemas sintácticos evidentes, pero no sustituye validación de esquema ni checks propios de cada herramienta. En Kubernetes, GitHub Actions, Ansible o producción, conviene probar el resultado en el sistema objetivo.
Cómo usar
Cómo usar
- Pega o introduce datos YAML en el cuadro de entrada izquierdo
- Selecciona el tamaño de sangría que coincida con el estilo de tu proyecto
- Haz clic en 'Formatear' para embellecer, 'Minimizar' para reducir el tamaño o 'Validar' para comprobar la sintaxis
- Los resultados aparecerán a la derecha
- Haz clic en 'Copiar' para guardar en el portapapeles
Descripción de opciones
Atajos de teclado
- Ctrl + EnterFormatear
- Ctrl + Shift + CCopiar resultado
Consejos de YAML
- YAML es sensible a la sangría, así que revisa las listas y mapas anidados tras formatear antes de usar el resultado en archivos de CI, Kubernetes o despliegue.
- Valida contra el esquema de la herramienta de destino cuando sea posible; un YAML sintácticamente válido puede no serlo para GitHub Actions, Docker Compose u OpenAPI.
Casos de uso
Principio técnico
El formateo YAML está anclado a la especificación YAML 1.2.2 (revisada en octubre de 2021), que define formalmente JSON como un subconjunto estricto de YAML: cualquier documento JSON válido es analizable como YAML. El análisis se realiza en tres capas: una capa de presentación escanea puntos de código Unicode y resuelve secuencias de escape de caracteres; una capa de serialización construye un grafo de nodos de escalares, secuencias y mapas; una capa nativa aplica el YAML Core Schema para coercionar escalares en los tipos resueltos `!!str`, `!!int`, `!!float`, `!!bool`, `!!null`, `!!seq`, `!!map`. Las bibliotecas de ejecución comunes incluyen js-yaml y el paquete más reciente `yaml` en Node, PyYAML y ruamel.yaml en Python, y SnakeYAML en la JVM. Los formateadores del lado del navegador típicamente analizan en un objeto JS simple mediante `load`/`dump` de js-yaml y hacen ida-vuelta. La indentación es la primitiva fundamental: solo se permite el espacio ASCII (U+0020); la especificación prohíbe explícitamente los caracteres de tabulación (U+0009) para la indentación en el §6.1, lo cual es la causa más común de error al pegar desde un editor de código que autoconvierte. El estilo de bloque determina la anidación puramente por posición de columna, por lo que los nodos hijos deben estar más indentados que su padre por al menos un espacio (dos por convención). El estilo de flujo toma prestada la sintaxis JSON: `[1, 2, 3]` y `{a: 1, b: 2}` y puede anidarse dentro del estilo de bloque para líneas únicas. Los escalares de bloque usan plegado basado en indicadores: `|` (literal) preserva los saltos de línea exactamente, `>` (plegado) colapsa saltos de línea individuales en espacios y mantiene líneas en blanco como separadores de párrafo, y los indicadores de recorte `-` (eliminar saltos de línea finales) y `+` (conservar todos los saltos de línea finales) se adjuntan después del indicador (`|-`, `>+`). Las reglas de entrecomillado difieren: los escalares entrecomillados simples tratan `\` literalmente y usan `''` para incrustar una comilla; los escalares entrecomillados dobles respetan las secuencias de escape de estilo C (`\n`, `\t`, `\uXXXX`). Los formateadores típicamente normalizan a un estilo de bloque y vuelven a emitir anclas y alias. Un ancla `&name` marca un nodo; un alias `*name` lo referencia; la clave de fusión `<<: *name` (un vestigio de YAML 1.1 aún soportado por la mayoría de los parsers) extrae claves de otro mapa al actual. Los flujos multidocumento se separan por marcadores de inicio `---` y marcadores de fin opcionales `...`, el patrón que Kubernetes usa para incluir múltiples recursos en un manifiesto. Dos trampas conocidas vale la pena reemitirlas de forma segura: el problema de Noruega, el escalar sin comillas `no` se interpreta como `false` bajo el esquema YAML 1.1 (y el código de país se convierte en booleano), y CVE-2017-18342, donde `yaml.load` de PyYAML deserializaba objetos Python arbitrarios, corregido cambiando a `safe_load`. Ambas son razones por las que un formateador debe tratar la resolución de escalares con cuidado y nunca ejecutar constructores etiquetados. El análisis es O(n) sobre la longitud de entrada; los comentarios se descartan por la mayoría de las bibliotecas basadas en AST porque no forman parte del modelo de información YAML.
- Especificación: YAML 1.2.2 (oct. 2021). JSON es un subconjunto estricto de YAML 1.2, por lo que cualquier documento JSON válido se analiza como YAML; las bibliotecas comunes son js-yaml, el paquete `yaml`, PyYAML, ruamel.yaml y SnakeYAML.
- La indentación debe ser espacio ASCII (U+0020); los caracteres de tabulación (U+0009) están prohibidos para la indentación según el §6.1: la causa más común de errores `mapping values are not allowed here`.
- Estilo de bloque vs. flujo: el bloque usa anidación por posición de columna (2 o 4 espacios por convención); el flujo usa sintaxis similar a JSON `[1, 2, 3]` y `{a: 1}`. Ambos pueden anidarse.
- Escalares de bloque: `|` literal preserva saltos de línea, `>` plegado colapsa saltos de línea individuales en espacios; los indicadores de recorte `-` (eliminar) y `+` (conservar) se adjuntan al indicador, por ejemplo `|-`, `>+`.
- Las anclas `&name` marcan nodos, los alias `*name` los referencian, y la clave de fusión `<<: *name` extrae claves de otro mapa (vestigio de YAML 1.1, soportado por la mayoría de los parsers).
- Flujos multidocumento separados por `---` (inicio) y `...` (fin) opcionales: el patrón que Kubernetes usa para incluir múltiples recursos en un manifiesto.
- Trampas: el problema de Noruega (`no`/`yes`/`on`/`off` sin comillas analizados como booleanos bajo el esquema YAML 1.1; el YAML 1.2 Core Schema corrige la mayoría de estos casos) y CVE-2017-18342 (ejecución arbitraria de código con `yaml.load` de PyYAML; usar `safe_load`).
Ejemplos
Corregir indentación inconsistente en un archivo de configuración
Entrada (rota):
server:
port: 8080
host: localhost
debug: true
Formateado (2 espacios):
server:
port: 8080
host: localhost
debug: trueLista anidada de servicios en docker-compose.yml
version: '3.8'
services:
web:
image: nginx:1.25
ports:
- "80:80"
- "443:443"
depends_on:
- api
api:
image: node:20
environment:
NODE_ENV: productionManifiesto Deployment de Kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
name: web-app
labels:
app: web
spec:
replicas: 3
selector:
matchLabels:
app: web
template:
spec:
containers:
- name: web
image: nginx:1.25Convertir YAML a JSON para una pipeline de jq
Entrada YAML:
user:
id: 42
name: alice
roles:
- admin
- editor
Salida JSON:
{
"user": {
"id": 42,
"name": "alice",
"roles": ["admin", "editor"]
}
}Detectar un espacio faltante después de los dos puntos
Entrada:
name:alice
age: 30
Error en la línea 1: falta espacio después de los dos puntos
Corregido:
name: alice
age: 30Preguntas frecuentes
¿Qué incluye el formateo de YAML?
Normalización de la indentación (normalmente 2 espacios), estilo de comillas consistente, alineación de los marcadores de lista y reescritura de colecciones inline largas a estilo de bloque. La mayoría del YAML real se edita a mano y acumula estilos inconsistentes; el formateador los uniforma.
¿Convertirá el estilo flow a estilo block?
Muchas versiones permiten elegir entre estilo flow (similar a JSON, {key: value, key2: value2}) y estilo block (multilínea con indentación). El estilo block es más legible para edición humana; el flow es más compacto. Pasar de uno a otro preserva los datos pero cambia la apariencia.
¿Por qué cambia mis comillas?
YAML admite strings sin comillas, con comillas simples y con comillas dobles, con diferencias sutiles. Yes/no, true/false, on/off se interpretan como booleanos a menos que vayan entre comillas; los números sin comillas son números, con comillas son strings. El formateador puede añadir comillas para desambiguar valores que de otro modo se interpretarían mal.
¿Conserva los comentarios?
La mayoría de versiones conservan los comentarios YAML (#), aunque su posición relativa a los nodos del AST puede desplazarse ligeramente. Los comentarios encima de claves suelen quedar arriba; los comentarios al final de la misma línea quedan adjuntos. Recarga después de formatear y comprueba si la ubicación de los comentarios sigue teniendo sentido.
¿Se sube el YAML?
No. El parseo y el formateo se ejecutan en tu navegador con js-yaml o similar. El YAML pegado no se transmite.
¿Por qué el ciclo de ida y vuelta cambia los anchors y aliases de mi YAML?
La sintaxis & (anchor) y * (alias) de YAML te permite referenciar un valor una vez y reutilizarlo. Algunos formateadores expanden los aliases inline por defecto, perdiendo la deduplicación. Busca una opción para preservar los anchors si tu tooling depende de ellos.
¿Y si mi YAML tiene indentación con tabuladores?
YAML prohíbe los tabuladores para la indentación: deben ser espacios. El formateador suele convertir los tabuladores en espacios o se niega a parsear, según la configuración. Sustituye los tabuladores por espacios antes de pegar si encuentras un error de parseo.