Penukar JSON ke YAML

Tampal JSON yang sah — objek, tatasusunan, skalar, respons API, atau manifest Kubernetes penuh — dan penukar ini akan mengeluarkan persamaan YAML secara masa nyata.

Penukaran berjalan sepenuhnya di dalam penyemak imbas anda menggunakan JSON.parse terbina dalam untuk pengesahan input (mengikut ECMA-404 / RFC 8259), kemudian menelusuri pepohon terurai dan mengeluarkan sintaks YAML 1.2.2.

Pendenakan 2-jarak ialah lalai — piawaian de-facto merentasi Kubernetes, Ansible, GitHub Actions, dan Docker Compose. Tukar kepada pendenakan 4-jarak jika pangkalan kod anda memerlukannya.

Output sedia untuk ditampal ke dalam fail `.yaml` atau disalurkan ke `kubectl apply -f -`. Anak tetingkap sebelah kanan menunjukkan bilangan bait dan baris secara langsung supaya anda boleh menyemak saiz sebelum melakukan commit.

Tukar dalam tiga langkah:

• Langkah 1: Tampal JSON anda ke dalam penyunting. Penukar mengesahkan semasa anda menaip — JSON yang tidak sah menunjukkan ralat pengurai yang tepat berserta baris dan lajur.
• Langkah 2: Output YAML muncul secara langsung di anak tetingkap kanan. Tiada klik butang diperlukan; setiap ketukan kekunci dijana semula.
• Langkah 3: Klik Salin (papan klip) atau Muat Turun (fail `.yaml`).

Untuk alur kerja teratur, logik yang sama dipaparkan melalui titik akhir `/api/calculate` — POST JSON kepadanya dan terima YAML dalam badan respons.

Keselamatan pemulihan semula (round-trip): tukar YAML kembali kepada JSON dengan Penukar YAML ke JSON rakan; model data dikekalkan sepenuhnya (komen dan sauh adalah khusus YAML dan tidak akan kekal selepas pemulihan semula).

JSON dan YAML mewakili model data yang sama — peta (objek), jujukan (tatasusunan), dan skalar (rentetan/nombor/bool/null) — tetapi dengan sintaks luaran yang sangat berbeza.

JSON menggunakan banyak kurungan dakap dan tanda petik: setiap kunci mendapat `"`, setiap peta mendapat `{}`, setiap tatasusunan mendapat `[]`, dan setiap pemisah adalah jelas (`:` dan `,`). YAML didorong oleh pendenakan: sarangan diwakili oleh pendenakan 2-jarak, jujukan menggunakan awalan `- `, dan kebanyakan rentetan tidak memerlukan tanda petik.

JSON mengurai 5–10× lebih pantas merentasi semua masa jalanan bahasa utama, tidak mempunyai sebarang kekaburan, dan merupakan pilihan tepat untuk API, giliran mesej, aliran log, dan format penyimpanan.

YAML menyokong komen (`#`), sauh (anchors) dan alias untuk penggunaan semula (`&name` / `*name`), aliran pelbagai dokumen (`---`), serta tag jenis jelas (`!!str`, `!!int`) — kelebihan yang menjadikannya pilihan tepat untuk konfigurasi kawalan sumber, saluran paip CI/CD, infrastruktur-sebagai-kod (IaC), dan manifest Kubernetes.

Pilih JSON untuk mesin, YAML untuk manusia, dan tukar di antara kedua-duanya di sempadan.

Sarangan mendalam ialah kekuatan sebenar penukaran JSON-ke-YAML — menjejaki kurungan dakap dan pendenakan secara manual pada aras 5+ berisiko tinggi menyebabkan ralat.

Penukar ini menelusuri pepohon JSON yang diurai secara rekurstif:

• Bagi setiap peta (objek), kunci dikeluarkan mengikut urutan asal dengan sintaks `key: value`; nilai tersarang dipendenakkan sebanyak 2 jarak lagi.
• Bagi setiap jujukan (tatasusunan), item menggunakan awalan `- `; objek tersarang di bawah `-` bermula pada baris yang sama dengan sempang dan mewarisi aras pendenakan seterusnya.

Struktur bercampur — tatasusunan objek, objek mengandungi tatasusunan objek, secara rekurstif — semuanya dijana dengan betul. Kedalaman maksimum hanya diimbangi oleh timbunan panggilan (call stack) penyemak imbas anda (~10,000+ bingkai dalam penyemak imbas moden, jauh melebihi sebarang konfigurasi realistik).

Uji dengan data ujian anda sendiri: urai output YAML kembali kepada JSON dan pastikan kesamaan struktur dengan input asal.

Manifest Kubernetes ialah kes penggunaan paling biasa untuk penukar ini. Pelbagai alatan (kubectl, Lens, k9s, Helm) mengeluarkan JSON melalui bendera `-o json`; format kebenaran punca kanonis yang disimpan dalam Git ialah YAML.

