जेसन को उसके JSON फॉर्मेट में मदद करें

Question

जेसन के पास एक बड़ा JSON है लेकिन यह अपठनीय है, इसलिए उसे इसे पूर्वस्थापित करने की आवश्यकता है।

स्वरूपण युक्ति

JSON के 4 अलग-अलग प्रकार हैं:

• नंबर; केवल0-9
• तार; डबल उद्धृत "स्ट्रिंग के साथ भाग गए\
• सरणी; द्वारा []विभाजित ,, आइटम द्वारा अलग किए गए , आइटम इनमें से किसी भी प्रकार के हो सकते हैं
• वस्तुएं; द्वारा सीमांकित {}, प्रारूप वह है key: valueजहाँ कुंजी एक स्ट्रिंग है और मान इनमें से कोई भी प्रकार है

रिक्ति

• मदों के बीच अल्पविराम के बाद एरे के पास बिल्कुल एक स्थान होना चाहिए
• ऑब्जेक्ट में कुंजी और मान के बीच सिर्फ एक स्थान होना चाहिए, के बाद :

खरोज

• प्रत्येक घोंसले का स्तर पिछले की तुलना में 2 अधिक है
• प्रत्येक ऑब्जेक्ट कुंजी / मान युग्म हमेशा अपनी रेखा पर होता है। वस्तुओं का इंडेंट होता है
• यदि कोई सरणी किसी अन्य सरणी या ऑब्जेक्ट में है, तो एक सरणी कई पंक्तियों में इंडेंट की जाती है। अन्यथा सरणी एक पंक्ति पर रहती है

नियम

• बिल्ट-इन जो इस कार्य को तुच्छ करते हैं उन्हें अनुमति नहीं है ।
• जैसा कि हमेशा मानक खामियों को रोक दिया जाता है

उदाहरण

[1,2,3]
[1, 2, 3]

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

"foo"
"foo"

56
56

{"a":[{"b":1,"c":"foo"},{"d":[2,3,4,1], "a":["abc","def",{"d":{"f":[3,4]}}]}]}
{
  "a": [
    {
      "b": 1,
      "c": "foo"
    },
    {
      "d": [2, 3, 4, 1],
      "a": [
        "abc",
        "def",
        {
          "d": {
            "f": [3, 4]
          }
        }
      ]
    }
  ]
}

[2,["foo123 ' bar \" baz\\", [1,2,3]]]
[
  2,
  [
    "foo123 ' bar \" baz\\",
    [1, 2, 3]
  ]
]

[1,2,3,"4[4,5]"]
[1, 2, 3, "4[4,5]"]

[1,2,3,{"b":["{\"c\":[2,5,6]}",4,5]}]
[
  1,
  2,
  3,
  {
    "b": ["{\"c\":[2,5,6]}", 4, 5]
  }
]

Comments

क्या JSON के पार्सिंग निर्माण की अनुमति है?

— पुरकाकूदरी

क्या वस्तुएं / सरणियाँ खाली हो सकती हैं? यदि हम कई लाइनों में विभाजित हो जाते हैं, तो क्या हम एरेस में कॉमा के बाद भी एक स्थान प्रिंट कर सकते हैं?

— मार्टिन एंडर

@ मार्टिनबंटनर नहीं, और हाँ

— डाउनगैट

@ Pietu1998 hm, मैं

— Nogo

क्या भाषा पार्सर भाषाओं की अनुमति है?

— मामा फन रोल

Answer 1

जावास्क्रिप्ट (ईएस 6), 368 बाइट्स

f=(s,r=[],i='',j=i+'  ',a=[])=>s<'['?([,,r[0]]=s.match(s<'0'?/("(?:\\.|[^"])*")(.*)/:/(\d+)(.*)/))[1]:s<'{'?(_=>{for(;s<']';s=r[0])a.push(f(s.slice(1),r,j));r[0]=s.slice(1)})()||/\n/.test(a)?`[
${j+a.join(`,
`+j)}
${i}]`:`[${a.join`, `}]`:(_=>{for(a=[];s<'}';s=r[0])a.push(f(s.slice(1),r,j)+': '+f(r[0].slice(1),r,j));r[0]=s.slice(1)})()||`{
${j+a.join(`,
`+j)}
${i}}`

कम गोल्फ वाला:

function j(s, r=[], i='') { // default to no indentation
    if (s < '0') { // string
        let a = s.match(/("(?:\\.|[^"])*")(.*)/);
        r[0] = a[2]; // pass the part after the string back to the caller
        return a[1];
    } else if (s < '[') { // number
        let a = s.match(/(\d+)(.*)/);
        r[0] = a[2]; // pass the part after the string back to the caller
        return a[1];
    } else if (s < '{') { // array
        let a = [];
        while (s < ']') { // until we see the end of the array
            s = s.slice(1);
            a.push(j(s, r, i + '  ')); // recurse with increased indentation
            s = r[0]; // retrieve the rest of the string
        }
        r[0] = s.slice(1); // pass the part after the string back to the caller
        if (/\n/.test(a.join())) { // array contained object
            return '[\n  ' + i + a.join(',\n  ' + i) + '\n' + i + ']';
        } else {
            return '[' + a.join(', ') + ']';
        }
    } else { // object
        let a = [];
        while (s < '}') { // until we see the end of the object
            s = s.slice(1);
            let n = j(s, r, i + '  ');
            s = r[0].slice(1);
            let v = j(s, r, i + '  ');
            a.push(n + ': ' + v);
            s = r[0]; // retrieve the rest of the string
        }
        r[0] = s.slice(1); // pass the part after the string back to the caller
        return '{\n  ' + i + a.join(',\n  ' + i) + '\n' + i + '}';
    }
}