ನಿಖರವಾದ ಇಂದೆಂಟೇಶನ್‌ೊಂದಿಗೆ ನಿಮ್ಮ ಜೆಎಸ್‌ಒಎನ್ ಡೇಟಾವನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮತ್ತು ಸುಂದರೀಕರಿಸಿ. ಕಚ್ಚಾ ಜೆಎಸ್‌ಒಎನ್ ಅನ್ನು ಓದಲು ಸುಲಭವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಂಕೇತ ಹೈಲೈಟಿಂಗ್ ಮತ್ತು ಪ್ರಮಾಣೀಕರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಈ ಸರಳ ಸಾಧನವನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಜೇಸನ್ ಅನ್ನು ಫಾರ್ಮಾಟ್ ಮತ್ತು ಸುಂದರಗೊಳಿಸಿ
ಫಾರ್ಮಾಟ್ ಮಾಡಿದ ಜೇಸನ್ ಇಲ್ಲಿ ಕಾಣುತ್ತದೆ...
JSON (JavaScript Object Notation) ಒಂದು ಹಗುರವಾದ ಡೇಟಾ ವಿನಿಮಯ ರೂಪವಾಗಿದೆ ಮತ್ತು ಇದು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಡೇಟಾ ವಿನಿಮಯದ ಪ್ರಮಾಣವಂತವಾಗಿದೆ. ಇದರ ಸರಳತೆಯ ವಿರುದ್ಧ, JSON ಡೇಟಾ ಕಡಿಮೆ ಅಥವಾ ಸೂಕ್ತವಾದ ರೂಪವಿಲ್ಲದಾಗ ಓದಲು ಕಷ್ಟವಾಗಬಹುದು. ಈ ಸಾಧನವು ಕಚ್ಚಾ, ಅಸಂರಚಿತ JSON ಶ್ರೇಣಿಗಳನ್ನು ಉತ್ತಮವಾಗಿ ರಚಿತ, ಅಂತರವಿಲ್ಲದ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ಓದಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು ಹೆಚ್ಚು ಸುಲಭವಾಗಿದೆ.
JSON ರೂಪಾಂತರ (ಅಥವಾ "ಸುಂದರ ಮುದ್ರಣ") ಪ್ರತಿ ಹಂತದ ಶ್ರೇಣಿಯ ರಚನೆಯನ್ನು ದೃಶ್ಯವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಲು ಸಮಾನಾಂತರವಾದ ಅಂತರ, ಸಾಲುಗಳನ್ನು ಮುರಿಯುವುದು ಮತ್ತು ಸ್ಥಳವನ್ನು ಸೇರಿಸುತ್ತದೆ. ಇದು ಸಂಕೀರ್ಣ ನೆಟ್ಟಗೊಳಿಸಿದ ವಸ್ತುಗಳು ಅಥವಾ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಕೆಲಸ ಮಾಡುವಾಗ ವಿಶೇಷವಾಗಿ ಮೌಲ್ಯವಂತವಾಗಿದೆ, ಅಲ್ಲಿ ಅಂಶಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ಇತರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಷ್ಟವಾಗಬಹುದು.
ನಮ್ಮ JSON ರೂಪಾಂತರ ಸಾಧನವು ನಿಮ್ಮ JSON ಡೇಟಾವನ್ನು ಸರಿಯಾದ ಅಂತರ ಮತ್ತು ರಚನೆಯೊಂದಿಗೆ ಸುಂದರಗೊಳಿಸಲು ಸರಳ ಇಂಟರ್ಫೇಸನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಯಂತ್ರಗಳಿಗೆ ಅದರ ಮಾನ್ಯತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳುವಾಗ ಮಾನವರಿಗೆ ಹೆಚ್ಚು ಓದಲು ಸುಲಭವಾಗಿದೆ.
JSON ಎರಡು ಪ್ರಮುಖ ರಚನೆಗಳನ್ನು ಆಧಾರಿತವಾಗಿದೆ:
{} ಕೂರಿ ಬಟ್ಟೆಯೊಳಗೆ ಹೆಸರಿನ/ಮೌಲ್ಯ ಜೋಡಿಗಳ ಸಂಕಲನಗಳು. ಪ್ರತಿ ಹೆಸರಿನ ನಂತರ : ಕೊಲನ್ ಮತ್ತು ಜೋಡಿಗಳು , ಮೂಲಕ ವಿಭಜಿತವಾಗಿರುತ್ತವೆ.1 {"name": "ಜಾನ್", "age": 30, "city": "ನ್ಯೂಯಾರ್ಕ್"}
2 [] ಕೂರಿ ಬಟ್ಟೆಯೊಳಗೆ ಮೌಲ್ಯಗಳ ಆದೇಶಿತ ಪಟ್ಟಿಗಳು. ಮೌಲ್ಯಗಳು , ಮೂಲಕ ವಿಭಜಿತವಾಗಿರುತ್ತವೆ.1 ["ಆಪಲ್", "ಬಾಳೆಹಣ್ಣು", "ಚೆರ್ರಿ"]
2 JSON ಮೌಲ್ಯಗಳು ಇರಬಹುದು:
"ಹಲೋ ವರ್ಲ್ಡ್"42 ಅಥವಾ 3.14159true ಅಥವಾ falsenull{"key": "value"}[1, 2, 3]ಸರಿಯಾದ JSON ಈ ವ್ಯಾಕರಣ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸಬೇಕು:
ಸಾಮಾನ್ಯ ವ್ಯಾಕರಣ ದೋಷಗಳು ಒಳಗೊಂಡಿವೆ:
JSON ರೂಪಾಂತರವು ಸಂಕೀರ್ಣ, ಸೂಕ್ಷ್ಮ JSON ಅನ್ನು ಓದಲು ಸುಲಭವಾದ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ:
ಪಾರ್ಸಿಂಗ್: JSON ಶ್ರೇಣಿಯನ್ನು ಮೊದಲು ಮಾನ್ಯ ಎಂದು ಖಚಿತಪಡಿಸಲು ಮತ್ತು ಡೇಟಾ ರಚನೆಯ ಮೆಮೊರಿ ಪ್ರತಿನಿಧಿಯನ್ನು ಸೃಷ್ಟಿಸಲು ಪಾರ್ಸ್ ಮಾಡಲಾಗುತ್ತದೆ.
ಅಂತರ: ವಸ್ತುಗಳು ಮತ್ತು ಅರೆಗಳ ಪ್ರತಿ ನೆಟ್ಟಗೊಳಿಸುವ ಹಂತವನ್ನು (ಸಾಮಾನ್ಯವಾಗಿ 2 ಅಥವಾ 4 ಸ್ಥಳಗಳಿಂದ) ದೃಶ್ಯವಾಗಿ ಪ್ರತಿನಿಧಿಸಲು ಅಂತರವನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ.
ಸಾಲು ಮುರಿಯುವುದು: ಪ್ರತಿ ಆಸ್ತಿ ಅಥವಾ ಅರೆ ಅಂಶದ ನಂತರ ಹೊಸ ಸಾಲುಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ.
ಸ್ಥಾನ: ಕೊಲನ್ ಮತ್ತು ಕೊಮಾ ಸುತ್ತಲೂ ಸಮಾನಾಂತರವಾದ ಸ್ಥಳವನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ಈ ಕಡಿಮೆ JSON:
1{"name":"ಜಾನ್ ಡೋ","age":30,"address":{"street":"123 ಮೆನ್ ಸ್ಟ್","city":"ಅನ್ಯಟೌನ್","state":"CA"},"hobbies":["ಓದು","ಹೈಕಿಂಗ್","ಫೋಟೋಗ್ರಫಿ"]}
2ಈ ರೂಪಾಂತರಿತ JSON ಆಗುತ್ತದೆ:
1{
2 "name": "ಜಾನ್ ಡೋ",
3 "age": 30,
4 "address": {
5 "street": "123 ಮೆನ್ ಸ್ಟ್",
6 "city": "ಅನ್ಯಟೌನ್",
7 "state": "CA"
8 },
9 "hobbies": [
10 "ಓದು",
11 "ಹೈಕಿಂಗ್",
12 "ಫೋಟೋಗ್ರಫಿ"
13 ]
14}
15ನಮ್ಮ ರೂಪಾಂತರವು 2 ಸ್ಥಳಗಳ ಪ್ರಮಾಣಿತ ಅಂತರವನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಅಭಿವೃದ್ಧಿ ಸಮುದಾಯದಲ್ಲಿ ಸಾಮಾನ್ಯ ಪರಂಪರೆ ಮತ್ತು ಓದುಗರ ಮತ್ತು ಬರಹಗಾರರ ನಡುವಿನ ಉತ್ತಮ ಸಮತೋಲನವನ್ನು ಒದಗಿಸುತ್ತದೆ.
JSON ರೂಪಾಂತರದ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಮಾನ್ಯತೆ. JSON ಅನ್ನು ರೂಪಾಂತರಿಸಲು ಮೊದಲು, ಅದು JSON ನಿರ್ದಿಷ್ಟತೆಗೆ ಅನುಗುಣವಾಗಿ ವ್ಯಾಕರಣಾತ್ಮಕವಾಗಿ ಮಾನ್ಯವಾಗಿರಬೇಕು. ಸಾಮಾನ್ಯ ಮಾನ್ಯತೆ ದೋಷಗಳು ಒಳಗೊಂಡಿವೆ:
ವ್ಯಾಕರಣ ದೋಷಗಳು:
ಡೇಟಾ ಪ್ರಕಾರದ ದೋಷಗಳು:
undefined ಅಥವಾ NaNಂತಹ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್-ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುವುದುನೀವು ಅಮಾನತುಗೊಂಡ JSON ಅನ್ನು ಎದುರಿಸಿದಾಗ, ದೋಷ ಸಂದೇಶವು ಸಮಸ್ಯೆಯನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು. ಹೆಚ್ಚಿನ JSON ಪಾರ್ಸರ್‌ಗಳು ಪಾರ್ಸಿಂಗ್ ವಿಫಲವಾದ ಸ್ಥಳವನ್ನು ಸೂಚಿಸುತ್ತವೆ, ಇದು ಸಮಸ್ಯೆಯನ್ನು ಸ್ಥಳಾಂತರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಮ್ಮ ಸಾಧನವು ನಿಮ್ಮ JSON ಡೇಟಾದಲ್ಲಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ಸಹಾಯ ಮಾಡಲು ಸ್ಪಷ್ಟ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
JSON ರೂಪಾಂತರವು ಹಲವಾರು ದೃಶ್ಯಗಳಲ್ಲಿ ಅಮೂಲ್ಯವಾಗಿದೆ:
RESTful APIಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ರೂಪಾಂತರಿತ JSON ಓದಲು ಸುಲಭವಾಗುತ್ತದೆ:
ಬಹಳಷ್ಟು ಆಧುನಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು JSON ಅನ್ನು ಕಾನ್ಫಿಗರೇಶನ್‌ಗಾಗಿ ಬಳಸುತ್ತವೆ:
ರೂಪಾಂತರಿತ JSON ಸಹಾಯ ಮಾಡುತ್ತದೆ:
ಸರಿಯಾಗಿ ರೂಪಾಂತರಿತ JSON ಡಿಬಗಿಂಗ್ ಮಾಡುವಾಗ ಅಗತ್ಯವಿದೆ:
ಸ್ಪಷ್ಟ JSON ರೂಪಾಂತರವು ಅಮೂಲ್ಯವಾಗಿದೆ:
ನಮ್ಮ ವೆಬ್ ಆಧಾರಿತ JSON ರೂಪಾಂತರವು ತ್ವರಿತ ರೂಪಾಂತರ ಕಾರ್ಯಗಳಿಗೆ ಅನುಕೂಲಕರವಾಗಿದೆ, ಆದರೆ ವಿಭಿನ್ನ ದೃಶ್ಯಗಳಿಗೆ ಹಲವಾರು ಪರ್ಯಾಯಗಳು ಇವೆ:
ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ JSON ರೂಪಾಂತರ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿವೆ:
ಬಹಳಷ್ಟು ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳು JSON ರೂಪಾಂತರವನ್ನು ಒದಗಿಸುತ್ತವೆ:
ಟರ್ಮಿನಲ್ ಬಳಕೆದಾರರು ಅಥವಾ ಸ್ವಯಂಚಾಲಿತತೆಗೆ:
jq ಒಂದು ಶಕ್ತಿಶಾಲಿ ಕಮಾಂಡ್-ಲೈನ್ JSON ಪ್ರಕ್ರಿಯಕವಾಗಿದೆjson_pp ಅನೇಕ ಯುನಿಕ್ಸ್ ವ್ಯವಸ್ಥೆಗಳ ಮೇಲೆ ಪೂರ್ವ-ಸ್ಥಾಪಿತವಾಗಿದೆpython -m json.tool ಪೈಥಾನ್ ಬಳಸಿಕೊಂಡು ತ್ವರಿತ ರೂಪಾಂತರವನ್ನು ಒದಗಿಸುತ್ತದೆಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ JSON ಅನ್ನು ರೂಪಾಂತರಿಸುವಾಗ:
1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
2const formatted = JSON.stringify(jsonObject, null, 2);
31# ಪೈಥಾನ್
2import json
3formatted = json.dumps(json_object, indent=2)
41// ಜಾವಾ ಗ್ಸಾನ್
2Gson gson = new GsonBuilder().setPrettyPrinting().create();
3String formatted = gson.toJson(jsonObject);
41# ರೂಬಿ
2require 'json'
3formatted = JSON.pretty_generate(json_object)
41// PHP
2$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);
3JSON ಅನ್ನು 2000ರ ದಶಕದ ಆರಂಭದಲ್ಲಿ ಡಗ್ಲಸ್ ಕ್ರಾಕ್‌ಫೋರ್ಡ್ ರಚಿಸಿದರು, ಇದು XML ಗೆ ಹಗುರವಾದ ಪರ್ಯಾಯವಾಗಿದೆ. ಈ ರೂಪವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತು ಲಿಟರಲ್ ವ್ಯಾಕರಣದಿಂದ ಉಲ್ಲೇಖಿತವಾಗಿದೆ ಆದರೆ ಭಾಷಾ-ಸ್ವಾಯತ್ತವಾಗಿರಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. 2006ರಲ್ಲಿ JSON ಅನ್ನು RFC 4627ರಲ್ಲಿ ಅಧಿಕೃತವಾಗಿ ನಿರ್ದಿಷ್ಟಗೊಳಿಸಲಾಯಿತು ಮತ್ತು ಇದು ಅದರ ಸರಳತೆ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯಿಂದಾಗಿ ವೇಗವಾಗಿ ಜನಪ್ರಿಯತೆಯನ್ನು ಪಡೆದಿತು.
JSON ಮೊದಲು, XML ಡೇಟಾ ವಿನಿಮಯದ ಪ್ರಮುಖ ರೂಪವಾಗಿತ್ತು, ಆದರೆ ಅದರ ದಪ್ಪತನ ಮತ್ತು ಸಂಕೀರ್ಣತೆಯು ಹಲವಾರು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಕಷ್ಟಕರವಾಗಿತ್ತು. JSON ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ವ್ಯಾಕರಣವನ್ನು ಒದಗಿಸುತ್ತಿತ್ತು, ಇದು ಓದಲು ಮತ್ತು ಬರೆಯಲು ಸುಲಭವಾಗಿತ್ತು, ಮಾನವರಿಗೂ ಮತ್ತು ಯಂತ್ರಗಳಿಗೆ. ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ವಸ್ತು ಮಾದರಿಯೊಂದಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಹೊಂದಿಕೆಯಾಗಿತ್ತು, ಇದು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ನೈಸರ್ಗಿಕ ಆಯ್ಕೆಯಾಗಿ ಮಾಡಿತು.
JSON ಅನ್ನು 2000ರ ಮಧ್ಯದಲ್ಲಿ AJAX ಮತ್ತು RESTful APIಗಳ ಏರಿಕೆಯಿಂದ ವೇಗವಾಗಿ ಅಂಗೀಕರಿಸಲಾಯಿತು. 2010ರ ದಶಕದಲ್ಲಿ, ಇದು ವೆಬ್ API, ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು ಮತ್ತು MongoDB ಮತ್ತು CouchDBಂತಹ NoSQL ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ ಡೇಟಾ ಸಂಗ್ರಹಣೆಗಾಗಿ ನಿರ್ಣಾಯಕ ಪ್ರಮಾಣವಾಗಿ ಪರಿಣಮಿಸಿತು.
ಇಂದು JSON ಪ್ರಾಯೋಗಿಕವಾಗಿ ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಮತ್ತು ವೆಬ್‌ನಲ್ಲಿ ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದರ ಸರಳತೆ, ಲವಚಿಕತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಬೆಂಬಲವು ಇದನ್ನು ಆಧುನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್‌ನಲ್ಲಿ ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ಡೇಟಾ ರೂಪಗಳಲ್ಲಿ ಒಂದಾಗಿಸಿದೆ.
ಇಲ್ಲಿ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ JSON ಅನ್ನು ರೂಪಾಂತರಿಸುವ ಉದಾಹರಣೆಗಳಿವೆ:
1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ JSON ರೂಪಾಂತರ
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `ದೋಷ: ${error.message}`;
8 }
9}
10
11// ಉದಾಹರಣೆ ಬಳಕೆ
12const rawJSON = '{"name":"ಜಾನ್","age":30,"city":"ನ್ಯೂಯಾರ್ಕ್"}';
13console.log(formatJSON(rawJSON));
141# ಪೈಥಾನ್ JSON ರೂಪಾಂತರ
2import json
3
4def format_json(json_string):
5 try:
6 parsed_data = json.loads(json_string)
7 return json.dumps(parsed_data, indent=2)
8 except json.JSONDecodeError as e:
9 return f"ದೋಷ: {str(e)}"
10
11# ಉದಾಹರಣೆ ಬಳಕೆ
12raw_json = '{"name":"ಜಾನ್","age":30,"city":"ನ್ಯೂಯಾರ್ಕ್"}'
13print(format_json(raw_json))
141// ಜಾವಾ JSON ರೂಪಾಂತರ ಗ್ಸಾನ್
2import com.google.gson.Gson;
3import com.google.gson.GsonBuilder;
4import com.google.gson.JsonSyntaxException;
5
6public class JSONFormatter {
7 public static String formatJSON(String jsonString) {
8 try {
9 Gson gson = new GsonBuilder().setPrettyPrinting().create();
10 Object parsedJson = gson.fromJson(jsonString, Object.class);
11 return gson.toJson(parsedJson);
12 } catch (JsonSyntaxException e) {
13 return "ದೋಷ: " + e.getMessage();
14 }
15 }
16
17 public static void main(String[] args) {
18 String rawJSON = "{\"name\":\"ಜಾನ್\",\"age\":30,\"city\":\"ನ್ಯೂಯಾರ್ಕ್\"}";
19 System.out.println(formatJSON(rawJSON));
20 }
21}
221// PHP JSON ರೂಪಾಂತರ
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "ದೋಷ: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// ಉದಾಹರಣೆ ಬಳಕೆ
11$rawJSON = '{"name":"ಜಾನ್","age":30,"city":"ನ್ಯೂಯಾರ್ಕ್"}';
12echo formatJSON($rawJSON);
131# ರೂಬಿ JSON ರೂಪಾಂತರ
2require 'json'
3
4def format_json(json_string)
5 begin
6 parsed_data = JSON.parse(json_string)
7 return JSON.pretty_generate(parsed_data)
8 rescue JSON::ParserError => e
9 return "ದೋಷ: #{e.message}"
10 end
11end
12
13# ಉದಾಹರಣೆ ಬಳಕೆ
14raw_json = '{"name":"ಜಾನ್","age":30,"city":"ನ್ಯೂಯಾರ್ಕ್"}'
15puts format_json(raw_json)
161// C# JSON ರೂಪಾಂತರ ನ್ಯೂಟಾನ್.ಜಾನ್
2using Newtonsoft.Json;
3using System;
4
5class JSONFormatter
6{
7 public static string FormatJSON(string jsonString)
8 {
9 try
10 {
11 object parsedJson = JsonConvert.DeserializeObject(jsonString);
12 return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
13 }
14 catch (JsonException e)
15 {
16 return $"ದೋಷ: {e.Message}";
17 }
18 }
19
20 static void Main()
21 {
22 string rawJSON = "{\"name\":\"ಜಾನ್\",\"age\":30,\"city\":\"ನ್ಯೂಯಾರ್ಕ್\"}";
23 Console.WriteLine(FormatJSON(rawJSON));
24 }
25}
261// ಗೋ JSON ರೂಪಾಂತರ
2package main
3
4import (
5 "encoding/json"
6 "fmt"
7)
8
9func formatJSON(jsonString string) string {
10 var parsedData interface{}
11 err := json.Unmarshal([]byte(jsonString), &parsedData)
12 if err != nil {
13 return fmt.Sprintf("ದೋಷ: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("ದೋಷ: %s", err.Error())
19 }
20
21 return string(formattedBytes)
22}
23
24func main() {
25 rawJSON := `{"name":"ಜಾನ್","age":30,"city":"ನ್ಯೂಯಾರ್ಕ್"}`
26 fmt.Println(formatJSON(rawJSON))
27}
28JSON ರೂಪಾಂತರದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಈ ಸಾಧ್ಯತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಳ್ಳಿ:
ಬಹಳ ದೊಡ್ಡ JSON ಫೈಲ್‌ಗಳು (ಕೆಲವು ಮೆಗಾಬೈಟುಗಳು ಅಥವಾ ಹೆಚ್ಚು) ಬ್ರೌಸರ್ ಆಧಾರಿತ ರೂಪಾಂತರಗಳಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಇಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ:
jq ನಂತಹ ಕಮಾಂಡ್-ಲೈನ್ ಸಾಧನಗಳನ್ನು ಬಳಸಲು ಪರಿಗಣಿಸಿಅತಿಯಾಗಿ ನೆಟ್ಟಗೊಳಿಸಿದ JSON (10-20 ಹಂತಗಳಿಗಿಂತ ಹೆಚ್ಚು) ರೂಪಾಂತರಿತವಾದಾಗಲೂ ನಾವಿಕವಾಗಿ ನಾವಿಗೇಟ್ ಮಾಡಲು ಕಷ್ಟವಾಗಬಹುದು. ಇಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ:
JSON ಯೂನಿಕೋಡ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದರೆ ಕೆಲವು ರೂಪಾಂತರಗಳು ಕೆಲವು ಅಕ್ಷರಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಬಹುದು:
JSON ಸಂಖ್ಯೆಗಳಿಗಾಗಿ ಶುದ್ಧತೆಯನ್ನು ನಿರ್ಧರಿಸುವುದಿಲ್ಲ, ಇದು ಬಹಳ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳು ಅಥವಾ ತೇಲುವ ಅಂಕಿಗಳನ್ನು ಬಳಸುವಾಗ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು:
ಮಾನ್ಯ JSON ಖಾಲಿ ವಸ್ತುಗಳನ್ನು {} ಮತ್ತು ಖಾಲಿ ಅರೆಗಳನ್ನು [] ಒಳಗೊಂಡಿದೆ, ಇದು ಸರಿಯಾಗಿ ರೂಪಾಂತರಿತವಾಗಿರಬೇಕು:
{} ಎಂದು ಕಾಣಬೇಕು[] ಎಂದು ಕಾಣಬೇಕುನಿಮ್ಮ ಕೆಲಸದ ಹಂತಕ್ಕೆ ಉಪಯೋಗಿಸಬಹುದಾದ ಹೆಚ್ಚು ಉಪಕರಣಗಳನ್ನು ಹುಡುಕಿ ಹೊಸ ಉಪಕರಣಗಳನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