ਜੇਐਸਓਐਨ ਵੈਧਕ

JSON ਵੈਲੀਡੇਸ਼ਨ ਕੀ ਹੈ?

JSON (ਜਾਵਾਸਕ੍ਰਿਪਟ ਆਬਜੈਕਟ ਨੋਟੇਸ਼ਨ) ਇੱਕ ਵਿਆਪਕ ਅਪਣਾਈ ਗਿਆ, ਹਲਕਾ ਫੁਲਕਾ ਡੇਟਾ-ਇੰਟਰਚੇਂਜ ਫਾਰਮੈਟ ਹੈ, ਜੋ ਕਿ ਮਨੁੱਖੀ ਪੜ੍ਹਨ ਲਾਇਕ ਅਤੇ ਮਸ਼ੀਨਾਂ ਵੱਲੋਂ ਆਸਾਨੀ ਨਾਲ ਪਾਰਸ ਅਤੇ ਜੈਨਰੇਟ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸਦਾ ਮੁੱਖ ਉਦੇਸ਼ ਸੰਰਚਿਤ ਡੇਟਾ—ਆਬਜੈਕਟ, ਐਰੇ, ਸਟਰਿੰਗਜ਼, ਨੰਬਰ, ਬੂਲੀਅਨ, ਅਤੇ ਨੱਲ—ਨੂੰ ਇੱਕ ਭਾਸ਼ਾ-ਰਹਿਤ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਉਣਾ ਹੈ।

JSON ਵੈਧਤਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਇੱਕ JSON ਦਸਤਾਵੇਜ਼ ਨੂੰ ਕਾਰਜਕਾਰੀ ਤਰੀਕੇ ਨਾਲ ਜਾਂਚਣ ਦੀ ਹੁੰਦੀ ਹੈ, ਜੋ ਕਿ ਕਿਸਮਤ ਅਤੇ ਸਰਚਨਾ ਦੋਹਾਂ ਵੱਲੋਂ ਸਹੀ ਹੋਣ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੀ ਹੈ। ਇਸ ਵਿੱਚ ਦੋ ਮੁੱਖ ਪਹਲੂਆਂ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਹੈ:

• ਸੰਰਚਨਾਤਮਕ ਜਾਂਚ: ECMA-404 JSON ਵਿਸ਼ੇਸ਼ਣ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਅਧਿਕਾਰਿਕ ਵਿਆਕਰਣ ਦੇ ਅਨੁਸਾਰ ਕੱਚੇ ਪਾਠ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ। ਜ਼ਿਆਦਾਤਰ ਆਧੁਨਿਕ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਪਾਰਸਰ (ਜਿਵੇਂ ਕਿ ਜਾਵਾਸਕ੍ਰਿਪਟ ਵਿੱਚ JSON.parse(), ਪਾਇਥਨ ਵਿੱਚ json.loads(), ਜਾਵਾ ਵਿੱਚ JSONDecoder) ਵੈਧ ਸਿੰਟੈਕਸ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹਨ ਅਤੇ ਜੇਕਰ ਇਨਪੁੱਟ ਗਲਤ ਹੋਵੇ ਤਾਂ ਗਲਤੀ ਫੈਂਕਦੇ ਹਨ।
• ਸੰਰਚਨਾਤਮਕ (Schema) ਚੈੱਕਿੰਗ: ਸਿੰਟੈਕਸ ਤੋਂ ਇਲਾਵਾ, ਸਕੀਮਾ ਵੈਲਿਡੇਸ਼ਨ ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ JSON ਡੇਟਾ ਇੱਕ ਉਮੀਦ ਕੀਤੀ ਗਈ ਬਣਤਰ ਨਾਲ ਮਿਲਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਡੇਟਾ ਪ੍ਰਕਾਰ, ਲੋੜੀਂਦੇ ਗੁਣ, ਵੈਲਯੂ ਸੀਮਾਵਾਂ ਅਤੇ ਸਭਿਆਚਾਰਕ ਅਬਜੈਕਟ/ਐਰੇ ਸ਼ਾਮਲ ਹਨ। ਸਕੀਮਾ ਵੈਲਿਡੇਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ JSON ਸਕੀਮਾ ਦੀ ਵਰਤੋਂ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਵੈਧ ਡੇਟਾ ਲਈ ਨਿਯਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।

JSON ਨੂੰ ਵੈਰੀਫਾਈ ਕਰਨ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ?

