JSON വാലിഡേറ്റർ

JSON സഹിതമായ പരിശോധന എന്താണ്?

JSON (ജാവസ്ക്രിപ്‌റ് ഒബ്‌ജക്റ്റ് നോട്ടേഷൻ) എന്നത് വളരെയധികം ഉപയോഗിക്കുന്ന, തുല്യഭാരം കുറഞ്ഞ ഡാറ്റാ-ഇന്റർചേഞ്ച് ഫോർമാറ്റാണ്, ഇത് മനുഷ്യർക്കു വായിക്കാൻ സുലഭവും യന്ത്രങ്ങൾക്കായി parse ചെയ്യാനും സൃഷ്ടിക്കാനും എളുപ്പമുള്ളതും ആക്കിയാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. അതിന്റെ പ്രധാന ഉദ്ദേശ്യം ഘടനാപരമായ ഡാറ്റയെ പ്രതിനിധീകരിക്കുക എന്നതാണ്—ഓബ്‌ജക്റ്റുകൾ, ਐറെയ്‌സ്, സ്ട്രിംഗ്‌സ്, നമ്പറുകൾ, ബൂൾയൻസ്, നൾ എന്നിവയെ ഭാഷയിൽ നിർദ്ദേശമില്ലാതെ പ്രത്യക്ഷപ്പെടുത്തുന്നു.

JSON സ്ഥിരീകരണം എന്നാണ് വിളിക്കുന്നത്, ഒരു JSON ഡോക്യുമെന്റ് വ്യാകരണപരവും ഘടനാപരവുമായ ദൃഢതയോടെ ശരിയായിട്ടുള്ളതായി പ്രോഗ്രാമാറ്റിക്കായി പരിശോധന നടത്തുന്നതിനുള്ള പ്രക്രിയ. ഇതിൽ രണ്ട് പ്രധാന അಂശങ്ങൾ പരിശോധിക്കപ്പെടുന്നു:

• വാക്യ ഘടനാ സാധുതാ പരിശോധന: അമലിന്‍റെ ECMA-404 JSON പ്രത്യേകതകൾ അനുസരിച്ചുള്ള ഔപചാരിക വ്യാകരണം പാലിക്കുന്നതിനായി raws ടെക്സ്റ്റ് ഉറപ്പാക്കൽ. മിക്ക പുതിയ പ്രോഗ്രാമിങ് ഭാഷകളിലെ പാഴ്സറുകൾ (ഉദാഹരണത്തിന്, ജാവാസ്ക്രിപ്റ്റിലെ JSON.parse(), പൈറ്റണിലെ json.loads(), ജാവയിലെ JSONDecoder) സാധുവായ സിന്ടാക്സ് പ്രതീക്ഷിച്ച് പ്രവർത്തിക്കുകയും തെറ്റായ ഇന്പുട്ട് കിട്ടുമ്പോൾ പിശകുകൾ കാണിക്കുകയും ചെയ്യുന്നു.
• ഘടനാത്മക (സ്‌കീമ) പരിശോധന: സിന്റാക്സിനെ മറികടന്ന്, സ്‌കീമാ പരിശോധന JSON ഡാറ്റ് ഒരു പ്രതീക്ഷിക്കപ്പെട്ട ഘടനയുമായി, ഉൾപ്പെടെയുള്ള ഡാറ്റാ തരം, ആവശ്യമുള്ള സ്വത്തുക്കൾ, മൂല്യ പരിച്ഛേദങ്ങൾ, നികുതി ചെയ്ത ഒബ്ജക്റ്റുകൾ/അറകളുടെ പൊരുത്തം പരിശോധിക്കുന്നു. സാധാരണയായി JSON Schema ഉപയോഗിച്ച് സ്‌കീമാ പരിശോധന നടപ്പാക്കപ്പെടുന്നു, ഇത് സാധുവായ ഡാറ്റാ എന്തെന്നു നിർവ്വചിക്കുന്ന നിയമങ്ങൾ നിർദ്ദിഷ്ടമാക്കുന്നു.

JSON പരിശോധന എന്തിന് ആവശ്യമുണ്ട്?

ഡാറ്റ ട്രാൻസ്മിഷൻ, സംഭരണം, അല്ലെങ്കിൽ ഇന്റർസർവീസ് സംവാദത്തിനായി സീരിയലൈസ് ചെയ്തപ്പോൾ JSON സാധുത ഉറപ്പ് വരുത്തുക അത്യന്താപേക്ഷിതമാണ്. പ്രധാന കാരണം ഉൾപ്പെടുന്നു:

