Převodník YAML do JSON

Vložte platný YAML — manifest Kubernetes, soubor Compose, playbook Ansible, specifikaci OpenAPI nebo jakýkoli dokument YAML 1.2 — a převodník v reálném čase vygeneruje ekvivalent v JSON.

Převod běží kompletně ve vašem prohlížeči pomocí parseru YAML 1.2, poté prochází analyzovaný strom a generuje JSON pomocí JSON.stringify (podle ECMA-404 / RFC 8259).

Vyberte si styl výstupu:

• 2 mezery (výchozí, čitelné pro člověka)
• 4 mezery (některé firemní kódové báze)
• minifikovaný (API, síťové datové přenosy)

Výstup je připraven k vložení do souboru `.json` nebo k předání do `kubectl apply -f -` (který přijímá JSON přes stdin). Pravý panel zobrazuje živý počet bajtů a řádků, takže si můžete zkontrolovat velikost před uložením.

Převod z YAML do JSON zahrnuje tři kroky:

• Krok 1: Vložte svůj YAML do editoru. Parser provádí validaci při psaní — neplatný YAML zobrazí přesnou chybu analýzy s řádkem a sloupcem.
• Krok 2: Výstup JSON se objeví živě v pravém panelu. Není potřeba klikat na tlačítko; každý stisk klávesy provede novou analýzu.
• Krok 3: Klikněte na Kopírovat (schránka) nebo Stáhnout (soubor `.json`).

Pro programové pracovní postupy je stejná logika vystavena přes koncový bod `/api/calculate` — pošlete YAML pomocí POST a získejte JSON v těle odpovědi.

Bezpečnost obousměrného převodu: převeďte JSON zpět na YAML pomocí sesterského převodníku JSON na YAML; datový model je přesně zachován (komentáře a kotvy jsou pouze součástí YAML a obousměrný převod nepřežijí).

YAML a JSON reprezentují stejný datový model — mapy (objekty), sekvence (pole) a skaláry (řetězec/číslo/bool/null) — ale s velmi odlišnou povrchovou syntaxí.

YAML je řízen odsazením: vnoření je implikováno 2 mezerami, sekvence používají prefix `- ` a většina řetězců nepotřebuje uvozovky. JSON je náročný na složené závorky a uvozovky: každý klíč dostane `"`, každá mapa `{}` a každé pole `[]`, přičemž každý oddělovač je explicitní (`:` a `,`).

YAML podporuje komentáře (`#`), kotvy a aliasy pro opakované použití (`&name` / `*name`), proudy více dokumentů (`---`) a explicitní typové značky (`!!str`, `!!int`) — silné stránky, které z něj dělají správnou volbu pro konfigurace pod správou verzí. JSON se analyzuje 5–10× rychleji, nemá žádnou nejednoznačnost a je správnou volbou pro API a úložiště.

Převádějte na rozhraní: YAML pro lidi, JSON pro stroje.

Hluboké vnoření je oblast, kde převod z YAML do JSON exceluje — ruční sledování odsazení na 5 a více úrovních je náchylné k chybám. Převodník prochází analyzovaný strom YAML rekurzivně.

• Pro každou blokovou mapu jsou klíče generovány v pořadí zdroje se syntaxí JSON `"klíč": hodnota`; vnořené hodnoty dostanou složené závorky `{...}`.
• Pro každou blokovou sekvenci jsou položky generovány jako pole JSON `[...]`; vnořené objekty pod `-` se stanou prvky pole `{...}`.

Smíšené struktury — sekvence map, mapy obsahující sekvence map, rekurzivně — se všechny převedou správně. Maximální hloubka je omezena pouze zásobníkem volání vašeho prohlížeče (cca 10 000+ rámců v moderních prohlížečích, což je daleko za hranicí jakékoli realistické konfigurace).

Otestujte se svými vlastními daty: analyzujte výstup JSON zpět do YAML a ověřte strukturální shodu se vstupem.

Volné odvozování typů v YAML je zdrojem mnoha chyb v reálných konfiguracích. YAML 1.2 (moderní standard, cíl tohoto převodníku) pravidla zúžil, aby byla bezpečnější.

