JSON શું છે? સાદી ભાષામાં ઉદાહરણો સાથે માર્ગદર્શિકા

JSON (JavaScript Object Notation) એ માળખાગત ડેટા લખવાનું સાદું લખાણ ફોર્મેટ છે — જેમ કે ગ્રાહક, ઓર્ડર અથવા પ્રોડક્ટ્સની યાદી — નામોને મૂલ્યો સાથે જોડીને. માણસો માટે તે વાંચવું સરળ છે, અને પ્રોગ્રામો માટે તેને બનાવવું અને પાર્સ કરવું સરળ છે. જ્યારે એપ્સ અને સેવાઓ વેબ પર ડેટાની આપલે કરે છે, ત્યારે JSON સૌથી સામાન્ય ફોર્મેટ છે.

AI સાથે બિલ્ડ કરતી વખતે JSON શા માટે મહત્વનું છે

તમે કોડ લખ્યા વિના પણ JSON સતત જોશો:

• APIs. જ્યારે તમારી એપની સ્ક્રીન તેના backend માંથી ડેટા લોડ કરે, અથવા તમારું backend પેમેન્ટ, ઇમેઇલ કે AI સેવાને કૉલ કરે, ત્યારે ડેટા સામાન્ય રીતે JSON તરીકે મુસાફરી કરે છે. જુઓ API શું છે.
• Settings ફાઇલો. ઘણી પ્રોજેક્ટ configuration ફાઇલો JSON છે — ઉદાહરણ તરીકે package.json, જે JavaScript પ્રોજેક્ટની dependencies યાદી કરે છે.
• Databases. Postgres એક column માં JSON સાચવી શકે છે (jsonb પ્રકાર), એવા ડેટા માટે જે સરસ rows અને columns માં બંધબેસતો નથી. જુઓ Postgres શું છે.
• AI આઉટપુટ. જ્યારે તમે AI model પાસેથી એવું કંઈક ઇચ્છો જે પ્રોગ્રામ વાપરી શકે — tags ની યાદી, ઇન્વોઇસના ફીલ્ડ્સ — ત્યારે સામાન્ય રીતે તમે JSON માંગો છો.
• Error સંદેશા અને logs. ઘણી ભૂલો JSON માં આવે છે, અને તેને વાંચવું ઘણી વાર એ જાણવાનો સૌથી ઝડપી રસ્તો છે કે શું ખોટું થયું.

JSON વાંચી શકવાથી તમે તપાસી શકો છો કે તમારી એપને ખરેખર શું મળ્યું, ગુમ થયેલ ફીલ્ડ શોધી શકો છો, અને તમારા AI બિલ્ડરને સમસ્યા ચોક્કસ રીતે સમજાવી શકો છો.

રોજિંદું ઉદાહરણ

કાગળનું ફોર્મ વિચારો: નામ: ____, ફોન: ____, ન્યૂઝલેટર: ☐ હા ☐ ના. દરેક પ્રવેશ એક લેબલ છે, જેની બાજુમાં મૂલ્ય છે. JSON એ ફોર્મ લખાણ તરીકે છે, એક કડક લેઆઉટમાં જે કમ્પ્યુટર અનુમાન લગાવ્યા વિના વાંચી શકે. અને ફોર્મની જેમ, JSON માં વિભાગોની અંદર વિભાગો (સરનામાંનો બ્લોક, જેમાં શેરી, શહેર અને પિનકોડ) અને યાદીઓ (ઘણા ફોન નંબર) હોઈ શકે.

JSON કેવું દેખાય છે

અહીં એક બુકિંગ JSON માં છે:

{
  "id": 5001,
  "customer": "Lena Park",
  "service": "Haircut",
  "startsAt": "2026-10-03T14:00:00Z",
  "price": 35.5,
  "paid": false,
  "notes": null,
  "extras": ["beard trim", "hot towel"],
  "contact": {
    "email": "lena@example.com",
    "phone": "+44 20 7946 0000"
  }
}

તેને વાંચવાની રીત:

• વાંકડિયા કૌંસ { } object ને લપેટે છે — નામ/મૂલ્ય જોડીઓનો સમૂહ.
• દરેક જોડી "name": value છે, જે commas થી અલગ પડે છે.
• ચોરસ કૌંસ [ ] array ને લપેટે છે — ક્રમબદ્ધ યાદી.
• Objects અને arrays એકબીજાની અંદર મૂકી શકાય છે, જેમ contact અને extras કરે છે.

છ પ્રકારના મૂલ્યો

JSON માં માત્ર છ પ્રકારના મૂલ્યો છે. એ નાની યાદી જ એનો મોટો ભાગ છે કે તે બધે કામ કરે છે.

તારીખનો કોઈ અલગ પ્રકાર નથી. તારીખો strings તરીકે લખાય છે, સામાન્ય રીતે ઉપર બતાવેલ ISO 8601 ફોર્મેટમાં (2026-10-03T14:00:00Z, જ્યાં Z એટલે UTC). એ ફોર્મેટ પર સહમત થવાથી સમય-ઝોનની ભૂલોની આખી શ્રેણી ટળે છે.

કડક નિયમો (જ્યાંથી ભૂલો આવે છે)