• പിശക് തടയല്‍: ഡേറ്റ കൈകാര്യം ചെയ്യുന്നതിനു മുന്‍പ് ബൊര്‍ബിളുകള്‍ പോലുള്ള വാക്ക് തെറ്റായ ചിഹ്നങ്ങള്‍, മായ്ച്ചു കളഞ്ഞ കോമകള്‍, അസാധുവായ അക്ഷരങ്ങള്‍ തുടങ്ങിയവ നേരത്തെ കണ്ടെത്തി റിപ്പോര്‍ട്ട് ചെയ്യുക.
• ഡാറ്റ ഇൻٹیഗ്രിറ്റിയും സുരക്ഷയും: തകരാറുള്ള അല്ലെങ്കിൽ ദുഷ്പ്രേരിതമായ JSON പേലോഡുകൾ നിരസിച്ച്, ബാക്ക്‌എൻഡ് ക്രാഷുകൾ, ഇൻജക്ഷൻ ആക്രമണങ്ങൾ, അല്ലെങ്കിൽ ഡാറ്റ കവർച്ച തടയാൻ സഹായിക്കുന്നു.
• ടൈപ്പ് സുരക്ഷ: കർശനമായ ടൈപ്പിംഗ് നടപ്പാക്കുക—ഉദാഹരണത്തിന്, ബൂളിയൻ ആയിരിക്കാൻ വേണ്ടിവരുന്ന ഫീൽഡ് സ്ട്രിംഗായി അയക്കപ്പെടാതിരിക്കണമെന്ന് ഉറപ്പാക്കുകയും, UUIDകൾ, ഇമെയിലുകൾ, നമ്പറുകൾ ശരിയായ ഫോർമാറ്റിൽ ഉണ്ടാകുമെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുക.
• ഭാഷകളിൽ കൂടിയ പൊരുത്തം: ഒരു പരിസരത്തിൽ (ഉദാഹരണത്തിന്, Node.js) നിർമ്മിച്ച JSON മറ്റൊരു പരിസരത്തിൽ (ഉദാഹരണത്തിന്, Python, Go, Java) സുരക്ഷിതമായി ഉപയോഗിക്കാമെന്ന് ഉറപ്പാക്കുക, സെറിയലൈസേഷൻ/ഡീസെറിയലൈസേഷൻ പിശകുകൾ ഒഴിവാക്കി.
• പരിപാലനക്ഷമതയും ദൃഢതയും: അംഗീകരിച്ച ഡാറ്റ ഘടനകൾ ട്രെയ്സബിലിറ്റി മെച്ചപ്പെടുത്തുകയും കോൺഫിഗറേഷൻ ഫയലുകളിൽ, ലോഗുകളിൽ, അല്ലെങ്കിൽ API അഭ്യർത്ഥനകളിലും പ്രതികരണങ്ങളിലും സ്ഥിതി ചെയ്യുന്നതായ ബുദ്ധിമുട്ടുള്ള പിശകുകൾ കുറയ്ക്കുകയും ചെയ്യുന്നു.
• സ്വകാര്യതയും സുരക്ഷയും: ധാർമ്മിക പരിശോധനകൾ മുഴുവൻ ക്ലയന്റ്-സൈഡ് (ബ്രൗസറിനുള്ളിൽ) നടത്താമെന്ന് ഉറപ്പാക്കുന്നു, ഇതിലൂടെ യഥാർത്ഥമോ സങ്കീർണ്ണവുമായ ഡാറ്റയും ഉപയോക്താവിന്റെ ഉപകരണത്തിൽ നിന്ന് പുറത്തേക്ക് പോകുന്നത് തടയുന്നു.

പൊതുവായ JSON സാധുതാപരിശോധന પુഠനവിവരങ്ങൾ (വിശദമായ ഉദാഹരണങ്ങളോടെ)

ഉദ്ധരിക്കാതെ കീകൾ

JSON വസ്തുക്കളിലെ എല്ലാ കീകളും ഇരട്ട ഉദ്ധരണ ചിഹ്നങ്ങളാൽ ചുറ്റപ്പെട്ട സ്ട്രിങുകൾ ആകണം.

{ name: "അലീസ്" }

{ "name": "അലീസ്" }

