चेक / कैच का उपयोग किए बिना जावास्क्रिप्ट में एक स्ट्रिंग एक वैध JSON स्ट्रिंग है, तो कैसे जांचें

Question

कुछ इस तरह:

var jsonString = '{ "Id": 1, "Name": "Coke" }';

//should be true
IsJsonString(jsonString);

//should be false
IsJsonString("foo");
IsJsonString("<div>foo</div>")

समाधान में कोशिश / कैच नहीं होना चाहिए। हम में से कुछ "सभी त्रुटियों पर ब्रेक" चालू करते हैं और वे उन अमान्य JSON स्ट्रिंग्स पर डिबगर को तोड़ना पसंद नहीं करते हैं।

Comments

उपयोग न करने का कोई वैध कारण है try?

— निक टी

@NickT क्योंकि यदि आप डीबगर में "सभी त्रुटियों पर ब्रेक" चालू करते हैं, तो यह होगा। Chrome के पास अब अनकवर्ड एरर थू पर ब्रेक करने का विकल्प है।

— ची चान

इसे पकड़ने की कोशिश के साथ जांच करने के लिए सिर्फ 2 लाइनों का उपयोग करें। var isValidJSON = true; {jSON.parse (jsonString)} को पकड़ने का प्रयास करें {isValidJSON = false; }

— kanफंक

जबकि यह काम करता है, यह बहुत बुरा और बुरा व्यवहार है। कोशिश / पकड़ असाधारण व्यवहार और त्रुटि से निपटने के लिए है, न कि सामान्य कार्यक्रम प्रवाह के लिए।

— तसाल

@ टासगल एक सामान्य नियम के रूप में, हाँ। लेकिन आप क्या करते हैं अगर कोशिश / पकड़ दृष्टिकोण किसी भी सत्यापनकर्ता-आधारित दृष्टिकोण से अधिक प्रदर्शनकारी है? (कभी-कभी काफी) धीमे विकल्प के साथ जाएं क्योंकि विकल्प "बुरा अभ्यास" है? कोशिश / पकड़ने की विधि के साथ कार्यात्मक रूप से कुछ भी गलत नहीं है, इसलिए इसका उपयोग न करने का कोई कारण नहीं है। नए प्रोग्रामर के लिए अच्छे कोडिंग मानकों का विकास करना महत्वपूर्ण है, लेकिन पारंपरिक दिशा-निर्देशों के प्रति अंध पालन को सुदृढ़ नहीं करना भी उतना ही महत्वपूर्ण है, विशेषकर ऐसे मामलों में जहां दिशा-निर्देश चीजों को अधिक कठिन बनाते हैं।

— अबिओन ४47

Answer 1

एक टिप्पणी पहले। सवाल उपयोग नहीं करने के बारे में था try/catch।
यदि आप इसका उपयोग करने का मन नहीं रखते हैं, तो नीचे दिए गए उत्तर को पढ़ें। यहां हम सिर्फ एक की जांच करते हैंJSON स्ट्रिंग का उपयोग करते हुए एक regexp की करते हैं, और यह अधिकांश मामलों में काम करेगा, सभी मामलों में नहीं।

450 में लाइन के आसपास एक नज़र है Https://github.com/douglascrockford/JSON-js/blob/master/json2.js पर

एक regexp है जो एक वैध JSON के लिए जाँच करता है, कुछ इस प्रकार है:

if (/^[\],:{}\s]*$/.test(text.replace(/\\["\\\/bfnrtu]/g, '@').
replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

  //the json is ok

}else{

  //the json is not ok

}

संपादित करें : json2.js का नया संस्करण ऊपर की तुलना में अधिक उन्नत पार्सिंग बनाता है, लेकिन फिर भी एक रीजैक्स रिप्ले ( @Mrchief की टिप्पणी से ) पर आधारित है

Comments

यह केवल जाँच रहा है कि कोड का उपयोग करने के लिए सुरक्षित है या नहीं। उदाहरण के लिए निम्नलिखित स्ट्रिंग '2011-6-27' उस परीक्षा को पास करेगी।

— SystemicPlural

@ सिस्टेमिकलुरल, हां, लेकिन सवाल कोशिश / कैच का उपयोग नहीं करने के बारे में था

— माइक

आप यह परीक्षण नहीं कर सकते हैं कि कोई स्ट्रिंग जावास्क्रिप्ट में JSON के साथ वैध JSON है, क्योंकि JS regexes आवश्यक एक्सटेंशन (पुनरावर्ती rexxes) का समर्थन नहीं करता है जो आपको ऐसा करने देते हैं। आपका उपरोक्त कोड "{" पर विफल रहता है।

— वेंग

@Mic json2.js अब उस साधारण चेक का उपयोग नहीं करता है (इसके बजाय वैध JSON को निर्धारित करने के लिए 4 चरण पार्सिंग का उपयोग करता है)। अपने उत्तर को संशोधित करने या हटाने का सुझाव देगा। ध्यान दें कि मुझे नहीं लगता कि दृष्टिकोण के रूप में "JSON के लिए जाँच करने के लिए एकमात्र तंत्र के रूप में कोशिश / पकड़ नहीं है" के साथ कोई भी गलत है।

— मृचि

सिर्फ इसलिए कि यह उसकी मदद करता है, इसका मतलब यह नहीं है कि यह बाकी लोगों की मदद करता है, जो सालों बाद एक ही सवाल करते हैं।

— मैके

Answer 2

JSON पार्सर का उपयोग करें जैसे JSON.parse:

function IsJsonString(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
}

Comments

धन्यवाद, लेकिन मैंने सिर्फ टीम के साथ इसे चलाया और वे ऐसा कुछ चाहते हैं जो कोशिश / कैच का उपयोग न करे। प्रश्न को नए शीर्षक के साथ संपादित किया जाता है। उसके लिए माफ़ करना।

— चाई चान

@trejder: यह ऐसा करता है क्योंकि 1 एक स्ट्रिंग नहीं है, इसे "1" के साथ आज़माएं

— प्योरफैन

@Gumbo मेरी टिप्पणी 1,5 साल पुरानी है! :] मुझे याद नहीं है, मैं दो हफ्ते पहले क्या कर रहा था और आप मुझे उस प्रोजेक्ट को याद करने के लिए कह रहे हैं? :] नहीं, रास्ता ...:]

— trejder

इस उत्तर के साथ समस्या यह है, यदि स्ट्रिंग चेक आउट करती है, और आप इसे पार्स करते हैं, तो आपने इसे दो बार पार्स किया होगा। क्या आप इसके बजाय एक बुरे तोते पर झूठे नहीं लौट सकते, लेकिन सफलता पर वस्तु वापस कर सकते हैं?

— कैरिजनेट

@Carcigenicate आप ऐसा कर सकते हैं। हालाँकि, असत्य काJSON.parse("false") मूल्यांकन भी करता है।

— गुम्बो

Answer 3

मुझे पता है कि मुझे इस सवाल पर 3 साल की देर हो गई है, लेकिन मुझे लगा कि मैं इसमें चीं-चीं कर रहा हूं।