Tampal output JSON daripada `kubectl get deployment -o json` dan penukar ini menghasilkan manifest bersih yang sedia untuk di-commit. Hierarki apiVersion, kind, metadata, dan spec mengekalkan urutan medan yang tepat.

Untuk nilai carta Helm, tampal nilai JSON anda dan masukkan YAML tersebut ke dalam `values.yaml` — templat Helm akan menggunakannya tanpa perubahan. Untuk hiasan atas (overlays) Kustomize, tukar objek tampalan anda dan tambahkan ke senarai `patchesStrategicMerge`.

Sahkan output dengan `kubectl apply --dry-run=client -f file.yaml` sebelum melakukan commit — ia mengesan isu peringkat skema yang tidak dapat dikesan oleh pengesahan sintaks YAML sahaja.

Docker Compose ialah fail YAML tulen yang mematuhi Spesifikasi Compose (compose-spec.io). Apabila anda mempunyai output JSON berprogram — daripada penjana konfigurasi, eksport Compose v2 terdahulu, atau skrip templat — tukarkannya di sini dan tampal ke dalam `docker-compose.yaml`.

Kunci peringkat atasan (`services`, `networks`, `volumes`, `configs`, `secrets`) dan spesifikasi tersarangnya (image, ports, environment, depends_on, healthcheck) semuanya ditukar dengan betul.

Perhatikan port: rentetan ringkas seperti `"8080:80"` mesti kekal dalam tanda petik dalam YAML untuk mengelakkan penafsiran sebagai nombor seksagesimal — penukar mengendalikan perkara ini secara automatik.

Sahkan dengan `docker compose config` sebelum `docker compose up`; ia menafsir, menggabungkan beberapa fail, dan memaparkan konfigurasi yang diselesaikan seperti yang akan dijalankan oleh enjin.

Peraturan indentasi YAML sangat ketat: 2 ruang setiap tahap (4 juga sah tetapi jarang digunakan), tab dilarang, dan kunci searas mesti sejajar dengan tepat. Urutan (`- item`) dan pemetaan (`key: value`) boleh bersarang secara bebas.

Rentetan pelbagai baris datang dalam dua bentuk: blok literal (`|`) mengekalkan setiap baris baharu; blok dilipat (`>`) menggabungkan baris dengan ruang (gaya perenggan).

Sauh (`&name`) dan alias (`*name`) membolehkan anda mendefinisikan nod YAML sekali dan menggunakannya semula di tempat lain — biasa dalam fail Compose untuk templat perkhidmatan berkongsi.

Tag jenis eksplisit (`!!str`, `!!int`, `!!bool`, `!!null`) mengatasi penakrifan jenis automatik YAML apabila anda memerlukan rentetan yang kelihatan seperti nombor, atau sebaliknya.

Penukar akan meletakkan tanda petik pada rentetan samar secara automatik: `"yes"`, `"no"`, `"null"`, `"~"`, nilai kelihatan seperti nombor seperti `"01234"`, dan sebarang rentetan yang mengandungi aksara khas YAML (`:`, `#`, `-`, `&`, `*`, `!`, `|`, `>`, `'`, `"`, `%`, `@`).

Enam ralat menyumbang kepada 95% kegagalan YAML yang biasa berlaku.

• (1) Aksara tab di mana-mana sahaja — walaupun satu aksara tab boleh merosakkan penafsiran. Sediakan editor anda untuk memasukkan ruang.
• (2) Indentasi tidak konsisten — kunci searas yang terhalang atau terkeluar satu lajur merupakan ralat penafsiran.
• (3) Jarak ruang terlepas selepas `:` — `key:value` tidak sah; `key: value` adalah betul.
• (4) Rentetan tanpa tanda petik yang kelihatan seperti boolean (`yes`, `no`, `on`, `off`) — dipaksa menjadi true/false dalam YAML 1.1 (penafsir lama). YAML 1.2 mengehadkan boolean kepada `true`/`false` sahaja, tetapi meletakkan tanda petik sebagai langkah berjaga-jaga adalah bijak.
• (5) Rentetan nombor tanpa tanda petik — `01234` menjadi integer 1234, menyebabkan kehilangan kosong di hadapan.
• (6) Jarak ruang terlepas selepas `-` — `-item` ialah rentetan yang bermula dengan sempang; `- item` ialah entri urutan.

Sahkan dengan `yamllint`, sambungan YAML dalam VS Code, atau pengesah khusus domain (`kubectl --dry-run`, `docker compose config`, `ansible-playbook --syntax-check`).

Aliran kerja API mendapat manfaat daripada penukaran JSON ke YAML di dua tempat.

Pertama, spesifikasi OpenAPI 3.x biasanya ditulis dalam YAML (lebih mudah dibaca untuk pokok laluan/parameter) tetapi dieksport sebagai JSON untuk alatan — tukar ke mana-mana arah mengikut keperluan aliran penyuntingan anda. Penukar mengekalkan medan yang diperlukan, definisi skema, penunjuk $ref, dan badan contoh.