ਜਿਥੇ ਵੀ ਡਾਟਾ ਨੂੰ ਟ੍ਰਾਂਸਮਿਸ਼ਨ, ਸਟੋਰੇਜ ਜਾਂ ਸੇਵਾ-ਵਿੱਚਕਾਰ ਕਮਿਊਨੀਕੇਸ਼ਨ ਲਈ ਸੀਰੀਅਲਾਈਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਉੱਥੇ JSON ਵੈਧਤਾ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ। ਮੁੱਖ ਕਾਰਨਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਗਲਤੀ ਰੋਕਥਾਮ: ਸਿਨਟੈਕਸ ਗਲਤੀਆਂ (ਜਿਵੇਂ ਕਿ ਕਮਾਂ ਦੀ ਕਮੀ, ਅਪੂਰਨ ਕੋਠੜੀਆਂ, ਗਲਤ ਅੱਖਰ) ਨੂੰ ਜਲਦੀ ਪਹਚਾਣੋ ਤੇ ਰਿਪੋਰਟ ਕਰੋ—ਡੇਟਾ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ।
• ਡੇਟਾ ਅਖੰਡਤਾ ਅਤੇ ਸੁਰੱਖਿਆ: ਗਲਤ ਜਾਂ ਮਾਲਿਸ਼ੀਅਸ JSON ਪੇਲੋਡਾਂ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰੋ, ਜਿਸ ਨਾਲ ਬੈਕਐਂਡ ਖਰਾਬੀਆਂ, ਇੰਜੈਕਸ਼ਨ ਹਮਲਿਆਂ ਜਾਂ ਡੇਟਾ ਖ਼ਰਾਬ ਹੋਣ ਤੋਂ ਬਚਾਅ ਹੋਵੇ।
• ਟਾਈਪ ਸੁਰੱਖਿਆ: ਸਖਤ ਟਾਈਪਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰੋ—ਜਿਵੇਂ ਕਿ, ਉਦਾਹਰਨ ਵਜੋਂ, ਜੇ ਕੋਈ ਖੇਤਰ ਬੂਲੀਅਨ ਹੋਣ ਦੀ ਉਮੀਦ ਹੈ ਤਾਂ ਉਹ ਸਟ੍ਰਿੰਗ ਵਜੋਂ ਨਾ ਭੇਜਿਆ ਜਾਵੇ, ਜਾਂ UUIDs, ਇਮੇਲ, ਜਾਂ ਨੰਬਰ ਸਹੀ ਫਾਰਮੈਟ ਵਿੱਚ ਹੀ ਹੋਣ।
• ਬਹੁਭਾਸ਼ਾਈ ਅਨੁਕੂਲਤਾ: ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਇੱਕ ਵਾਤਾਵਰਣ (ਜਿਵੇਂ ਕਿ Node.js) ਵਿੱਚ ਤਿਆਰ ਕੀਤੀ ਗਈ JSON ਦੂਜੇ ਵਾਤਾਵਰਣ ਵਿੱਚ (ਜਿਵੇਂ ਕਿ Python, Go, Java) ਬਿਨਾਂ ਕਿਸੇ ਸਿਰੀਅਲਾਈਜ਼ੇਸ਼ਨ/ਡਿਸਿਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਖ਼ਾਮੀਆਂ ਦੇ ਸੁਰੱਖਿਅਤ ਤੌਰ 'ਤੇ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।
• ਸੰਭਾਲ ਅਤੇ ਮਜ਼ਬੂਤੀ: ਪ੍ਰਮਾਣਿਤ ਡੇਟਾ ਢਾਂਚੇ ਟਰੈਸੇਬਿਲਿਟੀ ਨੂੰ ਵਧਾਉਂਦੇ ਹਨ ਅਤੇ ਕਾਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲਾਂ, ਲੌਗਜ਼ ਜਾਂ API ਬੇਨਤੀ/ਜਵਾਬ ਵਿੱਚ ਮੁਸ਼ਕਿਲ ਤੋਂ ਮੁਸ਼ਕਿਲ ਤ੍ਰੁੱਟੀਆਂ ਦੇ ਖਤਰੇ ਨੂੰ ਘਟਾਉਂਦੇ ਹਨ।
• ਪ੍ਰਾਈਵੇਸੀ ਅਤੇ ਸੁਰੱਖਿਆ: ਵੈਲਿਡੇਸ਼ਨ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਲਾਇਂਟ-ਸਾਈਡ (ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ) ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਕੱਚਾ ਜਾਂ ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਯੂਜ਼ਰ ਦੇ ਡਿਵਾਈਸ ਤੋਂ ਬਾਹਰ ਵੈਲਿਡੇਸ਼ਨ ਲਈ ਨਹੀਂ ਜਾਂਦਾ।