• Booleany: POUZE `true` a `false` (nerozlišuje se velikost písmen). YAML 1.1 také považoval `yes`/`no`/`on`/`off` za booleany, což slavně rozbilo konfigurace obsahující kód země Norska `NO` (tiše převedeno na `false`) — tzv. „problém Norska“. Většina moderních parserů (js-yaml, PyYAML 6+, Snakeyaml) standardně používá chování 1.2.
• Null: `null`, `~` nebo prázdná hodnota se všechny stanou JSON null.
• Čísla: vzory číslic odpovídající syntaxi celých čísel/desetinných čísel v JSON se stanou čísly JSON; vše ostatní zůstane řetězcem.
• Řetězce: hodnoty v uvozovkách vždy zůstávají řetězci; číselné řetězce jako PSČ (`"01234"`) a kalendářní data potřebují v YAML uvozovky, aby přežily převod — když konfigurace obsahuje datum, které jste si nejprve vypočítali pomocí kalkulačky věku, dejte ho do uvozovek, aby ho parser zachoval doslovně místo jeho vynucené konverze.

Převodník tato pravidla přísně dodržuje.

Kubernetes přijímá formáty YAML i JSON prostřednictvím svého API serveru, nástroje kubectl a klientských knihoven. Většina týmů uchovává YAML ve verzovacím systému (PR se lépe revidují), ale pro programové nástroje – vlastní řadiče, GitOps pipelines, Helm post-renderery nebo webhooky – využívá JSON.

Vložte svůj manifest (Pod, Deployment, Service, ConfigMap atd.) a zkopírujte výstup ve formátu JSON. Převodník zachovává hierarchii apiVersion, kind, metadata a spec v původním pořadí polí – Kubernetes očekává všude klíče v camelCase, takže pokud přenášíte pole ze zdroje ve formátu snake_case, převodník velikosti písmen názvy před vložením opraví.

Před odesláním (commit) proveďte validaci pomocí `kubectl apply --dry-run=client -f -` (který přijímá JSON na standardním vstupu). U manifestů s více zdroji oddělenými pomocí `---` je nejprve rozdělte na jednotlivé dokumenty – JSON nemá syntaxi pro více dokumentů v jednom souboru.

Tři časté případy použití mimo Kubernetes:

• Docker Compose: vložte `docker-compose.yaml` a zkopírujte JSON pro nástroje jako Kompose (migruje Compose do K8s), vlastní orchestrátory nebo programové transformace konfigurací.
• Ansible: převeďte playbooky do JSON pro dokumentační nástroje, vlastní CI integrace nebo REST/GraphQL API, která ukládají definice playbooků.
• CI/CD pipelines: GitHub Actions (`.github/workflows/*.yml`), GitLab CI (`.gitlab-ci.yml`), CircleCI, Travis – převeďte jakýkoli z těchto souborů do JSON pro analytiku, programové úpravy nebo archivaci auditních logů. Jejich naplánované `cron` triggery jsou vázány na UTC, takže převodník časových pásem vám pomůže předejít chybám při čtení času spuštění pipeline ve vašem místním čase.

Poznámka: Výrazy Jinja2 (`{{ var }}`), syntaxe šablon Helm (`{{ .Values.x }}`) a podobné šablony zůstávají v JSON jako prosté řetězce – převodník je nevyhodnocuje.

Specifikace OpenAPI 3.x se běžně píší v YAML (je čitelnější pro stromy cest a parametrů), ale starší nástroje je vyžadují ve formátu JSON – jde o starší verze Swagger UI, některé podnikové API brány a některé generátory kódu.

Vložte svůj `openapi.yaml` (nebo `swagger.yaml`) a stáhněte `openapi.json`. Převodník přesně zachovává ukazatele `$ref` (neřeší je), definice schémat, příklady odpovědí a bezpečnostní schémata.

Po převodu proveďte validaci pomocí oficiálního validátoru OpenAPI (Spectral CLI, openapi-cli, swagger-cli) pro potvrzení shody se schématem. Mnoho týmů udržuje YAML ve verzovacím systému a JSON generuje až při sestavení – pro uživatele API jsou `swagger.yaml` i `swagger.json` plně ekvivalentní.

Šest chyb tvoří 95 % selhání při parsování YAML:

