Ferramenta de Formatação YAML
O que é YAML?
O formatador YAML torna arquivos YAML mais fáceis de ler aplicando indentação consistente, quebras de linha e estrutura visível. YAML é muito usado em configuração de CI, manifests Kubernetes, Docker Compose, geradores de sites estáticos, localização, arquivos OpenAPI e configurações de aplicação. Diferente de JSON, YAML depende bastante de indentação, marcadores de lista, dois-pontos, aspas, anchors e strings multilinha; um pequeno erro pode criar uma estrutura diferente da pretendida. A ferramenta ajuda a ler, limpar e encontrar problemas óbvios de sintaxe, mas não substitui validação de schema nem checks específicos da ferramenta. Em Kubernetes, GitHub Actions, Ansible ou produção, teste no sistema alvo.
Como Usar
Como usar
- Cole ou digite os dados YAML na caixa de entrada à esquerda
- Selecione o tamanho de indentação que combine com o estilo do seu projeto
- Clique em 'Formatar' para formatar, 'Minificar' para reduzir o tamanho ou 'Validar' para verificar a sintaxe
- Veja os resultados à direita
- Clique em 'Copiar' para copiar para a área de transferência
Descrição das opções
Atalhos de teclado
- Ctrl + EnterFormatar
- Ctrl + Shift + CCopiar resultado
Dicas de YAML
- O YAML é sensível à indentação, portanto revise listas e maps aninhados após a formatação antes de usar o resultado em CI, Kubernetes ou arquivos de implantação.
- Valide em relação ao schema da ferramenta de destino quando possível; um YAML sintaticamente válido ainda pode ser inválido para GitHub Actions, Docker Compose ou OpenAPI.
Casos de uso
Princípio técnico
A formatação YAML é ancorada na especificação YAML 1.2.2 (revisada em outubro de 2021), que define formalmente JSON como um subconjunto estrito de YAML — qualquer documento JSON válido é analisável como YAML. A análise ocorre em três camadas: uma camada de apresentação varre pontos de código Unicode e resolve escapes de caracteres; uma camada de serialização constrói um grafo de nós de escalares, sequências e mapeamentos; uma camada nativa aplica o YAML Core Schema para converter escalares nos tipos resolvidos `!!str`, `!!int`, `!!float`, `!!bool`, `!!null`, `!!seq`, `!!map`. Bibliotecas de runtime comuns incluem js-yaml e o pacote mais recente `yaml` no Node, PyYAML e ruamel.yaml no Python, e SnakeYAML na JVM. Formatadores do lado do navegador normalmente analisam em um objeto JS simples via `load`/`dump` do js-yaml e fazem a conversão de volta. A indentação é a primitiva fundamental: apenas espaço ASCII (U+0020) é permitido — a especificação proíbe explicitamente caracteres de tabulação (U+0009) para indentação na seção §6.1, que é a causa mais comum de falha de análise ao colar de um editor de código que faz conversão automática. O estilo de bloco determina o aninhamento puramente pela posição da coluna, então nós filhos devem ser indentados mais que o pai por pelo menos um espaço (dois por convenção). O estilo de fluxo empresta a sintaxe de JSON — `[1, 2, 3]` e `{a: 1, b: 2}` — e pode ser aninhado dentro do estilo de bloco para linhas únicas. Escalares de bloco usam dobramento baseado em indicadores: `|` (literal) preserva quebras de linha exatamente, `>` (dobrado) colapsa quebras de linha únicas em espaços e mantém linhas em branco como separadores de parágrafo, e os indicadores de corte `-` (remover quebras de linha finais) e `+` (manter todas as quebras de linha finais) são anexados após o indicador (`|-`, `>+`). As regris de aspas diferem: escalares entre aspas simples tratam `\` literalmente e usam `''` para incorporar uma aspa; escalares entre aspas duplas honram escapes no estilo C (`\n`, `\t`, `\uXXXX`). Formatadores normalmente padronizam para um estilo de bloco e reemitem âncoras e aliases. Uma âncora `&name` marca um nó; um alias `*name` faz referência a ele; a chave de mesclagem `<<: *name` (um legado do YAML 1.1 ainda suportado pela maioria dos parsers) puxa chaves de outro mapeamento para o atual. Streams de múltiplos documentos são divididos por marcadores de início `---` e marcadores de fim opcionais `...`, o padrão usado pelo Kubernetes para enviar múltiplos recursos em um único manifesto. Dois problemas conhecidos merecem reemissão segura: o problema da Noruega — o escalar sem aspas `no` é interpretado como `false` sob o schema YAML 1.1 (e o código do país se torna um booleano) — e o CVE-2017-18342, onde o `yaml.load` do PyYAML desserializava objetos Python arbitrários, corrigido mudando para `safe_load`. Ambos são razões pelas quais um formatador deve tratar a resolução de escalares com cuidado e nunca executar construtores com tags. A análise é O(n) sobre o comprimento da entrada; comentários são descartados pela maioria das bibliotecas baseadas em AST porque não fazem parte do modelo de informação do YAML.
- Especificação: YAML 1.2.2 (outubro de 2021). JSON é um subconjunto estrito do YAML 1.2, então qualquer documento JSON válido é analisado como YAML; bibliotecas comuns são js-yaml, o pacote `yaml`, PyYAML, ruamel.yaml, SnakeYAML.
- A indentação deve ser espaço ASCII (U+0020); caracteres de tabulação (U+0009) são proibidos para indentação pela seção §6.1 — a causa mais comum de erros `mapping values are not allowed here`.
- Estilo de bloco vs. fluxo: bloco usa aninhamento por posição de coluna (2 ou 4 espaços por convenção); fluxo usa `[1, 2, 3]` e `{a: 1}` no estilo JSON. Ambos podem ser aninhados.
- Escalares de bloco: `|` literal preserva quebras de linha, `>` dobrado colapsa quebras de linha únicas em espaços; indicadores de corte `-` (remover) e `+` (manter) são anexados ao indicador, ex. `|-`, `>+`.
- Âncoras `&name` marcam nós, aliases `*name` fazem referência a eles, e a chave de mesclagem `<<: *name` puxa chaves de outro mapeamento (legado YAML 1.1, suportado pela maioria dos parsers).
- Streams de múltiplos documentos são divididos por `---` (início) e `...` (fim) opcionais — o padrão que o Kubernetes usa para enviar múltiplos recursos em um único manifesto.
- Problemas conhecidos: o problema da Noruega (`no`/`yes`/`on`/`off` sem aspas analisados como booleanos sob o schema YAML 1.1; o YAML 1.2 Core Schema corrige a maioria) e CVE-2017-18342 (`yaml.load` do PyYAML com execução arbitrária de código; use `safe_load`).
Exemplos
Corrigir indentação inconsistente em um arquivo de configuração
Entrada (quebrada):
server:
port: 8080
host: localhost
debug: true
Formatado (2 espaços):
server:
port: 8080
host: localhost
debug: trueLista aninhada de serviços em 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: productionManifesto de Deployment do 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.25Converter YAML para JSON para um pipeline jq
Entrada YAML:
user:
id: 42
name: alice
roles:
- admin
- editor
Saída JSON:
{
"user": {
"id": 42,
"name": "alice",
"roles": ["admin", "editor"]
}
}Detectar a falta de espaço após dois-pontos
Entrada:
name:alice
age: 30
Erro na linha 1: falta espaço após dois-pontos
Corrigido:
name: alice
age: 30Perguntas frequentes
O que a formatação YAML inclui?
Normalização da indentação (geralmente 2 espaços), estilo consistente de aspas, alinhamento dos marcadores de lista e reformatação de coleções inline longas para o estilo em bloco. A maior parte do YAML por aí é editado à mão e acumula estilos inconsistentes; o formatador uniformiza tudo.
Ele converte estilo flow para estilo block?
Muitas versões deixam você escolher entre estilo flow (parecido com JSON: {key: value, key2: value2}) e estilo block (multilinha indentado). O block é mais legível para edição humana; o flow é mais compacto. Converter de um para o outro preserva os dados, mas muda a aparência.
Por que ele muda minhas aspas?
O YAML permite strings sem aspas, com aspas simples e com aspas duplas, com diferenças sutis. Yes/no, true/false, on/off são interpretados como booleanos a menos que estejam entre aspas; números sem aspas são números, com aspas viram strings. O formatador pode adicionar aspas para desambiguar valores que seriam interpretados de outra forma.
Ele preserva os comentários?
A maioria das versões preserva os comentários YAML (#), mas a posição em relação aos nós da AST pode mudar um pouco. Comentários acima de chaves geralmente continuam acima; comentários no final da mesma linha ficam grudados nela. Recarregue após formatar e confira se a posição dos comentários ainda faz sentido.
O YAML é enviado para o servidor?
Não. A análise e a formatação rodam no seu navegador via js-yaml ou similar. O YAML colado não é transmitido.
Por que o ida e volta do meu YAML muda os anchors e aliases?
A sintaxe & (anchor) e * (alias) do YAML permite referenciar um valor uma vez e reutilizá-lo. Alguns formatadores expandem aliases inline por padrão, perdendo a deduplicação. Procure por uma opção para preservar os anchors se sua ferramenta depender deles.
E se meu YAML estiver indentado com tabs?
O YAML proíbe tabs na indentação — devem ser espaços. O formatador normalmente converte tabs em espaços ou se recusa a interpretar, dependendo da configuração. Substitua tabs por espaços antes de colar se aparecer um erro de parse.