जबकि गम्बो का समाधान बहुत अच्छा काम करता है, यह कुछ मामलों को नहीं संभालता है जहां कोई अपवाद नहीं उठाया जाता है JSON.parse({something that isn't JSON})

मैं एक ही समय में पार्स किए गए JSON को वापस करना भी पसंद करता हूं, इसलिए कॉलिंग कोड को कॉल करने की आवश्यकता नहीं है JSON.parse(jsonString) दूसरी बार ।

यह मेरी जरूरतों के लिए अच्छा काम करता है:

function tryParseJSON (jsonString){
    try {
        var o = JSON.parse(jsonString);

        // Handle non-exception-throwing cases:
        // Neither JSON.parse(false) or JSON.parse(1234) throw errors, hence the type-checking,
        // but... JSON.parse(null) returns null, and typeof null === "object", 
        // so we must check for that, too. Thankfully, null is falsey, so this suffices:
        if (o && typeof o === "object") {
            return o;
        }
    }
    catch (e) { }

    return false;
};

Comments

पृष्ठ पर उत्तरों में से, यह सबसे मजबूत और विश्वसनीय है।

— जॉनलाइन

o && o !== nullशानदार है।

— अलेक्सी मटिहस्किन

तो टाइपो के साथ ट्रिपल-बराबर का उपयोग कर रहा है, जो हमेशा एक स्ट्रिंग लौटाता है। :)

— हेन हरलडसन बर्ग

एक पुरानी पोस्ट होने के बावजूद, मैंने अपने उत्तर @matth को प्रदर्शित करते हुए एक बेड़ा डालना उचित समझा, कृपया ध्यान दें कि ऑब्जेक्ट मान्य नहीं होंगे .. आपको JSON स्ट्रिंग पास करना होगा। मुझे लगता है कि शुरू करने वाले किसी के लिए भी काम आ सकता है।

— माइंडवॉक्स 25'16

समारोह लौटना चाहिए undefined, नहीं falseक्योंकि falseएक मान्य JSON स्ट्रिंग है और वहाँ के बीच अंतर करने का कोई तरीका नहीं है tryParseJSON("false")औरtryParseJSON("garbage")

— sparebytes

Answer 4

// vanillaJS
function isJSON(str) {
    try {
        return (JSON.parse(str) && !!str);
    } catch (e) {
        return false;
    }
}

उपयोग: isJSON({}) होगा false, isJSON('{}')होगा true।

यह जाँचने के लिए कि क्या कुछ है Arrayया Object( पार्स किया गया JSON):

// vanillaJS
function isAO(val) {
    return val instanceof Array || val instanceof Object ? true : false;
}

// ES2015
var isAO = (val) => val instanceof Array || val instanceof Object ? true : false;

उपयोग: isAO({}) होगा true, isAO('{}')होगा false।

Comments

nullइस सत्यापन को पारित करने के बाद से सावधान रहें ।

— फ़रज़ाद वाईजेड

return !!(JSON.parse(str) && str);अशक्त मूल्यों को अवरुद्ध करना चाहिए। मैं इस कोड के साथ उत्तर को अपडेट करूंगा।

— मचाडो

यह सबसे अच्छा जवाब है, क्योंकि यह आपको यह भी जांचने की अनुमति देता है कि क्या JSON को ऑब्जेक्टिफाई किया गया है , और इस प्रकार parse()परीक्षण पास नहीं कर रहा है , जिससे WTF का कारण बनता है।

— not2qubit

Answer 5

यहाँ मेरा काम कोड:

function IsJsonString(str) {
  try {
    var json = JSON.parse(str);
    return (typeof json === 'object');
  } catch (e) {
    return false;
  }
}

Comments

(शून्य) IsJsonString; // रिटर्न सही है। इसकी तुलनाtypeof str === 'string'

— ग्रामा

Answer 6

मैंने एक स्ट्रिंग की जाँच करने के लिए वास्तव में सरल विधि का उपयोग किया कि यह कैसे एक वैध JSON है या नहीं।

function testJSON(text){
    if (typeof text!=="string"){
        return false;
    }
    try{
        JSON.parse(text);
        return true;
    }
    catch (error){
        return false;
    }
}

मान्य JSON स्ट्रिंग के साथ परिणाम:

var input='["foo","bar",{"foo":"bar"}]';
testJSON(input); // returns true;

एक साधारण स्ट्रिंग के साथ परिणाम;

var input='This is not a JSON string.';
testJSON(input); // returns false;

एक वस्तु के साथ परिणाम:

var input={};
testJSON(input); // returns false;

अशक्त इनपुट के साथ परिणाम:

var input=null;
testJSON(input); // returns false;

अंतिम एक गलत है क्योंकि अशक्त चर का प्रकार वस्तु है।

यह हर काम करता है। :)

Comments

JSON.parse (null), JSON.parse ("झूठी") त्रुटियां नहीं फेंकती हैं, शायद अधिक उदाहरण हैं

— klodoma

हाँ, आप सही हैं, मैं यह जांचना भूल गया कि इनपुट कैसे एक स्ट्रिंग है या नहीं, यदि मैं ऐसा करता हूं, तो nullइनपुट के साथ यह विधि इसे गलत बताती है। लेकिन "झूठा" इनपुट एक वैध JSON स्ट्रिंग है। इस पर विचार किया जाएगा boolean (false)। अब मैं अधिक सटीक होने के लिए कोड को संशोधित करता हूं।

— कुकको

Answer 7

प्रोटोटाइप में, हमारे पास विधि हैजॉन । आप कोशिश कर सकते हैं कि यहां तक ​​कि json मदद कर सकता है।

"something".isJSON();
// -> false
"\"something\"".isJSON();
// -> true
"{ foo: 42 }".isJSON();
// -> false
"{ \"foo\": 42 }".isJSON();

