JSON ↔ YAML કન્વર્ટર — JSON અને YAML વચ્ચે ઓનલાઇન રૂપાંતર કરો _

JSON ↔ YAML રૂપાંતર એટલે શું?

JSON (JavaScript Object Notation, RFC 8259) એ સંરચિત ડેટા માટેનું એક કડક, કૌંસ-સીમાંકિત લખાણ ફોર્મેટ છે; YAML (YAML Ain't Markup Language, આવૃત્તિ 1.2) એ JSON નો સુપરસેટ છે જે એ જ મૂલ્ય મોડેલ માટે ઇન્ડેન્ટેશન, પંક્તિ-વિરામ અને માણસ માટે વાંચી શકાય તેવી વાક્યરચના વાપરે છે. આ બે વચ્ચે રૂપાંતર કરવાથી તમે એ જ રૂપરેખાંકન (configuration) ને મશીન-મૈત્રીપૂર્ણ સ્વરૂપ (API, સ્કીમા ચકાસણી અને પ્રોગ્રામેટિક રૂપાંતરો માટે JSON) અને માણસ-મૈત્રીપૂર્ણ સ્વરૂપ (કોડ સમીક્ષા, Kubernetes મેનિફેસ્ટ, GitHub Actions વર્કફ્લો માટે YAML) વચ્ચે એક પણ કી ફરી ટાઇપ કર્યા વગર બદલી શકો છો.

JSON ↔ YAML?

દરેક રૂપાંતર તમારા બ્રાઉઝરમાં સ્થાનિક રીતે જોડેલી js-yaml લાઇબ્રેરી (MIT, આવૃત્તિ 4.1.0) વાપરીને ચાલે છે. ઉચ્ચ-સ્તરનાં પગલાં આ પ્રમાણે છે:

1. મોડ પસંદગીકાર (Auto-detect / JSON → YAML / YAML → JSON) નક્કી કરે છે કે કઈ પાઇપલાઇન ચાલશે. Auto-detect મોડમાં ઇનપુટનો પ્રથમ ખાલી-જગ્યા સિવાયનો અક્ષર દિશા પસંદ કરે છે — { અથવા [ એટલે JSON; બીજું કંઈ પણ હોય તો YAML માનવામાં આવે છે.
2. JSON → YAML: JSON.parse ઇનપુટને ચકાસે છે અને એક JavaScript મૂલ્ય ઉત્પન્ન કરે છે; jsyaml.dump(value, { indent, lineWidth: -1, sortKeys: false }) YAML 1.2 સ્વરૂપ લખે છે. Multi-document ચાલુ હોય ત્યારે ઇનપુટ એરેનો દરેક ઘટક અલગ દસ્તાવેજ તરીકે આઉટપુટ થાય છે અને --- વિભાજકોથી જોડાય છે.
3. YAML → JSON: jsyaml.loadAll ઇનપુટના દરેક દસ્તાવેજને પાર્સ કરે છે (--- વિભાજકોને આપમેળે સંભાળતાં) અને એક એરે બનાવે છે; એક-દસ્તાવેજ ઇનપુટ ખોલી (unwrap) નાખવામાં આવે છે જેથી JSON આઉટપુટ માત્ર એક-ઘટક એરે ન બની રહેતાં એ દસ્તાવેજ પોતે જ બને.
4. ઇન્ડેન્ટ (2 કે 4 સ્પેસ) અને Pretty-print બંને રૂપરેખાંકિત કરી શકાય છે. Pretty-print બંધ હોય ત્યારે JSON.stringify(value) કોઈ પણ ખાલી જગ્યા વગર મિનિફાઇડ JSON ઉત્સર્જિત કરે છે.
5. આઉટપુટ ફક્ત-વાંચન માટેના ટેક્સ્ટએરિયામાં લખાય છે. YAML પાર્સ નિષ્ફળતા પર ભૂલ સંદેશમાં js-yaml ના e.mark દ્વારા જણાવેલ 1-આધારિત પંક્તિ અને સ્તંભ ક્રમાંક શામેલ હોય છે, જેથી તમે સીધા બગ પર પહોંચી શકો.

JSON YAML?

• ગોપનીયતા: દરેક પાર્સ, રૂપાંતર અને આઉટપુટ પાસ તમારા બ્રાઉઝરમાં થાય છે. ડેટા — Kubernetes સીક્રેટ્સ, હસ્તાક્ષરિત JWT અને માલિકીના કોન્ફિગ સહિત — ક્યારેય અમારા સર્વર સુધી પહોંચતો નથી.
• બહુ-દસ્તાવેજ YAML: jsyaml.loadAll --- વિભાજકોને ઓળખે છે અને દસ્તાવેજોનો એક એરે પાછો આપે છે, જેને કન્વર્ટર એક-દસ્તાવેજના કિસ્સામાં ખોલી નાખે છે અને બહુ-દસ્તાવેજના કિસ્સામાં JSON એરે તરીકે જાળવી રાખે છે.
• એન્કર અને ઉપનામ ઉકેલાય છે: YAML ની &anchor / *alias વ્યવસ્થા js-yaml ની ડિફોલ્ટ સ્કીમા સંભાળે છે. એક વાર વ્યાખ્યાયિત અને બે વાર સંદર્ભિત મૂલ્ય એવા JSON ઑબ્જેક્ટમાં રાઉન્ડ-ટ્રિપ થાય છે જ્યાં બધા સંદર્ભોનાં મૂલ્ય સમાન રહે છે.
• કોઈ CDN નહીં, કોઈ ટેલિમેટ્રી નહીં: js-yaml.min.js લાઇબ્રેરી પૃષ્ઠ જેવા જ મૂળ (origin) પરથી મોકલાય છે, એટલે આ સાધન ઑફલાઇન, કોર્પોરેટ પ્રોક્સીની પાછળ અને એર-ગૅપ્ડ વાતાવરણમાં પણ કામ કરે છે.

JSON ↔ YAML રૂપાંતરના સામાન્ય ઉપયોગો કયા છે?

JSON અને YAML વચ્ચે ફેરબદલ DevOps, પ્લેટફોર્મ એન્જિનિયરિંગ અને API ટૂલિંગમાં બધે જ દેખાય છે:

• Kubernetes મેનિફેસ્ટ: YAML ના Deployment, ConfigMap કે HelmRelease ને JSON માં બદલવું જેથી ઘરનું પોલિસી ચકાસનાર (Joi, Ajv, OPA Rego) તેને પ્રોગ્રામેટિક રીતે lint કરી શકે, પછી ક્લસ્ટર પર લાગુ કરવા માટે પાછું YAML માં બદલવું.
• CI/CD વર્કફ્લો: GitHub Actions ની workflow.yml ને JSON દ્વારા રાઉન્ડ-ટ્રિપ કરવી જેથી કોડ-જનરેટર મેટ્રિક્સ કે જોબ નિર્ભરતાઓને ફરી લખી શકે, પછી PR માટે સાફ-સુથરી YAML ઉત્સર્જિત કરવી.
• OpenAPI સ્પેક્સ: કોઈ બેકએન્ડના આપમેળે ઉત્પન્ન થયેલા દસ્તાવેજોમાંથી JSON openapi.json પેસ્ટ કરવી અને રિપોઝિટરીમાં ચેક-ઇન કરાતા માણસ-સંપાદિત સંદર્ભ માટે openapi.yaml માં બદલવી.

JSON ↔ YAML રાઉન્ડ-ટ્રિપનું ઉદાહરણ કેવું દેખાય છે?

{"apiVersion":"apps/v1","kind":"Deployment","metadata":{"name":"web"},"spec":{"replicas":3,"selector":{"matchLabels":{"app":"web"}}}} પેસ્ટ કરીને JSON → YAML મોડમાં CONVERT દબાવવાથી આઠ પંક્તિઓની ઇન્ડેન્ટ કરેલી YAML બને છે જેની પ્રથમ પંક્તિ પર apiVersion: apps/v1 હોય છે. એ જ YAML ને YAML → JSON મોડમાં Pretty-print ચાલુ રાખીને પાછી નાખવાથી સ્થિર JSON.stringify(value, null, 2) પછી મૂળ ઑબ્જેક્ટ બાઇટ-દર-બાઇટ પાછો આવે છે, અને કી ક્રમ પણ જળવાય છે કેમ કે js-yaml ની ડિફોલ્ટ સ્કીમા બંને દિશામાં દાખલ ક્રમ (insertion order) નું માન રાખે છે.

Browser?

હા. દરેક પાર્સ, રૂપાંતર અને આઉટપુટ પાસ તમારા બ્રાઉઝર ટૅબની અંદર JavaScript તરીકે સ્થાનિક રીતે ચાલે છે. જોડેલી js-yaml લાઇબ્રેરી પૃષ્ઠ જેવા જ મૂળ પરથી મોકલાય છે — કોઈ CDN નહીં, કોઈ fetch નહીં, કોઈ XMLHttpRequest નહીં, ઇનપુટ પર કોઈ navigator.sendBeacon નહીં. પૃષ્ઠ એક વાર લોડ થઈ ગયા પછી આ સાધન ઑફલાઇન પણ કામ કરે છે, કેમ કે તે વેન્ડર લાઇબ્રેરી સાથે કોપી કરેલ સ્થિર HTML/CSS/JS બંડલ છે. Kubernetes સીક્રેટ્સ, JWT પેલોડ, હસ્તાક્ષરિત CloudFormation YAML અને માલિકીના કોન્ફિગ બધું તમારા ઉપકરણ પર જ રહે છે.

કન્વર્ટર બહુ-દસ્તાવેજ YAML ને કેવી રીતે સંભાળે છે?

YAML એક જ સ્ટ્રીમમાં ફક્ત --- ધરાવતી પંક્તિઓથી અલગ કરેલા અનેક દસ્તાવેજોને આધાર આપે છે. YAML → JSON પર કન્વર્ટર jsyaml.loadAll ને બોલાવે છે, જે દરેક દસ્તાવેજને JavaScript મૂલ્ય તરીકે પાછો આપે છે. જો બરાબર એક જ દસ્તાવેજ મળે તો JSON આઉટપુટ સીધો એ જ દસ્તાવેજ હોય છે; જો બે કે વધુ મળે તો JSON આઉટપુટ એક એરે હોય છે. JSON → YAML પર, જ્યારે ઇનપુટ JSON એરે હોય અને Multi-document ટૉગલ ચાલુ હોય, ત્યારે દરેક એરે ઘટક પોતાના અલગ દસ્તાવેજ તરીકે ઉત્સર્જિત થાય છે અને તેમની વચ્ચે --- વિભાજકો મૂકાય છે — સંસાધનોના JSON એરેમાંથી kubectl apply-મૈત્રીપૂર્ણ બંડલ બનાવવા માટે ઉપયોગી.

શું YAML એન્કર અને ઉપનામ સમર્થિત છે?

હા — &anchor વ્યાખ્યાઓ અને *alias સંદર્ભો લોડ પગલા દરમિયાન js-yaml ની ડિફોલ્ટ સ્કીમા દ્વારા ઉકેલાય છે. defaults: &d\n retries: 3\n timeout: 30\njob_a:\n <<: *d\njob_b:\n <<: *d જેવું YAML ઇનપુટ એવા JSON ઑબ્જેક્ટમાં પાર્સ થાય છે જ્યાં job_a અને job_b બંનેમાં retries: 3, timeout: 30 હોય છે. મર્જ કી << (YAML 1.1 નું એક વિસ્તરણ જેને js-yaml હજુ પણ માન આપે છે) પણ ડિફોલ્ટ સ્કીમા પર સમર્થિત છે.

JSON માં જતાં અને પાછા આવતાં શું YAML ટિપ્પણીઓ જળવાઈ રહે છે?

ના — js-yaml પાર્સ પગલા દરમિયાન ટિપ્પણીઓ કાઢી નાખે છે, એટલે YAML → JSON → YAML રાઉન્ડ-ટ્રિપમાં # થી શરૂ થતી દરેક પંક્તિ ખોવાઈ જાય છે. આ load/dump મોડેલની એક જાણીતી મર્યાદા છે; જો ટિપ્પણીઓ સાચવવી જરૂરી હોય, તો js-yaml ને બદલે ટિપ્પણી-જાગૃત લાઇબ્રેરી વાપરો જેમ કે yaml npm પૅકેજ (જે trivia સાચવવા માટે ડિઝાઇન કરેલ CST + AST API સાથે આવે છે). મોટાભાગના કોન્ફિગ-રૂપાંતર વર્કફ્લો માટે આ સમાધાન સ્વીકાર્ય છે: રાઉન્ડ-ટ્રિપ થયેલી YAML દરેક કી, મૂલ્ય, એન્કર અને ઉપનામ સાચવી રાખે છે, ફક્ત માણસ-લખિત ટિપ્પણીઓ વગર.

કસ્ટમ YAML ટૅગ્સનું શું થાય છે?

કન્વર્ટર js-yaml ની DEFAULT_SCHEMA વાપરે છે, જે !!str, !!int, !!float, !!bool, !!null, !!seq, !!map, !!binary અને !!timestamp ને સમજે છે — એટલે YAML 1.2 core અને JSON સ્કીમાના દરેક ટૅગ. કસ્ટમ કે એપ્લિકેશન-વિશિષ્ટ ટૅગ (દા.ત. CloudFormation માં !Ref, Ansible માં !vault) ઓળખાતા નથી અને અસમર્થિત ટૅગનો સ્પષ્ટ ઉલ્લેખ કરતી ભૂલ તરીકે સામે આવે છે. ખાસ કરીને CloudFormation માટે, આ કન્વર્ટરમાં પેસ્ટ કરતા પહેલા કસ્ટમ ટૅગને વિસ્તારવા માટે aws cloudformation package + --output-template-file પ્રવાહ વાપરો.

આ JSON ↔ YAML કન્વર્ટર js-yaml@4.1.0 ને એ જ મૂળ પર જોડેલ સાથે આવે છે, બહુ-દસ્તાવેજ સ્ટ્રીમ અને એન્કર/ઉપનામને સીધેસીધો આધાર આપે છે, અને YAML પાર્સ ભૂલોને પંક્તિ અને સ્તંભ સાથે રિપોર્ટ કરે છે જેથી તમે સ્રોત ઠીક કરી શકો. કોઈ અપલોડ નહીં, કોઈ CDN નહીં, કોઈ ટેલિમેટ્રી નહીં — દરેક બાઇટ તમારા બ્રાઉઝરમાં જ રહે છે.