ਆਮ JSON ਵੈਲੀਡੇਸ਼ਨ ਤਰੁਟੀਆਂ (ਵਿਸਤਾਰਪੂਰਵਕ ਉਦਾਹਰਣਾਂ ਸਮੇਤ)

ਔਟੋਟ ਕੀਜ ਨਹੀਂ

JSON ਆਬਜੈਕਟਾਂ ਵਿੱਚ ਸਾਰੇ ਕੁੰਜੀਆਂ ਦੋਹਰੇ ਉਲਲੇਖਕਾਂ ਵਾਲੀਆਂ ਸਤਰਾਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।

{ name: "ਐਲਿਸ" }

{ "name": "ਐਲਿਸ" }

ਕਈ JSON-ਸਮਾਨ ਫਾਰਮੈਟ (ਜਿਵੇਂ ਕਿ ਜਾਵਾਸਕ੍ਰਿਪਟ ਆਬਜੈਕਟ ਲਿਟਰਲ) ਬਿਨਾਂ ਕਿਰਪਟੀਆਂ ਵਾਲੀਆਂ ਕੁੰਜੀਆਂ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ, ਪਰ ਸਧਾਰਣ JSON ਵਿੱਚ ਇਹ ਸਹੀ ਨਹੀਂ ਹੈ।

ਇਕਲੌਤੇ ਕੋਟੇਸ਼ਨ

JSON ਸਤਰਾਂ ਵਿੱਚ ਸਿਰਫ ਦੋਹਰੀ ਕੋਟੇਸ਼ਨ ਚਿੰਨ੍ਹ ਹੀ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ; ਇਕੱਲੇ ਕੋਟੇਸ਼ਨ ਮਨਜ਼ੂਰ ਨਹੀਂ ਹਨ।

{ 'name': 'ਬਾਬ' }

{ "name": "ਬਾਪ" }

ਇੱਕਲੋਟੜੇ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਸਾਰੇ ਅਨੁਕੂਲ JSON ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਪਾਰਸਰ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਦਾ ਕਾਰਣ ਬਣੇਗੀ।

ਅੰਤ ਵਾਲੇ ਕੌਮਾ

ਇੱਕ ਔਬਜੈਕਟ ਜਾਂ ਐਰੇ ਵਿੱਚ ਆਖਰੀ ਆਈਟਮ ਤੋਂ ਬਾਅਦ کوئی ਕਮਾ ਨਹੀਂ ਲਗਾਉਣਾ।

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

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

ਟਰੇਲਿੰਗ ਕੰਮਾ ਜਾਵਾਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ, ਪਰ ਕੜੇ JSON ਪਾਰਸਰਾਂ ਵਿੱਚ ਨਹੀਂ।

ਅੱਖਰਾਂ ਦੀ ਗਲਤ ਤਰ੍ਹਾਂੋਂ ਏਸਕੇਪਿੰਗ

ਸਤਰਾਂ ਦੇ ਅੰਦਰ ਉਤੇਰਲੇ ਅਤੇ ਵਿਸ਼ੇਸ਼ ਅੱਖਰਾਂ ਨੂੰ ਬੈਕਸਲੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਸਕੇਪ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

{ "quote": "ਟੌਮ ਨੇ ਕਿਹਾ 'ਹੈਲੋ'" }

{ "quote": "ਟੌਮ ਨੇ ਕਿਹਾ \"ਸਤ ਸ੍ਰੀ ਅਕਾਲ\"" }

ਹੋਰ ਐਸਕੇਪ ਸਿਕਵੰਸਾਂ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ ਲਈ \\ , ਨਵੇਂ ਲਾਈਨਾਂ ਲਈ \n ਅਤੇ ਟੈਬ ਲਈ \t ਸ਼ਾਮਲ ਹਨ।

ਗਲਤ ਡੇਟਾ ਕਿਸਮਾਂ

ਅੰਕ, ਬੂਲੀਅਨ ਜਾਂ ਨੱਲ ਲਈ ਸਤਰਾਂ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ।

{ "enabled": "ਸਚ", "count": "10" }

{ "ਸਕ੍ਰਿਯ": ਸੱਚ, "ਗਿਣਤੀ": 10 }

