Whiz Tools

ਜੇਐਸਓਐਨ ਫਾਰਮੈਟਰ

ਇਸ ਸਧਾਰਣ ਟੂਲ ਨਾਲ ਆਪਣੇ ਜੇਐਸਓਐਨ ਨੂੰ ਫਾਰਮੈਟ ਅਤੇ ਸੁੰਦਰ ਬਣਾਓ

ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਜੇਐਸਓਐਨ ਇੱਥੇ ਦਿਖਾਈ ਦੇਵੇਗਾ...

## JSON Formatter

### Introduction

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

JSON ਫਾਰਮੈਟਿੰਗ (ਜਿਸਨੂੰ "ਪ੍ਰੇਟੀ ਪ੍ਰਿੰਟਿੰਗ" ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਸਹੀ ਇੰਡੈਂਟੇਸ਼ਨ, ਲਾਈਨ ਬ੍ਰੇਕ ਅਤੇ ਖਾਲੀ ਥਾਵਾਂ ਨੂੰ ਜੋੜਦੀ ਹੈ ਤਾਂ ਕਿ JSON ਡਾਟਾ ਦੀ ਹਾਇਰਾਰਕੀਕਲ ਢਾਂਚਾ ਵਿਜ਼ੂਅਲੀ ਰੂਪ ਵਿੱਚ ਸਪਸ਼ਟ ਹੋ ਸਕੇ। ਇਹ ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਕੰਪਲੈਕਸ ਨੈਸਟਡ ਓਬਜੈਕਟਾਂ ਜਾਂ ਵੱਡੇ ਡਾਟਾਸੇਟਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋਏ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਤੱਤਾਂ ਦੇ ਵਿਚਕਾਰ ਦੇ ਰਿਸ਼ਤੇ ਨਹੀਂ ਦੇਖੇ ਜਾ ਸਕਦੇ।

ਸਾਡਾ JSON ਫਾਰਮੈਟਰ ਟੂਲ ਤੁਹਾਡੇ JSON ਡਾਟਾ ਨੂੰ ਸਹੀ ਇੰਡੈਂਟੇਸ਼ਨ ਅਤੇ ਢਾਂਚਾ ਨਾਲ ਸੁਧਾਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਮਨੁੱਖਾਂ ਲਈ ਪੜ੍ਹਨਯੋਗ ਹੋਣ ਦੇ ਨਾਲ-ਨਾਲ ਮਸ਼ੀਨਾਂ ਲਈ ਇਸਦੀ ਵੈਧਤਾ ਨੂੰ ਵੀ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ।

### JSON Syntax and Structure

JSON ਦੋ ਮੁੱਖ ਢਾਂਚਿਆਂ 'ਤੇ ਬਣਿਆ ਹੈ:

1. **ਓਬਜੈਕਟਸ**: ਨਾਂ/ਮੁੱਲ ਜੋੜਿਆਂ ਦਾ ਸੰਗ੍ਰਹਿ ਜੋ ਕੁਰਲੀ ਬ੍ਰੇਸ `{}` ਵਿੱਚ ਬੰਦ ਹੁੰਦਾ ਹੈ। ਹਰ ਨਾਂ ਦੇ ਨਾਲ ਇੱਕ ਕੋਲਨ `:` ਹੁੰਦਾ ਹੈ ਅਤੇ ਜੋੜੇ ਕਾਮਾ `,` ਨਾਲ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ।

json {"name": "John", "age": 30, "city": "New York"}


2. **ਐਰੇਸ**: ਮੁੱਲਾਂ ਦੀ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਜੋ ਕੋਣੀ ਬ੍ਰੇਕਟ `[]` ਵਿੱਚ ਬੰਦ ਹੁੰਦੀ ਹੈ। ਮੁੱਲ ਕਾਮਾ `,` ਨਾਲ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ।

json ["apple", "banana", "cherry"]


JSON ਮੁੱਲ ਹੋ ਸਕਦੇ ਹਨ:
- ਸਟਰਿੰਗਾਂ (ਡਬਲ ਕੋਟਸ ਵਿੱਚ): `"Hello World"`
- ਨੰਬਰ: `42` ਜਾਂ `3.14159`
- ਬੂਲੀਅਨ: `true` ਜਾਂ `false`
- ਨੱਲ: `null`
- ਓਬਜੈਕਟਸ: `{"key": "value"}`
- ਐਰੇਸ: `[1, 2, 3]`

ਸਹੀ JSON ਨੂੰ ਇਹ ਸਿੰਟੈਕਸ ਨਿਯਮਾਂ ਦਾ ਪਾਲਣ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:
- ਨਾਂ ਡਬਲ ਕੋਟਸ ਵਿੱਚ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ
- ਮੁੱਲਾਂ ਨੂੰ ਇੱਕ ਵੈਧ JSON ਡਾਟਾ ਕਿਸਮ ਵਿੱਚੋਂ ਇੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
- ਕੋਈ ਵੀ ਟ੍ਰੇਲਿੰਗ ਕਾਮਾ ਹੋਣਾ ਚਾਹੀਦਾ ਨਹੀਂ
- ਕੋਈ ਵੀ ਟਿੱਪਣੀਆਂ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੈ
- ਕੋਈ ਵੀ ਫੰਕਸ਼ਨ ਜਾਂ ਵਿਧੀਆਂ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੈ

ਆਮ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:
- ਬ੍ਰੈਕਟਾਂ/ਬ੍ਰੇਸਾਂ ਦੀ ਗੈਰਹਾਜ਼ਰੀ ਜਾਂ ਗਲਤ ਜੋੜ
- ਪ੍ਰਾਪਰਟੀ ਨਾਂ ਦੇ ਆਸ-ਪਾਸ ਕੋਟਸ ਦੀ ਗੈਰਹਾਜ਼ਰੀ
- ਪ੍ਰਾਪਰਟੀ ਨਾਂ ਲਈ ਸਿੰਗਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ
- ਟ੍ਰੇਲਿੰਗ ਕਾਮਾ ਸ਼ਾਮਲ ਕਰਨਾ
- ਮੁੱਲ ਦੇ ਤੌਰ 'ਤੇ ਅਣਪਰਿਚਿਤ ਦੀ ਵਰਤੋਂ

### How JSON Formatting Works

JSON ਫਾਰਮੈਟਿੰਗ ਸੰਕੁਚਿਤ, ਮਿਨਿਫਾਈਡ JSON ਨੂੰ ਪੜ੍ਹਨਯੋਗ ਰੂਪ ਵਿੱਚ ਬਦਲਦੀ ਹੈ:

1. **ਪਾਰਸਿੰਗ**: JSON ਸਟਰਿੰਗ ਪਹਿਲਾਂ ਵੈਧਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਪਾਰਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਡਾਟਾ ਢਾਂਚੇ ਦੀ ਇੱਕ ਮੈਮੋਰੀ ਵਿੱਚ ਪ੍ਰਤੀਨਿਧੀ ਬਣਾਈ ਜਾਂਦੀ ਹੈ।

2. **ਇੰਡੈਂਟੇਸ਼ਨ**: ਹਰ ਨੈਸਟਡ ਢਾਂਚੇ ਦੇ ਪੱਧਰ ਨੂੰ (ਆਮ ਤੌਰ 'ਤੇ 2 ਜਾਂ 4 ਖਾਲੀ ਥਾਵਾਂ ਦੁਆਰਾ) ਇੰਡੈਂਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕਿ ਹਾਇਰਾਰਕੀ ਨੂੰ ਵਿਜ਼ੂਅਲ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾ ਸਕੇ।

3. **ਲਾਈਨ ਬ੍ਰੇਕਸ**: ਹਰ ਪ੍ਰਾਪਰਟੀ ਜਾਂ ਐਰੇ ਤੱਤ ਦੇ ਬਾਅਦ ਨਵੇਂ ਲਾਈਨ ਜੋੜੇ ਜਾਂਦੇ ਹਨ ਤਾਂ ਕਿ ਪੜ੍ਹਨਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕੀਤਾ ਜਾ ਸਕੇ।

4. **ਖਾਲੀ ਥਾਵਾਂ**: ਕੋਲਨ ਅਤੇ ਕਾਮਾ ਦੇ ਆਸ-ਪਾਸ ਸਥਿਰ ਖਾਲੀ ਥਾਵਾਂ ਜੋੜੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਉਦਾਹਰਨ ਵਜੋਂ, ਇਹ ਮਿਨਿਫਾਈਡ JSON:

json {"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}


ਇਸ ਫਾਰਮੈਟ ਕੀਤੇ JSON ਵਿੱਚ ਬਦਲਦਾ ਹੈ:

json { "name": "John Doe", "age": 30, "address": { "street": "123 Main St", "city": "Anytown", "state": "CA" }, "hobbies": [ "reading", "hiking", "photography" ] }


ਸਾਡਾ ਫਾਰਮੈਟਰ ਪ੍ਰਤੀ ਪੱਧਰ 2 ਖਾਲੀ ਥਾਵਾਂ ਦੀ ਸਧਾਰਨ ਇੰਡੈਂਟੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਵਿਕਾਸਕ ਸਮੁਦਾਇ ਵਿੱਚ ਇੱਕ ਆਮ ਰਿਵਾਜ ਹੈ ਅਤੇ ਪੜ੍ਹਨਯੋਗਤਾ ਅਤੇ ਸੰਕੁਚਿਤਤਾ ਵਿਚ ਇੱਕ ਚੰਗਾ ਸੰਤੁਲਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

### JSON Validation

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

1. **ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ**:
   - ਗੈਰ-ਉਧਰਿਤ ਪ੍ਰਾਪਰਟੀ ਨਾਂ
   - ਗੈਰ-ਹਾਜ਼ਰ ਜਾਂ ਵੱਧ ਕਾਮੇ
   - ਗਲਤ ਨੈਸਟ ਕੀਤੇ ਢਾਂਚੇ
   - ਖੁਲੀ ਸਟਰਿੰਗਾਂ, ਓਬਜੈਕਟਾਂ ਜਾਂ ਐਰੇਆਂ

2. **ਡਾਟਾ ਕਿਸਮ ਦੀਆਂ ਗਲਤੀਆਂ**:
   - ਬਹੁਤ ਵੱਡੇ ਪੂਰਨਾਂ ਜਾਂ ਫਲੋਟਿੰਗ-ਪੋਇੰਟ ਮੁੱਲਾਂ ਲਈ ਗੈਰ-ਵੈਧ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ
   - ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਵਿਧੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ
   - ਸਟਰਿੰਗਾਂ ਲਈ ਸਿੰਗਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ

ਜਦੋਂ ਤੁਸੀਂ ਗੈਰ-ਵੈਧ JSON ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਗਲਤੀ ਦਾ ਸੁਨੇਹਾ ਸਮੱਸਿਆ ਪਛਾਣਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਜ਼ਿਆਦਾਤਰ JSON ਪਾਰਸਰ ਇਹ ਦਰਸਾਉਣਗੇ ਕਿ ਪਾਰਸਿੰਗ ਕਿੱਥੇ ਫੇਲ ਹੋਈ, ਜੋ ਸਮੱਸਿਆ ਨੂੰ ਲੋਕੇਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੀ ਹੈ। ਸਾਡਾ ਟੂਲ ਤੁਹਾਨੂੰ ਆਪਣੇ JSON ਡਾਟਾ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਪਛਾਣਨ ਅਤੇ ਠੀਕ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ ਸਾਫ਼ ਗਲਤੀ ਦੇ ਸੁਨੇਹੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

### Use Cases

JSON ਫਾਰਮੈਟਿੰਗ ਕਈ ਸਥਿਤੀਆਂ ਵਿੱਚ ਕੀਮਤੀ ਹੈ:

#### API Development and Testing

ਜਦੋਂ RESTful APIs ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ JSON ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ:
- ਜਵਾਬ ਪੇਲੋਡ ਦੀ ਜਾਂਚ
- ਬੇਨਤੀ ਦੇ ਸਰੀਰ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ
- API ਉਦਾਹਰਣਾਂ ਦਾ ਦਸਤਾਵੇਜ਼ ਬਣਾਉਣਾ
- ਡਾਟਾ ਢਾਂਚਿਆਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨਾ

#### Configuration Management

ਬਹੁਤ ਸਾਰੇ ਆਧੁਨਿਕ ਐਪਲੀਕੇਸ਼ਨ JSON ਨੂੰ ਸੰਰਚਨਾ ਲਈ ਵਰਤਦੇ ਹਨ:
- ਐਪਲੀਕੇਸ਼ਨ ਸੈਟਿੰਗ ਫਾਈਲਾਂ
- ਵਾਤਾਵਰਨ ਸੰਰਚਨਾਵਾਂ
- ਬਿਲਡ ਅਤੇ ਡਿਪਲੋਇਮੈਂਟ ਵਿਸ਼ੇਸ਼ਣ
- ਇੰਫਰਾਸਟਰਕਚਰ ਐਜ਼ ਕੋਡ ਟੈਂਪਲੇਟ (ਜਿਵੇਂ ਕਿ AWS CloudFormation, Terraform)

#### Data Analysis and Visualization

ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ JSON ਤੁਹਾਡੇ ਲਈ ਮਦਦਗਾਰ ਹੈ ਜਦੋਂ:
- ਡਾਟਾਸੇਟਾਂ ਦੀ ਖੋਜ ਕਰਨਾ
- ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ ਡਾਟਾ ਤਿਆਰ ਕਰਨਾ
- ਡਾਟਾ ਸਕੀਮਾਂ ਨੂੰ ਸਮਝਣਾ
- ਢਾਂਚਿਤ ਡਾਟਾ ਵਿੱਚ ਪੈਟਰਨ ਪਛਾਣਨਾ

#### Debugging and Troubleshooting

ਸਹੀ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ JSON ਜਰੂਰੀ ਹੈ ਜਦੋਂ:
- ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ
- localStorage ਜਾਂ sessionStorage ਦੀ ਜਾਂਚ ਕਰਨਾ
- ਨੈਟਵਰਕ ਜਵਾਬਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ
- ਡਾਟਾ ਇੰਟੇਗਰੇਸ਼ਨ ਸਮੱਸਿਆਵਾਂ ਦਾ ਡੀਬੱਗ ਕਰਨਾ

#### Educational Purposes

ਸਾਫ਼ JSON ਫਾਰਮੈਟਿੰਗ ਸਿੱਖਣ ਲਈ ਕੀਮਤੀ ਹੈ:
- ਡਾਟਾ ਢਾਂਚਿਆਂ ਦੀ ਸਿੱਖਿਆ
- ਨੈਸਟਡ ਰਿਸ਼ਤਿਆਂ ਨੂੰ ਦਰਸਾਉਣਾ
- API ਸੰਕਲਪਾਂ ਨੂੰ ਸਮਝਾਉਣਾ
- ਡਾਟਾ ਮਾਡਲਿੰਗ ਦੇ ਸਿਧਾਂਤਾਂ ਨੂੰ ਦਰਸਾਉਣਾ

### Alternatives

ਜਦੋਂ ਕਿ ਸਾਡਾ ਵੈੱਬ-ਅਧਾਰਿਤ JSON ਫਾਰਮੈਟਰ ਤੇਜ਼ ਫਾਰਮੈਟਿੰਗ ਕਾਰਜਾਂ ਲਈ ਸੁਵਿਧਾਜਨਕ ਹੈ, ਕਈ ਵਿਕਲਪ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਲਈ ਮੌਜੂਦ ਹਨ:

#### Browser Developer Tools

ਆਧੁਨਿਕ ਬ੍ਰਾਊਜ਼ਰ JSON ਫਾਰਮੈਟਿੰਗ ਦੀ ਸਮਰੱਥਾ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ:
- Chrome ਅਤੇ Edge DevTools ਨੈੱਟਵਰਕ ਟੈਬ ਵਿੱਚ JSON ਜਵਾਬਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਫਾਰਮੈਟ ਕਰਦੇ ਹਨ
- Firefox ਦਾ JSON ਵਿਊਅਰ ਇੱਕ ਇੰਟਰੈਕਟਿਵ ਟ੍ਰੀ ਵਿਊ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ
- ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਐਕਸਟੈਂਸ਼ਨ ਜਿਵੇਂ JSONView JSON ਨੂੰ ਸਿੱਧਾ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰ ਸਕਦੇ ਹਨ

#### Code Editors and IDEs

ਜ਼ਿਆਦਾਤਰ ਵਿਕਾਸ ਦੇ ਮਾਹੌਲ JSON ਫਾਰਮੈਟਿੰਗ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ:
- Visual Studio Code ਵਿੱਚ ਬਿਲਟ-ਇਨ JSON ਫਾਰਮੈਟਿੰਗ ਹੈ (Alt+Shift+F)
- JetBrains IDEs (WebStorm, IntelliJ) ਸ਼ਕਤੀਸ਼ਾਲੀ JSON ਟੂਲ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ
- Sublime Text ਅਤੇ Atom ਪਲੱਗਇਨ ਦੁਆਰਾ JSON ਫਾਰਮੈਟਿੰਗ ਨੂੰ ਸਮਰਥਨ ਕਰਦੇ ਹਨ

#### Command Line Tools

ਟਰਮੀਨਲ ਉਪਭੋਗੀਆਂ ਜਾਂ ਆਟੋਮੈਸ਼ਨ ਲਈ:
- `jq` ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਕਮਾਂਡ-ਲਾਈਨ JSON ਪ੍ਰੋਸੈਸਰ ਹੈ
- `json_pp` ਬਹੁਤ ਸਾਰੇ ਯੂਨੀਕਸ ਸਿਸਟਮਾਂ 'ਤੇ ਪਹਿਲਾਂ ਤੋਂ ਇੰਸਟਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ
- `python -m json.tool` ਪਾਇਥਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੇਜ਼ ਫਾਰਮੈਟਿੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ

#### Programmatic Approaches

ਜਦੋਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਅੰਦਰ JSON ਫਾਰਮੈਟਿੰਗ:

javascript // JavaScript const formatted = JSON.stringify(jsonObject, null, 2);

python

Python

import json formatted = json.dumps(json_object, indent=2)

java // Java with Gson Gson gson = new GsonBuilder().setPrettyPrinting().create(); String formatted = gson.toJson(jsonObject);

ruby

Ruby

require 'json' formatted = JSON.pretty_generate(json_object)

php // PHP formatted=jsonencode(formatted = json_encode(jsonObject, JSON_PRETTY_PRINT);


### History

JSON ਨੂੰ ਡਗਲਸ ਕ੍ਰੋਕਫੋਰਡ ਦੁਆਰਾ 2000 ਦੇ ਆਰੰਭ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਸੀ, ਜੋ XML ਦਾ ਇੱਕ ਹਲਕਾ ਵਿਕਲਪ ਹੈ। ਇਹ ਫਾਰਮੈਟ ਜਾਵਾਸਕ੍ਰਿਪਟ ਓਬਜੈਕਟ ਲਿਟਰਲ ਸਿੰਟੈਕਸ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ ਪਰ ਭਾਸ਼ਾ-ਗੈਰ-ਨਿਰਭਰ ਬਣਾਉਣ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਗਿਆ ਸੀ। 2006 ਵਿੱਚ, JSON ਨੂੰ RFC 4627 ਵਿੱਚ ਵਿਸ਼ੇਸ਼ਤ ਕੀਤਾ ਗਿਆ, ਅਤੇ ਇਸ ਨੇ ਆਪਣੀ ਸਾਦਗੀ ਅਤੇ ਜਾਵਾਸਕ੍ਰਿਪਟ ਨਾਲ ਸਹਿਯੋਗ ਦੇ ਕਾਰਨ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰਸਿੱਧੀ ਹਾਸਲ ਕੀਤੀ।

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

JSON ਦੀ ਅਪਣਾਈ 2000 ਦੇ ਦਹਾਕੇ ਵਿੱਚ AJAX ਅਤੇ RESTful APIs ਦੇ ਉੱਥੇ ਤੇਜ਼ੀ ਨਾਲ ਹੋਈ। 2010 ਦੇ ਦਹਾਕੇ ਵਿੱਚ, ਇਹ ਵੈੱਬ APIs, ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਅਤੇ MongoDB ਅਤੇ CouchDB ਵਰਗੇ NoSQL ਡਾਟਾਬੇਸਾਂ ਵਿੱਚ ਡਾਟਾ ਸਟੋਰੇਜ ਲਈ ਡਿਫੈਕਟੋ ਮਿਆਰ ਬਣ ਗਿਆ।

ਅੱਜ, JSON ਲਗਭਗ ਹਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੁਆਰਾ ਸਮਰਥਿਤ ਹੈ ਅਤੇ ਵੈੱਬ 'ਤੇ ਬੇਅੰਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਦੀ ਸਾਦਗੀ, ਲਚਕਦਾਰਤਾ, ਅਤੇ ਯੂਨੀਵਰਸਲ ਸਮਰਥਨ ਨੇ ਇਸਨੂੰ ਆਧੁਨਿਕ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਡਾਟਾ ਫਾਰਮੈਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਣਾਇਆ ਹੈ।

### Code Examples

ਇੱਥੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ JSON ਫਾਰਮੈਟ ਕਰਨ ਦੇ ਉਦਾਹਰਨ ਹਨ:

javascript // JavaScript JSON formatting function formatJSON(jsonString) { try { const parsedData = JSON.parse(jsonString); return JSON.stringify(parsedData, null, 2); } catch (error) { return Error: ${error.message}; } }

// Example usage const rawJSON = '{"name":"John","age":30,"city":"New York"}'; console.log(formatJSON(rawJSON));

python

Python JSON formatting

import json

def format_json(json_string): try: parsed_data = json.loads(json_string) return json.dumps(parsed_data, indent=2) except json.JSONDecodeError as e: return f"Error: {str(e)}"

Example usage

raw_json = '{"name":"John","age":30,"city":"New York"}' print(format_json(raw_json))

java // Java JSON formatting with Gson import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonSyntaxException;

public class JSONFormatter { public static String formatJSON(String jsonString) { try { Gson gson = new GsonBuilder().setPrettyPrinting().create(); Object parsedJson = gson.fromJson(jsonString, Object.class); return gson.toJson(parsedJson); } catch (JsonSyntaxException e) { return "Error: " + e.getMessage(); } }

public static void main(String[] args) {
    String rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
    System.out.println(formatJSON(rawJSON));
}

}

php // PHP JSON formatting function formatJSON(jsonString) { result = json_decode(jsonString);if(jsonlasterror()!==JSONERRORNONE)return"Error:".jsonlasterrormsg();returnjsonencode(jsonString); if (json_last_error() !== JSON_ERROR_NONE) { return "Error: " . json_last_error_msg(); } return json_encode(result, JSON_PRETTY_PRINT); }

// Example usage rawJSON=′"name":"John","age":30,"city":"NewYork"′;echoformatJSON(rawJSON = '{"name":"John","age":30,"city":"New York"}'; echo formatJSON(rawJSON);

ruby

Ruby JSON formatting

require 'json'

def format_json(json_string) begin parsed_data = JSON.parse(json_string) return JSON.pretty_generate(parsed_data) rescue JSON::ParserError => e return "Error: #{e.message}" end end

Example usage

raw_json = '{"name":"John","age":30,"city":"New York"}' puts format_json(raw_json)

csharp // C# JSON formatting with Newtonsoft.Json using Newtonsoft.Json; using System;

class JSONFormatter { public static string FormatJSON(string jsonString) { try { object parsedJson = JsonConvert.DeserializeObject(jsonString); return JsonConvert.SerializeObject(parsedJson, Formatting.Indented); } catch (JsonException e) { return $"Error: {e.Message}"; } }

static void Main()
{
    string rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
    Console.WriteLine(FormatJSON(rawJSON));
}

}

go // Go JSON formatting package main

import ( "encoding/json" "fmt" )

func formatJSON(jsonString string) string { var parsedData interface{} err := json.Unmarshal([]byte(jsonString), &parsedData) if err != nil { return fmt.Sprintf("Error: %s", err.Error()) }

formattedBytes, err := json.MarshalIndent(parsedData, "", "  ")
if err != nil {
    return fmt.Sprintf("Error: %s", err.Error())
}

return string(formattedBytes)

}

func main() { rawJSON := {"name":"John","age":30,"city":"New York"} fmt.Println(formatJSON(rawJSON)) }


### Edge Cases and Considerations

ਜਦੋਂ JSON ਫਾਰਮੈਟਿੰਗ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹਨਾਂ ਸੰਭਾਵਿਤ ਚੁਣੌਤੀਆਂ ਦੀ ਜਾਣਕਾਰੀ ਰੱਖੋ:

#### Large JSON Files

ਬਹੁਤ ਵੱਡੇ JSON ਫਾਈਲਾਂ (ਕਈ ਮੇਗਾਬਾਈਟ ਜਾਂ ਇਸ ਤੋਂ ਵੱਧ) ਬ੍ਰਾਊਜ਼ਰ-ਅਧਾਰਿਤ ਫਾਰਮੈਟਰਾਂ ਵਿੱਚ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਸਮੱਸਿਆ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹਨ। ਐਸੇ ਮਾਮਲਿਆਂ ਵਿੱਚ:
- ਕਮਾਂਡ-ਲਾਈਨ ਟੂਲਾਂ ਜਿਵੇਂ `jq` ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸੋਚੋ
- JSON ਨੂੰ ਛੋਟੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡੋ
- ਸਮੂਹਿਕ ਪਾਰਸਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਤਾਂ ਜੋ ਪੂਰੀ ਫਾਈਲ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨ ਤੋਂ ਬਿਨਾਂ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾ ਸਕੇ

#### Deeply Nested Structures

ਬਹੁਤ ਹੀ ਨੈਸਟਡ JSON (10-20 ਪੱਧਰਾਂ ਤੋਂ ਵੱਧ) ਫਾਰਮੈਟ ਕੀਤੇ ਜਾਣ 'ਤੇ ਵੀ ਪੜ੍ਹਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ। ਐਸੇ ਮਾਮਲਿਆਂ ਵਿੱਚ:
- ਜੇ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਢਾਂਚੇ ਨੂੰ ਸਮਤਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ
- ਢਾਂਚੇਦਾਰ JSON ਦੇ ਦਰਸ਼ਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ
- JSON ਦੇ ਖਾਸ ਹਿੱਸਿਆਂ ਨਾਲ ਕੰਮ ਕਰੋ

#### Special Characters and Unicode

JSON ਯੂਨੀਕੋਡ ਨੂੰ ਸਮਰਥਿਤ ਕਰਦਾ ਹੈ, ਪਰ ਕੁਝ ਫਾਰਮੈਟਰਾਂ ਕੁਝ ਅੱਖਰਾਂ ਨਾਲ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰ ਸਕਦੇ ਹਨ:
- ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡਾ ਫਾਰਮੈਟਰ ਇਮੋਜੀ ਅਤੇ ਹੋਰ ਯੂਨੀਕੋਡ ਅੱਖਰਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ
- ਕੰਟਰੋਲ ਅੱਖਰਾਂ ਅਤੇ ਭੱਜਣ ਵਾਲੀਆਂ ਲਕੀਰਾਂ ਨਾਲ ਸਾਵਧਾਨ ਰਹੋ
- ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਨਿਕਾਸ ਸਾਰੇ ਮੂਲ ਅੱਖਰਾਂ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ

#### Numeric Precision

JSON ਨੰਬਰਾਂ ਲਈ ਸਟੀਕਤਾ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰਦਾ, ਜੋ ਬਹੁਤ ਵੱਡੇ ਪੂਰਨਾਂ ਜਾਂ ਫਲੋਟਿੰਗ-ਪੋਇੰਟ ਮੁੱਲਾਂ ਨਾਲ ਸਮੱਸਿਆ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ:
- ਯਾਦ ਰੱਖੋ ਕਿ ਕੁਝ ਜਾਵਾਸਕ੍ਰਿਪਟ ਦੇ ਕਾਰਜਕਾਰੀ 53 ਬਿੱਟਾਂ ਤੋਂ ਵੱਧ ਪੂਰਨਾਂ ਲਈ ਸਟੀਕਤਾ ਗੁਆ ਸਕਦੇ ਹਨ
- ਸਟੀਕ ਨੰਬਰਾਂ ਲਈ ਸਟਰਿੰਗ ਪ੍ਰਤੀਨਿਧੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸੋਚੋ
- ਜੇ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਉੱਚ ਸਟੀਕਤਾ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਅਤਿਅਤਿ ਮੁੱਲਾਂ ਨਾਲ ਟੈਸਟ ਕਰੋ

#### Empty Objects and Arrays

ਵੈਧ JSON ਵਿੱਚ ਖਾਲੀ ਓਬਜੈਕਟ `{}` ਅਤੇ ਐਰੇ `[]` ਸ਼ਾਮਲ ਹਨ, ਜੋ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ:
- ਖਾਲੀ ਓਬਜੈਕਟ `{}` ਦੇ ਤੌਰ 'ਤੇ ਦਿਖਾਈ ਦੇਣੇ ਚਾਹੀਦੇ ਹਨ
- ਖਾਲੀ ਐਰੇ `[]` ਦੇ ਤੌਰ 'ਤੇ ਦਿਖਾਈ ਦੇਣੇ ਚਾਹੀਦੇ ਹਨ
- ਨੈਸਟਡ ਖਾਲੀ ਢਾਂਚੇ ਨੂੰ ਸਹੀ ਇੰਡੈਂਟੇਸ਼ਨ ਬਣਾਈ ਰੱਖਣੀ ਚਾਹੀਦੀ ਹੈ

### References

1. [JSON.org](https://www.json.org/) - ਅਧਿਕਾਰਕ JSON ਵਿਸ਼ੇਸ਼ਤਾ ਵੈਬਸਾਈਟ
2. [RFC 8259](https://tools.ietf.org/html/rfc8259) - JSON ਡਾਟਾ ਬਦਲਣ ਦਾ ਫਾਰਮੈਟ
3. [MDN Web Docs: JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON) - ਜਾਵਾਸਕ੍ਰਿਪਟ ਵਿੱਚ JSON ਬਾਰੇ ਵਿਸ਼ਤ੍ਰਿਤ ਦਸਤਾਵੇਜ਼
4. [JSON Lint](https://jsonlint.com/) - ਇੱਕ ਪ੍ਰਸਿੱਧ ਆਨਲਾਈਨ JSON ਵੈਧਤਾ ਕਰਨ ਵਾਲਾ ਟੂਲ
5. [jq](https://stedolan.github.io/jq/) - ਇੱਕ ਹਲਕਾ ਅਤੇ ਲਚਕੀਲਾ ਕਮਾਂਡ-ਲਾਈਨ JSON ਪ੍ਰੋਸੈਸਰ

ਸੰਬੰਧਿਤ ਸੰਦ

ਸਮਾਂ ਇਕਾਈ ਪਰਿਵਰਤਕ: ਸਾਲ, ਦਿਨ, ਘੰਟੇ, ਮਿੰਟ, ਸਕਿੰਟ
ਬੇਸ64 ਕੋਡਰ ਅਤੇ ਡੀਕੋਡਰ: ਟੈਕਸਟ ਨੂੰ ਬੇਸ64 ਵਿੱਚ ਬਦਲੋ ਜਾਂ ਬੇਸ64 ਨੂੰ ਟੈਕਸਟ ਵਿੱਚ
ਟੈਕਸਟ ਇਨਵਰਟਰ ਟੂਲ: ਕਿਸੇ ਵੀ ਸਟਰਿੰਗ ਵਿੱਚ ਅੱਖਰਾਂ ਦਾ ਕ੍ਰਮ ਉਲਟੋ
ਯੂਨਿਕਸ ਟਾਈਮਸਟੈਂਪ ਤੋਂ ਤਾਰੀਖ਼ ਕਨਵਰਟਰ: 12/24 ਘੰਟੇ ਫਾਰਮੈਟ ਸਹਾਇਤਾ
ਕਵਾਡ੍ਰੈਟਿਕ ਸਮੀਕਰਨ ਹੱਲ ਕਰਨ ਵਾਲਾ: ax² + bx + c = 0 ਦੇ ਮੂਲ ਲੱਭੋ
ਰੈਂਡਮ ਏਪੀ ਆਈ ਕੀ ਜਨਰੇਟਰ: ਸੁਰੱਖਿਅਤ 32-ਅੱਖਰ ਵਾਲੇ ਸਟਰਿੰਗ ਬਣਾਓ
Feedback