Comments

धन्यवाद, लेकिन मुझे लगता है कि ऐसा करने के लिए प्रोटोटाइप लाइब्रेरी का उपयोग करना थोड़ा अधिक है।

— ची चान

आपने चार उदाहरण दिए लेकिन केवल तीन परिणाम। के लिए परिणाम क्या है "{ foo: 42 }".isJSON()? यदि false, जैसा कि मैं मानता हूं (परिणाम को फ़ंक्शन के दस्तावेज़ का पालन करना चाहिए), तो अच्छा सवाल यह है कि यह गलत क्यों है? { foo: 42 }लगता है पूरी तरह से वैध JSON है।

— trejder

@trejder दुर्भाग्य से, JSON कल्पना को उद्धृत कुंजियों की आवश्यकता होती है।

— mikermcneil

और "2002-12-15" .isJSON सही है, जबकि JSON.parse ("2002-12-15") एक त्रुटि फेंकता है।

— नौकाचू

मुझे लगता है कि यहां बेहतर उत्तर उस फ़ंक्शन को प्रोटोटाइप लाइब्रेरी से बाहर निकालने और यहां रखने के लिए होगा। विशेष रूप से चूंकि api.prototypjs.org/language/string/prototyp/isjson 404 है।

— jcollum

Answer 8

प्रोटोटाइप ढांचे से String.isJSONपरिभाषा यहाँ

/**
   *  String#isJSON() -> Boolean
   *
   *  Check if the string is valid JSON by the use of regular expressions.
   *  This security method is called internally.
   *
   *  ##### Examples
   *
   *      "something".isJSON();
   *      // -> false
   *      "\"something\"".isJSON();
   *      // -> true
   *      "{ foo: 42 }".isJSON();
   *      // -> false
   *      "{ \"foo\": 42 }".isJSON();
   *      // -> true
  **/
  function isJSON() {
    var str = this;
    if (str.blank()) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }

तो यह वह संस्करण है जिसका उपयोग स्ट्रिंग ऑब्जेक्ट को पास करने में किया जा सकता है

function isJSON(str) {
    if ( /^\s*$/.test(str) ) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }

function isJSON(str) {
    if ( /^\s*$/.test(str) ) return false;
    str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
    str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
    str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
    return (/^[\],:{}\s]*$/).test(str);
  }

console.log ("this is a json",  isJSON( "{ \"key\" : 1, \"key2@e\" : \"val\"}" ) )

console.log("this is not a json", isJSON( "{ \"key\" : 1, \"key2@e\" : pippo }" ) )

Comments

इन सभी उत्तरों की तुलना करने के लिए किसी के पास टेस्ट सूट है? मैं यह देखना चाहता हूं कि क्या यह सही है।

— लोनी बेस्ट

@ लोनीबेस्ट अच्छा बिंदु। मेरे 2 सेंट। मैंने उत्पादन में वर्षों तक उपयोग किया है और इसने हमेशा ठीक काम किया है और उचित निष्पादन समय के साथ।

— लोरेटोपरिसी

Answer 9

यह जवाब देने की कोशिश को कम करने की कोशिश करता है।

मैंने JSON तार को पार्स करने के लिए JQuery का उपयोग किया और अपवादों को संभालने के लिए मैंने ट्रायचैच स्टेटमेंट का उपयोग किया, लेकिन अन-पार्सबल स्ट्रिंग्स के अपवादों को फेंकने से मेरा कोड धीमा हो गया, इसलिए मैंने स्ट्रिंग को चेक करने के लिए सरल Regex का उपयोग किया, यदि यह संभव JSON स्ट्रिंग है या पंख के बिना नहीं है। यह सिंटैक्स की जाँच करके, फिर मैंने JQuery का उपयोग करके स्ट्रिंग को पार्स करके नियमित रूप से उपयोग किया:

if (typeof jsonData == 'string') {
    if (! /^[\[|\{](\s|.*|\w)*[\]|\}]$/.test(jsonData)) {
        return jsonData;
    }
}

try {
    jsonData = $.parseJSON(jsonData);
} catch (e) {

}

मैं नेस्टेड JSON प्रतिक्रियाओं को पार्स करने के लिए एक पुनरावर्ती फ़ंक्शन में पिछले कोड को लपेटा।

Comments