അനേകം JSON-സമാന ഫോർമാറ്റുകൾ (ഉദാഹരണത്തിന്, ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്ട് ലിറ്ററൽസ്) ഉദ്ധരണികളില്ലാത്ത കീകൾ അനുവദിച്ചാലും, സ്റ്റാൻഡേർഡ് JSON ഒന്നും അവഗണിക്കുന്നു.

ഒറ്റ ഉദ്ധരണികൾ

JSON സ്ട്രിങ്ങുകൾ കൃത്യമായി ഡബിൾ കൊടുവകൊള്ളികൾ ഉപയോഗിച്ചുതന്നെ എഴുതണം; ഒറ്റ കൊടുവകൊള്ളികൾ അനുവദനീയമല്ല.

{ 'name': 'ബോബ്' }

{ "name": "ബോബ്" }

ഏകവര്ണ്ണ ചിഹ്നങ്ങൾ ഉപയോഗിക്കുന്നത് എല്ലാ അനുസരിച്ചുള്ള JSON ലൈബ്രറികളിലും പാഴ്സർ പിഴവുകൾ ഉണ്ടാക്കും.

അന്തിമ കോമുകൾ

ഒരു ഒബ്ജക്ടിലും അല്ലെങ്കിൽ അrrayയിലും അവസാന آیടത്തിനുശേഷമുള്ള കോമ ഉപയോഗിക്കരുത്.

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

ട്രെയ്ലിംഗ് കോമകൾ ജാവാസ്ക്രിപ്റ്റിൽ പ്രവർത്തിക്കാം, പക്ഷേ കർശനമായ JSON പാഴ്സറുകളിൽ അത് സാധ്യമല്ല.

തെറ്റായ അക്ഷരങ്ങള്‍ എസ്കേपിംഗ്

സ്ട്രിങ്ങുകളിലുളള ഉദ്ധരണികൾക്കും പ്രത്യേക അക്ഷരത്തിനും ബാക്ക്‌സ്ലാഷ് ഉപയോഗിച്ച് എസ്കേപ്പ് ചെയ്യണം.

{ "quote": "ടോം പറഞ്ഞു "ഹലോ"" }

{ "quote": "ടോം പറഞ്ഞു \"ഹലോ\"" }

മറ്റു എസ്കേപ്പ് സീక్వൻസുകളിൽ \ അടയാളത്തിനായി \\ ഉം, പുതിയ വരികൾക്ക് \n ഉം, ടാബുകൾക്കായി \t ഉം ഉൾപ്പെടുന്നു.

തെറ്റായ ഡാറ്റ ടൈപ്പുകൾ

സംഖ്യകൾ, ബൂലിയൻ മൂല്യങ്ങൾ, അല്ലെങ്കിൽ നൾ മൂല്യങ്ങൾ సూచിക്കാൻ സ്ട്രിംഗ് ഉപയോഗിക്കരുത്.

{ "enabled": "സജീവമാണ്", "count": "10" }

{ "enabled": true, "count": 10 }

JSON ബൂളിയൻ, സംഖ്യകൾ, സ്ട്രിംഗ് എന്നിവ വേര്‍തിരിക്കുന്നു — ശരിയായ തരം ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുക.

അപ്രാഥമിക കീകൾ

JSON ഒബ്‌ജെക്ട് കീകൾ എപ്പോഴും സ്ട്രിംഗ് ആകണം; നിങ്ങൾക്ക് നമ്പറുകൾ, ബൂളിയൻ മൂല്യങ്ങൾ, അല്ലെങ്കിൽ മറ്റ് വിധത്തിലുള്ള മൂല്യങ്ങൾ കീയായി ഉപയോഗിക്കാനാകില്ല.

{ 123: "എാബിസി" }

{ "123": "എബിസി" }

പ്രതി കീകൾ

JSON അമര്ത്ഥത്തിൽ അനുവദിച്ചിട്ടുണ്ടെങ്കിലും, ഒരേ കീ പലതോമെ വന്നാൽ സാധാരണമായ പിഴവുകളുടെ കാരണമാകും.

{ "name": "അലിസ്", "name": "ബോബ്" }

അകത്തള解析കർത്താക്കൾ കൂടുതലും അവസാന മൂല്യം ("Bob") മാത്രം ഒഴിച്ച് വെച്ച്, മുൻവരകൾ നിശ്ശബ്ദമായി ഒഴിവാക്കും.

കമന്റുകളുടെ ഉപയോഗം