JSON ਬੂਲੀਅਨ, ਨੰਬਰ ਅਤੇ ਸਟਰਿੰਗਜ਼ ਵਿੱਚ ਫਰਕ ਕਰਦਾ ਹੈ—ਸੁਨਿਸ਼ਚਿਤ ਕਰੋ ਕਿ ਸਹੀ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ।

ਗੈਰ-ਮੂਲ ਕੁੰਜੀਆਂ

JSON ਆਬਜੈਕਟ ਦੀਆਂ ਕੁੰਜੀਆਂ ਹਮੇਸ਼ਾ ਸਤਰਾਂ (strings) ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ; ਤੁਸੀਂ ਨੰਬਰ, ਬੂਲੀਅਨ ਜਾਂ ਹੋਰ ਕਿਸੇ ਕਿਸਮਾਂ ਨੂੰ ਕੁੰਜੀ ਵਜੋਂ ਵਰਤ ਨਹੀਂ ਸਕਦੇ।

{ 123: "ਏਬੀਸੀ" }

{ "123": "ਏਬੀਸੀ" }

ਨਕਲ ਕੁੰਜੀਆਂ

ਜਦੋਂ ਕਿ JSON ਵਿਸ਼ੇਸ਼ਤਾ ਦੁਆਰਾ ਇਜਾਜ਼ਤ ਹੈ, ਨਕਲ ਕੁੰਜੀਆਂ ਆਮ ਤੌਰ 'ਤੇ ਬੱਗਾਂ ਦਾ ਸੋਤਰ ਹੁੰਦੀਆਂ ਹਨ।

{ "name": "ਐਲਿਸ", "name": "ਬੌਬ" }

ਜ਼ਿਆਦਾਤਰ ਪਾਰਸਰ ਸਿਰਫ਼ ਆਖਰੀ ਮੁੱਲ ("Bob") ਨੂੰ ਹੀ ਸੰਭਾਲਦੇ ਹਨ, ਪਹਿਲਾਂ ਵਾਲੇ ਮੁੱਲਾਂ ਨੂੰ ਬਿਨਾਂ ਦੱਸੇ ਹੀ ਖਤਮ ਕਰ ਦਿੰਦੇ ਹਨ।

ਟਿੱਪਣੀਆਂ ਦੀ ਵਰਤੋਂ

ਮਿਆਰੀ JSON ਵਿਚ ਟਿੱਪਣੀਆਂ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਹੈ, ਹਾਲਾਂਕਿ ਕੁਝ ਸੰਪਾਦਕ ਉਹਨਾਂ ਨੂੰ ਸਹਿਯੋਗ ਦਿੰਦੇ ਹਨ।

{
  // ਯੂਜ਼ਰ ਜਾਣਕਾਰੀ
  "name": "ਏਲਿਸ"
}

{
  "name": "ਐਲਿਸ"
}

ਸਕੀਮਾ ਸਹੀਕਰਨ: ਢਾਂਚਾ ਅਤੇ ਡਾਟਾ ਕਿਸਮਾਂ ਦੀ ਪਾਬੰਦੀ

JSON Schema ਇੱਕ ਤਾਕਤਵਰ ਮਿਆਰ ਹੈ ਜੋ JSON ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਉਮੀਦ ਕੀਤੀ ਗਈ ਸੰਰਚਨਾ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਅਤੇ ਵੈਧਤਾ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਨਾਲ ਤੁਸੀਂ ਦਰਜਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਕਿ:

• ਜ਼ਰੂਰੀ ਖੇਤਰ (`required`)
• ਡਾਟਾ ਪ੍ਰਕਾਰ (`type`: ਸਟਰਿੰਗ, ਨੰਬਰ, ਬੂਲੀਅਨ, ਔਬਜੈਕਟ, ਐਰੇ, ਨਲ)
• ਸਟ੍ਰਿੰਗ ਫੋਰਮੈਟ (`format`: ਈਮੇਲ, ਯੂਆਈਡੀ, ਤਾਰੀਖ-ਸਮਾਂ, ਆਦਿ)
• ਸਤ੍ਰਾਂ ਲਈ ਪੈਟਰਨ ਮਿਲਾਉਣਾ (`pattern`)
• ਨੰਬਰ ਦੀ ਲੜੀ (`ਘੱਟੋ-ਘੱਟ`, `ਵੱਧ ਤੋਂ ਵੱਧ`)
• ਅਰੇ ਦੀ ਲੰਬਾਈ ਅਤੇ ਆਈਟਮ ਦੀ ਵੈਧਤਾ (minItems, maxItems, items)
• ਆਬਜੈਕਟ ਅਤੇ ਐਰੇਜ਼ ਲਈ ਘੁੰਮਾਵਾਰ ਜਾਂਚ
• ਇਨਮ ਸੀਮਾਵਾਂ (`enum`)