JQuery क्या करता है जो JSON.parse () नहीं करता है?

— एडीजेक्स

Answer 10

शायद यह उपयोगी होगा:

    function parseJson(code)
{
    try {
        return JSON.parse(code);
    } catch (e) {
        return code;
    }
}
function parseJsonJQ(code)
{
    try {
        return $.parseJSON(code);
    } catch (e) {
        return code;
    }
}

var str =  "{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}";
alert(typeof parseJson(str));
alert(typeof parseJsonJQ(str));
var str_b  = "c";
alert(typeof parseJson(str_b));
alert(typeof parseJsonJQ(str_b));

उत्पादन:

IE7: स्ट्रिंग , ऑब्जेक्ट, स्ट्रिंग, स्ट्रिंग

CHROME: ऑब्जेक्ट, ऑब्जेक्ट, स्ट्रिंग, स्ट्रिंग

Answer 11

मुझे लगता है कि मुझे पता है कि आप इससे बचना क्यों चाहते हैं। लेकिन शायद कोशिश करें और पकड़ें! == कोशिश करें और पकड़ें। ; ओ) यह मेरे दिमाग में आया:

var json_verify = function(s){ try { JSON.parse(s); return true; } catch (e) { return false; }};

तो आप JSON ऑब्जेक्ट को क्लिप को भी गंदा कर सकते हैं, जैसे:

JSON.verify = function(s){ try { JSON.parse(s); return true; } catch (e) { return false; }};

इस रूप में संभव के रूप में समझाया, यह त्रुटि पर टूट नहीं सकता है।

Answer 12

यहाँ टाइपस्क्रिप्ट संस्करण भी है:

JSONTryParse(input) {
    try {
        //check if the string exists
        if (input) {
            var o = JSON.parse(input);

            //validate the result too
            if (o && o.constructor === Object) {
                return o;
            }
        }
    }
    catch (e) {
    }

    return false;
};

Comments

टाइपस्क्रिप्ट जावास्क्रिप्ट नहीं है, लेकिन आपका जवाब लगता है।

— लोनी बेस्ट

Answer 13

var jsonstring='[{"ConnectionString":"aaaaaa","Server":"ssssss"}]';

if(((x)=>{try{JSON.parse(x);return true;}catch(e){return false}})(jsonstring)){

document.write("valide json")

}else{
document.write("invalide json")
}

Answer 14

मैं शुरुआती टिप्पणी से अनुमान लगाता हूं कि उपयोग का मामला नाजुक है कि क्या प्रतिक्रिया HTML या JSON है। किस मामले में, जब आप करते हैं JSON प्राप्त हैं, तो आपको संभवतः इसे पार्स करने और अपने कोड में किसी भी समय अमान्य JSON को संभालने की आवश्यकता होगी। कुछ के अलावा, मुझे लगता है कि आप अपने ब्राउज़र द्वारा सूचित किया जाना चाहते हैं JSON की उम्मीद की जानी चाहिए, लेकिन अमान्य JSON प्राप्त हुआ (जैसा कि कुछ सार्थक त्रुटि संदेश के प्रॉक्सी द्वारा उपयोगकर्ता होगा)!

JSON के लिए पूर्ण रेगेक्स करना अनावश्यक है (जैसा कि यह होगा - मेरे अनुभव में - अधिकांश उपयोग-मामलों के लिए)। आप शायद नीचे दिए गए कुछ का उपयोग करके बेहतर होंगे:

function (someString) {
  // test string is opened with curly brace or machine bracket
  if (someString.trim().search(/^(\[|\{){1}/) > -1) {
    try { // it is, so now let's see if its valid JSON
      var myJson = JSON.parse(someString);
      // yep, we're working with valid JSON
    } catch (e) {
      // nope, we got what we thought was JSON, it isn't; let's handle it.
    }
  } else {
    // nope, we're working with non-json, no need to parse it fully
  }
}

मान्य गैर-JSON कोड को हैंडल करने के लिए आपको सहेजना चाहिए और एक ही समय में duff json का ध्यान रखना चाहिए।

Comments

यह हाइब्रिड समाधान ऐसा लगता है कि यह गैर-जोंसन मामलों में कोशिश करने से बचने का एक प्रभावी तरीका होगा। मुझे आपके दृष्टिकोण का वह पहलू पसंद है।

— लोनी बेस्ट

Answer 15

if(resp) {
    try {
        resp = $.parseJSON(resp);
        console.log(resp);
    } catch(e) {
        alert(e);
    }
}

आशा है कि यह आपके लिए भी काम करता है

Answer 16

function get_json(txt)
{  var data

   try     {  data = eval('('+txt+')'); }
   catch(e){  data = false;             }

   return data;
}

यदि त्रुटियां हैं, तो झूठी लौटें।

यदि कोई त्रुटि नहीं है, तो json डेटा लौटाएं

Comments

प्रश्न में: "समाधान में कोशिश / कैच नहीं होना चाहिए"।

— ddmps

क्यों? इस तरह से गारंटी दी जाती है ... डिसाइड करना बेवकूफी होगी! मुझे अंग्रेजी नहीं जानने के लिए खेद है। मैंने

— Emrah Tuncel

दिलचस्प। मैं JSON.parse बनाम इस eval आधारित समाधान के प्रदर्शन की तुलना देखना चाहता हूं। फिर भी यह सुरक्षा / इंजेक्शन के नजरिए से डरावना है।

— लोनी बेस्ट

Answer 17

यदि यह वैध है तो आप सत्यापित करने के लिए जावास्क्रिप्ट eval () फ़ंक्शन का उपयोग कर सकते हैं ।

जैसे

var jsonString = '{ "Id": 1, "Name": "Coke" }';
var json;

try {
  json = eval(jsonString);
} catch (exception) {
  //It's advisable to always catch an exception since eval() is a javascript executor...
  json = null;
}

if (json) {
  //this is json
}

वैकल्पिक रूप से, आप json.orgJSON.parse से फ़ंक्शन का उपयोग कर सकते हैं :

try {
  json = JSON.parse(jsonString);
} catch (exception) {
  json = null;
}

if (json) {
  //this is json
}

उम्मीद है की यह मदद करेगा।

चेतावनी : यदि कोई दुर्भावनापूर्ण जेएस कोड जोड़ता है, तो eval()यह खतरनाक है क्योंकि यह इसे निष्पादित करेगा। सुनिश्चित करें कि JSON स्ट्रिंग विश्वसनीय है , यानी आपको यह एक विश्वसनीय स्रोत से मिला है।

मेरे पहले समाधान के लिए संपादित करें , इसे करने की सिफारिश की गई है।

 try {
      json = eval("{" + jsonString + "}");
    } catch (exception) {
      //It's advisable to always catch an exception since eval() is a javascript executor...
      json = null;
    }

करने के लिए गारंटी json सत्ता। यदि jsonStringशुद्ध JSON नहीं है, तो eval एक अपवाद फेंक देगा।

Comments

Eval का उपयोग करने वाला पहला उदाहरण कहता है कि "<div> foo </ div>" वैध JSON है। यह अलग-अलग ब्राउज़रों में अलग-अलग काम कर सकता है, लेकिन ऐसा प्रतीत होता है कि फायरफॉक्स में, एक्सल () एक्सएमएल को स्वीकार करता है।

— मार्क ल्यूटन

धन्यवाद, लेकिन मैंने सिर्फ टीम के साथ इसे चलाया और वे ऐसा कुछ चाहते हैं जो कोशिश / कैच का उपयोग न करे। प्रश्न को नए शीर्षक के साथ संपादित किया जाता है। उसके लिए माफ़ करना।

— चाई चान

@ मर्क लुट्टन, ऑब्जेक्ट प्रकार JSON का नहीं होगा लेकिन XML DOM डॉक्यूमेंट का (मैं भूल गया कि फायरफॉक्स में सटीक प्रकार क्या है)।

— बुहके सिंडी

eval भी मान्य जावास्क्रिप्ट को स्वीकार करता है, जैसे "अलर्ट (5);" और एकल उद्धरण में तार, जो मान्य JSON नहीं हैं।

— मार्क ल्यूटन

यह शुद्ध निष्कासन है।

— क्रिस बेकर

Answer 18

ओह, आप निश्चित रूप से यह जानने के लिए कि क्या कोई वैध JSON है या नहीं, यह जानने के लिए कोशिश कर सकते हैं

Firfox Quantom 60.0.1 पर परीक्षण किया गया

JSON का परीक्षण करने के लिए एक फ़ंक्शन के अंदर फ़ंक्शन का उपयोग करें और स्ट्रिंग को मान्य करने के लिए उस आउटपुट का उपयोग करें। एक उदाहरण सुनता है।

    function myfunction(text){

       //function for validating json string
        function testJSON(text){
            try{
                if (typeof text!=="string"){
                    return false;
                }else{
                    JSON.parse(text);
                    return true;                            
                }
            }
            catch (error){
                return false;
            }
        }

  //content of your real function   
        if(testJSON(text)){
            console.log("json");
        }else{
            console.log("not json");
        }
    }

//use it as a normal function
        myfunction('{"name":"kasun","age":10}')

Answer 19

फ़ंक्शन IsJsonString(str), जो उपयोग कर रहा है JSON.parse(str), मेरे मामले में काम नहीं करता है।
मैंने ग्राफ़िंकल से जूस आउटपुट को मान्य करने की कोशिश की, यह हमेशा गलत होता है। लकी मी, isJSON बेहतर काम करता है:

var test = false;

$('body').on('DOMSubtreeModified', '.resultWrap', function() {

    if (!test) {   
        var resultWrap = "{" + $('#graphiql .resultWrap').text().split("{").pop();
        if isJSON(resultWrap) {test = !test;}
        console.log(resultWrap); 
        console.log(resultWrap.isJSON());
    }

});

नमूना उत्पादन:

THREE.WebGLRenderer 79
draw.js:170 {xxxxxxxxxx​
draw.js:170 false
draw.js:170 {xxxxxxxxxx ​
draw.js:170 false
draw.js:170 {xxxxxxxxxx ​
draw.js:170 false
draw.js:170 {xxxxxxxxxx ​
draw.js:170 false
draw.js:170 {​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,  "height": 327​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,  "height": 327}​
draw.js:170 false
draw.js:170 {  "PI": 3.141592653589793,  "time": 1570751209006,  "tick": 156,  "tickr": 1.56,  "fps": 41.666666666666664,  "width": 396.984,  "height": 327}
draw.js:170 true

Answer 20

ऐसे लोगों के लिए जो "कोशिश" कार्यों के .Net सम्मेलन को पसंद करते हैं जो बूलियन वापस करते हैं और परिणाम से युक्त एक बफ़र पैराम को संभालते हैं। यदि आपको आउट पैरामीटर की आवश्यकता नहीं है तो आप इसे छोड़ सकते हैं और बस रिटर्न मान का उपयोग कर सकते हैं।

StringTests.js

  var obj1 = {};
  var bool1 = '{"h":"happy"}'.tryParse(obj1); // false
  var obj2 = {};
  var bool2 = '2114509 GOODLUCKBUDDY 315852'.tryParse(obj2);  // false

  var obj3 = {};
  if('{"house_number":"1","road":"Mauchly","city":"Irvine","county":"Orange County","state":"California","postcode":"92618","country":"United States of America","country_code":"us"}'.tryParse(obj3))
    console.log(obj3);

StringUtils.js

String.prototype.tryParse = function(jsonObject) {
  jsonObject = jsonObject || {};
  try {
    if(!/^[\[{]/.test(this) || !/[}\]]$/.test(this)) // begin / end with [] or {}
      return false; // avoid error handling for strings that obviously aren't json
    var json = JSON.parse(this);
    if(typeof json === 'object'){
      jsonObject.merge(json);
      return true;
    }
  } catch (e) {
    return false;
  }
}

ObjectUtils.js

Object.defineProperty(Object.prototype, 'merge', {
  value: function(mergeObj){
    for (var propertyName in mergeObj) {
      if (mergeObj.hasOwnProperty(propertyName)) {
        this[propertyName] = mergeObj[propertyName];
      }      
    }
    return this;
  },
  enumerable: false, // this is actually the default
});

Answer 21

बहुत सरल एक-लाइनर कोड (लेकिन हैकी दृष्टिकोण)

if (expected_json.id === undefined){
   // not a json
}
else{
   // json
}

ध्यान दें: यह केवल तभी काम करता है जब आप किसी चीज की उम्मीद कर रहे हों, जैसे कि JSON स्ट्रिंग। मैं एक एपीआई के लिए इसका उपयोग कर रहा हूं और परिणाम JSON या कुछ त्रुटि स्ट्रिंग की अपेक्षा कर रहा हूं।