സ്റ്റാൻഡേർഡ് JSON കമന്റുകൾ അനുവദിക്കുന്നില്ല, എന്നാൽ ചില എഡിറ്ററുകൾ അവ പിന്തുണയ്ക്കുന്നതായി കാണാം.

{
  // ഉപയോക്തൃ വിവരങ്ങൾ
  "name": "ആലിസ്"
}

{
  "name": "ആലിസ്"
}

സ്കീമ സർവേക്ഷണം: ഘടനയും ഡാറ്റാ തരം നിർണ്ണയവും നിർബന്ധമാക്കൽ

JSON Schema ഒരു ശക്തമായ സ്റ്റാൻഡേർഡ് ആണ്, JSON ഡോക്യുമെന്റുകളുടെ പ്രതീക്ഷിക്കുന്ന ഘടന നിർവചിക്കുകയും സാധുത പരിശോധിക്കുകയും ചെയ്യുന്നത്. ഇത് നിങ്ങൾക്ക് സ്പെസിഫൈ ചെയ്യാൻ അനുവദിക്കുന്നു:

• ആവശ്യമായ ഫീൽഡുകൾ (`required`)
• ഡേറ്റാ തരംകൾ (`type`: സ്ട്രിംഗ്, സംഖ്യ, ബൂലിയൻ, объജക്ട്, അരെയ്, നൾ)
• സ്ട്രിംഗ് ഫോർമാറ്റുകൾ (`format`: ഇമെയിൽ, uuid, തീയതി-സമയം, തുടങ്ങിയവ)
• സ്ട്രിംഗ്‌സിനുള്ള ദേശവുമാറ്റം പ്രയോഗം (`pattern`)
• സംഖ്യാ പരിധികള്‍ (`കുറഞ്ഞത്`, `അധികം` )
• അറേയിലെ വസ്തുക്കളുടെ എണ്ണം ശരിവെക്കൽ (`minItems`, `maxItems`, `items`)
• ഓബ്ജക്റ്റുകൾക്കും അറേയുകൾക്കും ഫലപ്രദമായ നിസ്റ്റഡ് നിലവാരം
• എനത്തിന്‌ വിലനിയന്ത്രണങ്ങൾ (`enum`)