JSON દેખાય તેના કરતાં ઓછું માફ કરનારું છે. આ બધું અમાન્ય છે:

{ name: "Lena" }            ← ડબલ quotes વગરની key
{ 'name': 'Lena' }          ← સિંગલ quotes
{ "a": 1, "b": 2, }         ← trailing comma
{ "a": 1 "b": 2 }           ← comma ગુમ
{ "a": 1 // comment }       ← comments માન્ય નથી

તમે જોશો તે મોટાભાગની "Unexpected token" ભૂલો આમાંથી એક હોય છે. JSON validator અથવા formatter તમને ચોક્કસ લાઇન બતાવશે.

કામનું ઉદાહરણ: એપમાંથી પસાર થતું JSON

એક ગ્રાહક બ્યુટી સલૂન એપમાં હેરકટ બુક કરે છે. અહીં JSON ક્યાં દેખાય છે:

1. બુકિંગ ફોર્મ એપના backend ને આ મોકલે છે:

{ "service": "Haircut", "startsAt": "2026-10-03T14:00:00Z", "name": "Lena Park" }

1. Backend બુકિંગને database માં સાચવે છે અને સ્ટેટસ 201 Created સાથે આ જવાબ આપે છે:

{ "id": 5001, "status": "confirmed" }

1. જો તે સમય પહેલેથી બુક થઈ ગયો હોય, તો તે તેના બદલે સ્ટેટસ 409 Conflict અને આ આપી શકે છે:

{ "error": "slot_taken", "message": "That time was just booked. Please pick another." }

પેજ status અથવા error વાંચે છે અને સાચો સંદેશ બતાવે છે. જો પેજ તેના બદલે ખાલી સ્ક્રીન બતાવે, તો બ્રાઉઝરના developer tools (Network ટેબ) માં આ JSON દેખાશે — ઘણી વાર શું ખોટું થયું તેની સૌથી ઝડપી કડી.

મુખ્ય શબ્દો

સામાન્ય ગેરસમજો

• "JSON એ JavaScript છે." તે JavaScript ની syntax પરથી આવ્યું, પણ તે language-independent છે; Python, Java, C#, Go અને બીજી બધી તેને વાંચે છે.
• "Quotes માં નંબર ઠીક છે." "35" એ string છે, number નહીં. બંનેને ભેળવવાથી bugs થાય છે, જેમ કે "35" + "5" નું "355" બની જવું. પૈસા ઘણી વાર પૂર્ણ સેન્ટ્સ તરીકે (3550) સાચવવા વધુ સારા છે, જેથી rounding ની સમસ્યા ન આવે.
• "JSON તો માત્ર ડેટા છે, એટલે સુરક્ષિત છે." JSON માં કંઈ પણ હોઈ શકે, secrets સહિત. બ્રાઉઝરને મોકલાતા JSON માં API keys ન મૂકો.
• "બધું JSON column માં મૂકો." વધારાની લવચીક માહિતી માટે સરસ, પણ જે ડેટા તમે શોધો, ફિલ્ટર કરો કે join કરો તે સામાન્ય રીતે યોગ્ય columns માં હોવો જોઈએ.
• "AI હંમેશાં માન્ય JSON આપે છે." Models વધારાનું લખાણ ઉમેરી શકે છે અથવા ફોર્મેટ તોડી શકે છે. ઘણા પ્રોવાઇડર્સ structured-output મોડ આપે છે; છતાં તમારા કોડે પાછું આવેલું ચકાસવું જોઈએ.

તમારા AI બિલ્ડરને શું માગવું

• "આ endpoint કયું JSON પાછું આપે છે તેનું ઉદાહરણ બતાવો."
• "ભૂલો JSON તરીકે પાછી આપો, જેમાં error કોડ અને માણસો વાંચી શકે તેવો message હોય."
• "તારીખો UTC માં ISO 8601 strings તરીકે સાચવો અને સ્ક્રીન પર જ સ્થાનિક સમયમાં ફેરવો."
• "કિંમતો પૂર્ણ સેન્ટ્સ તરીકે સાચવો."
• "આવતું JSON સર્વર પર માન્ય કરો અને ગુમ કે ખોટા પ્રકારના ફીલ્ડવાળી વિનંતીઓ નકારો."
• "AI model ને કૉલ કરતી વખતે આ ચોક્કસ આકારમાં JSON માંગો અને વાપરતા પહેલાં તપાસો."

Mythex માં JSON

Mythex માં તમારે JSON હાથે લખવાની જરૂર નથી — તમે જે જોઈએ છે તે વર્ણવો છો અને agent તેને મોકલવા અને વાંચવા માટેનો કોડ લખે છે. તેમ છતાં તેને ઓળખવું ઉપયોગી છે: જ્યારે કંઈ તૂટે, ત્યારે JSON ભૂલ ચેટમાં પેસ્ટ કરવાથી agent ને ચોક્કસ કડી મળે છે. docs ની REST API backend recipe શરૂઆતથી "clear JSON errors" માંગે છે, અને integrate any API recipe બહારની સેવાઓને કૉલ કરવાનું આવરી લે છે. મોટા ચિત્ર માટે જુઓ REST વિરુદ્ધ GraphQL અને AI થી બનેલી એપને કેવી રીતે debug કરવી.

પ્રશ્નો