• Tabulátory kdekoli v odsazení – YAML tabulátory zcela zakazuje, i jediný znak tabulátoru rozbije parsování.
• Nekonzistentní odsazení – sourozenecké klíče musí být zarovnány přesně ve stejném sloupci.
• Chybějící mezera za `:` v mapách – `klíč:hodnota` je neplatné; `klíč: hodnota` je správně.
• Chybějící mezera za `-` v sekvencích – `-položka` je řetězec začínající pomlčkou; `- položka` je prvek sekvence.
• Neuzavřené speciální znaky na začátku hodnoty – `@`, `` ` ``, `%`, `*`, `&` vyžadují uvozovky.
• Nepodporované funkce v převodníku: kotvy (`&name`), aliasy (`*name`) a vícestránkové proudy (`---`) – pro tyto případy použijte plnohodnotnou knihovnu YAML jako js-yaml, PyYAML nebo `yq`.

Chybová zpráva zobrazuje řádek a sloupec, kde parsování selhalo.

Tři funkce YAML nemají přímý ekvivalent v JSON a vyžadují zvláštní zacházení:

• Kotvy (`&name`) a aliasy (`*name`) umožňují YAML odkazovat na uzel a znovu jej použít jinde – běžné v souborech Compose pro sdílené šablony služeb a v CloudFormation pro sdílené parametry. JSON nemá syntaxi pro odkazy, takže převodník aliasy rozbalí (každý alias se stane plnou kopií). Data jsou zachována, ale JSON je větší a struktura sdílených odkazů se ztrácí.
• Vícestránkové proudy (oddělovač `---`) představují více hodnot na nejvyšší úrovni v jednom souboru – běžné pro sdružování prostředků Kubernetes. JSON má v dokumentu pouze jednu kořenovou hodnotu. Nejprve rozdělte YAML do samostatných souborů nebo dokumenty obalte do pole JSON `[doc1, doc2, doc3]`.
• Komentáře (`#`) jsou pouze v YAML – během převodu jsou zcela odstraněny. Pokud jsou komentáře důležité, ponechte si YAML jako zdroj pravdy.

Pět úvah o obousměrném převodu, které by měl znát každý vývojář:

• Datový model: YAML → JSON → YAML přesně zachovává klíče, hodnoty, typy a vnoření. Data jsou při vstupu i výstupu identická.
• Komentáře: jsou navždy ztraceny – JSON nemá syntaxi pro komentáře. Pokud máte vloženou dokumentaci, ponechte si YAML jako zdroj pravdy.
• Kotvy/aliasy: při cestě do JSON se rozbalí a při cestě zpět se již nikdy neobnoví. Výstupní YAML obsahuje duplicitní obsah tam, kde zdroj obsahoval sdílené odkazy.
• Pořadí klíčů: YAML zachovává pořadí ze zdroje; převodník jej zachovává v JSON; při zpětném převodu do YAML zůstává stejné pořadí.
• Typové značky (`!!str`, `!!int`) – jsou vygenerovány pouze tehdy, je-li to nutné pro odstranění nejednoznačnosti. Řetězec `"01234"` přežije obousměrný převod, protože JSON jej udržuje v uvozovkách; neuzavřený YAML `01234` se parsuje jako celé číslo a při zpětném převodu se změní na číslo 1234, čímž se ztratí úvodní nula.

Nejednoznačné hodnoty raději uzavírejte do uvozovek.

Přehled mapování typů:

• Mapa YAML → Objekt JSON
• Sekvence YAML → Pole JSON
• Skalár YAML (podle odvození typu) → Řetězec/číslo/boolean/null v JSON
• Značka YAML !!str → Řetězec JSON (vynuceno)
• YAML null/~/prázdné → JSON null
• YAML true/false → JSON boolean
• Vzor celého čísla YAML → Celé číslo JSON
• Vzor desetinného čísla YAML → Číslo JSON

Srovnání nástrojů:

• tento převodník (prohlížeč, okamžitý, bez instalace, 95 % reálného YAML)
• `yq -o json` (CLI, velké soubory, dotazy JSONPath)
• `js-yaml`/`PyYAML` (plná knihovna, podpora kotev a vícestránkových souborů, programové použití)

Osvědčené postupy:

• Vždy uzavírejte nejednoznačné hodnoty (yes/no/on/off/null/číselná ID) ve zdroji YAML do uvozovek.
• Používejte 2mezerní odsazení (de-facto standard).
• Validujte výstup JSON proti schématu vašeho následného systému (JSON Schema, OpenAPI, K8s OpenAPI) – zde se projeví typové chyby.
• Pokud je to možné, udržujte YAML jako kanonický zdroj a JSON generujte při sestavení.