ਉਦਾਹਰਨ: ਯੂਜ਼ਰ ਸਕੀਮਾ (ਡ੍ਰਾਫਟ-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1, "description": "ਉਪਭੋਗਤਾ ਦਾ ਨਾਮ" },
    "email": { "type": "string", "format": "email", "description": "ਵੈਧ ਈਮੇਲ ਪਤਾ" },
    "is_active": { "type": "boolean", "description": "ਖਾਤਾ ਸਰਗਰਮ ਹੈ ਜਾਂ ਨਹੀਂ" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

ਇਹ ਕੀ ਲਾਗੂ ਕਰਦਾ ਹੈ:

• id ਇੱਕ ਵੈਧ UUID ਸਟਰਿੰਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਨਾਂ ਖਾਲੀ ਸਤਰ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
• ਈਮੇਲ ਸਧਾਰਣ ਅਤੇ ਮਿਆਰੀ ਈਮੇਲ ਫਾਰਮੈਟ ਦੇ ਨਾਲ ਮੇਲ ਖਾਣੀ ਚਾਹੀਦੀ ਹੈ।
• is_active (ਵਿਕਲਪੀ) ਇੱਕ ਬੂਲੀਅਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਉੱਪਰ ਦਿੱਤੀਆਂ ਸਰਵਿਸਜ਼ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਕੋਈ ਜਾਇਦਾਦ ਮਨਜ਼ੂਰ ਨਹੀਂ ਹੈ।

ਅਸਲੀ ਦੁਨੀਆ ਦਾ ਉਦਾਹਰਨ: Stripe API ਦੇ ਜਵਾਬਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨਾ

ਮੰਨ ਲਵੋ ਤੁਹਾਨੂੰ ਸਟਰਾਈਪ API (ਜਿਵੇਂ PaymentIntent) ਤੋਂ JSON ਜਵਾਬ ਮਿਲਦੇ ਹਨ। ਸਕੀਮਾ ਵੈਧਤਾ ਨਾਲ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕਦੇ ਵੀ ਅਧੂਰੇ ਜਾਂ ਗਲਤ ਕਿਸਮ ਦੇ ਡਾਟਾ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਨਹੀਂ ਲਿਆਉਂਦੇ।

{
  "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
}

• id "pi_" ਨਾਲ ਸ਼ੁਰੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
• ਆਬਜੈਕਟ ਸਦਾ "payment_intent" ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
• ਰਾਸ਼ੀ ਇੱਕ ਪੂਰਨਾਂਕ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਜੋ 1 ਜਾਂ ਉਸ ਤੋਂ ਵੱਧ ਹੋਵੇ
• ਮੁਦਰਾ ਤਿੰਨ ਅੱਖਰਾਂ ਦਾ ਸਤਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਜਿਵੇਂ, "usd", "eur")
• ਸਥਿਤੀ ਦਿੱਤੀਆਂ ਗਈਆਂ ਮੁੱਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ

ਫਾਇਦੇ

• ਸ਼ੁਰੂਆਤੀ ਗਲਤੀ ਪਛਾਣ: ਆਪਣੇ ਵਪਾਰਿਕ ਤਰਕ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਤੋੜ-ਫੋੜ ਵਾਲੇ API ਬਦਲਾਅ ਜਾਂ ਅਧੂਰੇ ਡਾਟੇ ਨੂੰ ਫੜੋ।
• ਆਟੋਮੇਟਿਡ ਟੈਸਟਿੰਗ: ਅਸਲੀ ਅਤੇ ਮੌਕ ਜਵਾਬਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ CI/CD ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਸਕੀਮਿਆਂ ਦਾ ਇਸਤੇਮਾਲ ਕਰੋ।
• ਟੀਮਾਂ ਦੇ ਵਿਚਕਾਰ ਸਥਿਰਤਾ: ਫਰੰਟਐਂਡ, ਬੈਕਐਂਡ ਅਤੇ ਤੀਜੀਆਂ ਪੱਖੀ APIs ਦਰਮਿਆਨ ਡੇਟਾ ਕੰਟ੍ਰੈਕਟਾਂ ਨੂੰ ਮਿਆਰੀਕਰਣ ਕਰੋ।

ਸਹੀ 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)
  }
}

ਇਸ ਟੂਲ ਬਾਰੇ