ഉദാഹരണം: യൂസർ സ്‌കീമ (ഡ്രാഫ്റ്റ്-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

ഇതിലൂടെ നടപ്പാക്കപ്പെടുന്നത്:

• ഐഡിയ UUID സാധുവായ സ്ട്രിംഗ് ആയിരിക്കണം.
• പേര് ഒഴിഞ്ഞിട്ടില്ലാത്ത സ്ട്രിംഗ് ആകണം.
• ഇമെയിൽ സാധാരണ ഇമെയിൽ രൂപരേഖ പാലിക്കണം.
• is_active (ഐച്ഛികം) ബൂളിയൻ ആയിരിക്കണം.
• മുകളിൽ നിർവ്വചിച്ചവരിൽ ഒഴികെയുള്ള മറ്റ് സ്വത്തുക്കൾ അനുവദനീയമല്ല.

പ്രായോഗിക ഉദാഹരണം: Stripe API പ്രതികരണങ്ങളുടെ സ്ഥിരീകരണം

നിങ്ങൾ Stripe API-യിൽ നിന്ന് JSON പ്രതികരണങ്ങൾ (ഉദാ., PaymentIntent) ലഭിക്കുന്നുവെന്ന് فرضിക്കുക. സ്കീമ പരിശോധണം അസംപൂർണമായ അല്ലെങ്കിൽ തെറ്റായ തരത്തിലുളള ഡേറ്റ പ്രോസസ്സ് ചെയ്യാതെ നിങ്ങളെ രക്ഷിക്കാം.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "പെയ്മെന്റ് മേധാവ് ആവശ്യമാണ്",
      "സ്ഥിരീകരണം ആവശ്യമാണ്",
      "പ്രോസസ്സ് ചെയ്യുന്നു",
      "വിജയം",
      "റദ്ദാക്കിയിരിക്കുന്നു"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• ഐഡി "pi_" എന്നതിനുശേഷം തുടങ്ങണം
• ഓർത്ത്‌വയ്ക്കേണ്ടത് ഒരു "payment_intent" ഒബ്ജക്റ്റ് ആകണം
• തൊക്ക് 1നോ അതിനു മുകളിൽ ഉള്ള മുഴുവൻ സംഖ്യയായിരിക്കണം
• കടന്‍ നാണയം മൂന്ന് അക്ഷരങ്ങളായ ഒരു സ്ട്രിംഗ് ആയിരിക്കണം (ഉദാഹരണം: "usd", "eur")
• स्थिति നിർദ്ദിഷ്‌ട മൂല്യങ്ങളിൽ ഒരിടത്തായിരിക്കണം

പ്രയോജനങ്ങൾ

• ആദ്യഘട്ടത്തിലെ പിഴവ് കണ്ടെത്തൽ: നിങ്ങളുടെ ബിസിനസ് ലജികിലേക്ക് റീച്ച് ചെയ്യുന്നതിനു മുൻപ് ബ്രേക്കിംഗ് API മാറ്റങ്ങളും അപൂർണ്ണമായ ഡാറ്റയുമെല്ലാം പിടികൂടൂ.
• ഓട്ടോമേറ്റഡ് ടെസ്റ്റിംഗ്: യാഥാർഥ്യവും മോക്ക് പ്രതികരണങ്ങളുമായുള്ള പരിശോധനയ്ക്ക് CI/CD പൈപ്പ്‌ലൈനുകളിൽ സ്‌കീമകൾ ഉപയോഗിക്കുക.
• രണ്ടു ടീമുകൾക്കിടയിലെ ഒരുപോലുള്ളത്വം: ഫ്രണ്ട്‌എൻഡ്, ബാക്ക്‌എൻഡ്, മൂന്നാംപാർട്ടി API-കളുടെ ഇടയിൽ ഡാറ്റാ കരാറുകൾ ഏകരീതപ്പെടുത്തുക.

സൂക്ഷ്മമായ പിശക് കണ്ടെത്തലുകൾ തടയുവാൻ, മികച്ച പ്രവർത്തന മാർഗങ്ങൾ പാലിക്കാൻ, തെറ്റായ അല്ലെങ്കിൽ ദുഷ്പ്രവൃത്തിയുള്ള ഇൻപുട്ടുകളിൽനിന്ന് നിങ്ങളുടെ അപ്ലിക്കേഷനുകൾ സുരക്ഷിതമാക്കാൻ ശരിയായ JSON സാധുത പരിശോധന—സിന്ടാക്സ്, സ്കീമകൾ ഉൾപ്പെടെ—മൂല്യവത്താണ്. കോൺഫിഗറേഷൻ ഫയലുകളിൽ, API പെയ്ലോഡുകളിൽ, അല്ലെങ്കിൽ ഇന്റർ-സർവീസ് മെസേജിങിലോ ഉപയോഗിക്കുമ്പോഴും, ശക്തമായ സാധുത പരിശോധന ആധുനിക സോഫ്റ്റ്വെയർ സിസ്റ്റങ്ങൾക്കും അടിസ്ഥാന ഘടകമാണ്.

സ്വകാര്യതയും സുരക്ഷയും

എല്ലാ പരിശോധനകളും സ്കീമ പരിശോധനകളും നിങ്ങളുടെ ബ്രൗസറിലൂടെയായാണ് സമ്പൂർണമായും പ്രവർത്തിക്കുക. യാതൊരു ഡാറ്റയും അപ്‌ലോഡ് ചെയ്യുകയോ ലോഗ് ചെയ്യുകയോ നടക്കുന്നില്ല. നിങ്ങളുടെ JSON പൂർണ്ണമായും സ്വകാര്യമാണ്.

JSON സാധൂകരണത്തിനുള്ള കോഡ് ഉദാഹരണങ്ങൾ

എന്താണ് JSON മാനദണ്ഡങ്ങൾ വിവിധ പ്രോഗ്രാമിങ് ഭാഷകളിൽ നിർമ്മിത ലൈബ്രറീരുകൾക്കോ ജനപ്രിയ ഫ്രെയിംവർക്കുകൾക്കോ ഉപയോഗിച്ച് സ്ഥിരീകരിക്കേണ്ടത് എങ്ങനെ എന്ന് കാണുക. ഈ ഉദാഹരണങ്ങൾ സിന്റക്സ് പരിശോധനയും സ്കീമ പരിശോധനയും ഇരുവരേയും പ്രദർശിപ്പിക്കുന്നു.

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{"name":"Alice","age":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{"name":"Alice","age":30}";
    try {
      var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

ഈ ഉപകരണമേക്കുറിച്ച്