Kedua, apabila mendokumenkan API, tampal contoh respons JSON dan tampilkan versi YAML dalam dokumentasi anda — lebih mudah untuk pembaca meneliti badan respons yang tersarang dalam.

Untuk integrasi Swagger UI, kedua-dua `swagger.yaml` dan `swagger.json` diterima; banyak pasukan menyimpan YAML dalam kawalan sumber dan menghasilkan JSON semasa masa binaan. Keselamatan penukaran dua hala terjamin untuk spesifikasi OpenAPI kerana ia tidak menggunakan ulasan atau sauh dalam bentuk kanonikal.

Hampir setiap platform CI/CD moden menggunakan YAML untuk definisi saluran paip:

• GitHub Actions (`.github/workflows/*.yaml`)
• GitLab CI (`.gitlab-ci.yml`)
• CircleCI (`.circleci/config.yml`)
• Travis (`.travis.yml`)
• Drone
• Concourse
• Argo Workflows
• Tekton

Apabila anda mempunyai konfigurasi JSON — daripada penjana, eksport kawalan versi terdahulu, atau pembina berprogram — tampal di sini dan hasilkan YAML.

Ansible playbooks terutamanya sangat bergantung pada struktur senarai tugas YAML dengan sauh untuk blok yang digunakan semula; penukar mengeluarkan urutan secara kemas supaya anda boleh menampal di bawah `tasks:` tanpa suntingan lanjut.

Untuk GitHub Actions, bahagian yang paling sukar ialah syarat `if:` dan strategi matriks — simpan YAML yang telah ditukar, kemudian tambah ulasan yang menjelaskan niat (ciri khusus YAML yang akan hilang jika anda kembali ke JSON).

Lima kes khas yang sering merosakkan penukar mudah.

• (1) Ulasan: JSON tidak mempunyai ulasan, manakala YAML menyokong `#`. Penukaran dua hala JSON → YAML → JSON adalah tanpa kehilangan data, tetapi YAML → JSON → YAML akan memadamkan setiap ulasan. Kekalkan YAML sebagai sumber kebenaran anda apabila ulasan adalah penting.
• (2) Paksaan boolean: penafsir YAML 1.1 lama menganggap `yes`/`no`/`on`/`off` sebagai boolean. Penafsir moden (1.2.2) hanya menganggap `true`/`false` sedemikian, tetapi meletakkan tanda petik sebagai langkah berjaga-jaga dapat mengelakkan kejutan.
• (3) Null: JSON `null` dipetakan kepada YAML `null`, `~`, atau nilai kosong. Penukar menghasilkan `null` untuk kejelasan; sesetengah alat lebih menyukai kosong (`key:`) tetapi ia boleh menimbulkan kekeliruan dengan rentetan kosong.
• (4) Rentetan nombor: `"01234"` (kod ZIP AS) kehilangan kosong di hadapan jika tidak diletakkan tanda petik dalam YAML — penukar akan meletakkan tanda petik secara automatik.
• (5) Nombor terapung dengan sifar di belakang: `1.50` ditukar secara dua hala sebagai `1.5` kerana kedua-dua JSON dan YAML menggunakan perwakilan nombor kanonikal. Jika sifar di belakang adalah penting (mata wang, rentetan versi), bersirikan ia sebagai rentetan.

Sekilas pandang pemetaan jenis:

• Objek JSON → pemetaan YAML (gaya blok)
• Larik JSON → urutan YAML (item `-`)
• Rentetan JSON → rentetan YAML (diletakkan tanda petik automatik apabila samar)
• Nombor JSON → skalar YAML dengan nilai nombor yang sama
• JSON true/false → YAML true/false
• JSON null → YAML null

Pilihan gaya:

• utamakan gaya blok (pelbagai baris, diinden) untuk kebolehbacaan berbanding gaya aliran (`{key: value, ...}` padat seperti JSON)
• sentiasa gunakan indentasi 2 ruang
• hasilkan kunci mengikut urutan sumber (sepadan dengan kelakuan JSON)

Petua penukaran dua hala:

• (1) JSON → YAML → JSON adalah tanpa kehilangan data.
• (2) YAML → JSON memadamkan ulasan, sauh (dikembangkan), tag eksplisit, dan aliran pelbagai dokumen.
• (3) Sentiasa letakkan tanda petik pada rentetan yang kelihatan seperti boolean, null, atau nombor.
• (4) Uji output anda dengan alat sebenar yang menggunakannya (kubectl, docker compose, ansible-playbook) — alat ini mempunyai pengesahan yang lebih ketat daripada penafsir YAML generik.
• (5) Simpan kedua-dua versi dalam kawalan sumber jika pasukan anda menggunakan kedua-dua format; layan satu sebagai kanonikal (biasanya YAML untuk konfigurasi, JSON untuk API) dan hasilkan semula yang satu lagi semasa binaan.