यदि स्ट्रिंग JSON है या नहीं तो कैसे परीक्षण करें?

Question

मेरे पास एक सरल AJAX कॉल है, और सर्वर या तो JSON स्ट्रिंग को उपयोगी डेटा या PHP फ़ंक्शन द्वारा उत्पादित त्रुटि संदेश स्ट्रिंग के साथ लौटा देगा mysql_error()। मैं कैसे जांच सकता हूं कि यह डेटा JSON स्ट्रिंग है या त्रुटि संदेश।

किसी फ़ंक्शन का उपयोग करना अच्छा होगा isJSONजैसे आप फ़ंक्शन instanceofका उपयोग करके परीक्षण कर सकते हैं कि क्या कुछ ऐरे है।

यह वही चीज है जो मैं चाहता हूं:

if (isJSON(data)){
    //do some data stuff
}else{
    //report the error
    alert(data);
}

Comments

शायद इसका उपयोग करते हुए eval()अगर यह वापस आता है undefined, तो यह JSON नहीं है

— MatuDuke

इसे यहाँ हल कर दिया गया है: stackoverflow.com/questions/3710204/…

— रीनार्ड

सभी को धन्यवाद, खेद है कि मुझे वह दूसरी पोस्ट पहले नहीं मिली।

— jeffery_the_wind

तकनीकी रूप से यह 3710204 का डुप्लिकेट नहीं है क्योंकि कोई यह पूछता है कि क्या यह वैध जोंस है जो पास होने की तुलना में बहुत अधिक बार है तो यह जस है।

— carlin.scott

AJAX

— मेहदी देहगानी

Answer 1

JSON.parse का उपयोग करें

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

Comments

अपवाद हैंडलिंग को कुछ अपेक्षित करने के लिए उपयोग नहीं किया जाना चाहिए।

— luisZavaleta

JSON.parse(1234)OR JSON.parse(0)या JSON.parse(false)OR JSON.parse(null)सभी Exception नहीं बढ़ाएंगे और सही वापस आएंगे !!। इस उत्तर का उपयोग न करें

— ज़लाबोज़ा

@Zalaboza 1234, 0, false, और nullसभी मान्य JSON मान हैं। यदि आप चाहते हैं कि JSON एक ऑब्जेक्ट का प्रतिनिधित्व करता है, तो आप एक छोटे से अधिक करने की आवश्यकता होगी कि एक परीक्षण करना चाहते हैं।

— माइकल लैंग

JSON.parseस्ट्रिंग को पार्स करने के लिए बहुत सारी गणना करता है, और यदि सफल होने पर आपको json ऑब्जेक्ट देता है, फिर भी आप उस परिणाम को छोड़ रहे हैं जिसे कुछ उपयोगकर्ता उपयोग करना चाहते हैं। जो अच्छा नहीं लगता है। मैं इसके बजाय return {value: JSON.parse(str), valid: true};और पकड़ ब्लॉक में था return {value: str, valid: false};.. और मैं फ़ंक्शन का नाम बदलूंगा tryParse()।

— नवाज

@luisZavaleta तब आप एक विधि के रूप में क्या सुझाव देते हैं

— PirateApp

Answer 2

इस कोड है JSON.parse(1234)या JSON.parse(0)या JSON.parse(false)या JSON.parse(null)सभी सच्चे वापस आ जाएगी।

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

तो मैं इस तरह से कोड फिर से लिखना:

function isJson(item) {
    item = typeof item !== "string"
        ? JSON.stringify(item)
        : item;

    try {
        item = JSON.parse(item);
    } catch (e) {
        return false;
    }

    if (typeof item === "object" && item !== null) {
        return true;
    }

    return false;
}

परीक्षण का परिणाम:

isJson परीक्षा परिणाम

Comments

अच्छा काम! आपका अंतिम यदि कथन को साधारण रिटर्न स्टेटमेंट में सरल बनाया जा सकता है जैसे:return (typeof suspect === "object" && suspect !== null);

— नेबुलसर

Answer 3

इसे (2019+ के लिए) रीमैप करें।

तर्क : मान जैसे true, false, nullमान्य हैं JSON (?)

तथ्य : ये आदिम मूल्य JSON-parsable हैं, लेकिन वे JSON संरचना के लिए अच्छी तरह से गठित नहीं हैं । JSON विनिर्देश इंगित करता है कि JSON दो संरचनाओं पर बनाया गया है: नाम / मूल्य जोड़ी (ऑब्जेक्ट) या मूल्यों की एक सूची की सूची (सरणी)।

तर्क : अपवाद से निपटने के लिए कुछ अपेक्षित नहीं किया जाना चाहिए।
(यह एक टिप्पणी है जिसमें 25+ अपवोट्स हैं!)

तथ्य : नहीं! यह निश्चित रूप से इस तरह के एक मामले में, विशेष रूप से कोशिश / पकड़ने का उपयोग करने के लिए कानूनी है। अन्यथा, आपको बहुत सारे स्ट्रिंग विश्लेषण सामान करने की आवश्यकता होगी जैसे कि टोकन / रेगेक्स संचालन; जिसका भयानक प्रदर्शन होगा।

hasJsonStructure()

यह उपयोगी है यदि आपका लक्ष्य यह जांचने के लिए है कि कुछ डेटा / टेक्स्ट में JSON इंटरचेंज प्रारूप उचित है या नहीं।

function hasJsonStructure(str) {
    if (typeof str !== 'string') return false;
    try {
        const result = JSON.parse(str);
        const type = Object.prototype.toString.call(result);
        return type === '[object Object]' 
            || type === '[object Array]';
    } catch (err) {
        return false;
    }
}

उपयोग:

hasJsonStructure('true')             // —» false
hasJsonStructure('{"x":true}')       // —» true
hasJsonStructure('[1, false, null]') // —» true

safeJsonParse()

और यह तब उपयोगी है जब आप किसी डेटा को जावास्क्रिप्ट मूल्य पर पार्स करते समय सावधान रहना चाहते हैं।

function safeJsonParse(str) {
    try {
        return [null, JSON.parse(str)];
    } catch (err) {
        return [err];
    }
}

उपयोग:

const [err, result] = safeJsonParse('[Invalid JSON}');
if (err) {
    console.log('Failed to parse JSON: ' + err.message);
} else {
    console.log(result);
}

Comments

आप JSON Spec से लिंक करते हैं, निम्नलिखित कहता है: "JSON टेक्स्ट यूनिकोड कोड पॉइंट्स से बने टोकन का एक अनुक्रम है जो JSON मूल्य व्याकरण के अनुरूप है।" और "A JSON मान ऑब्जेक्ट, सरणी, संख्या, स्ट्रिंग, सही, गलत या अशक्त हो सकता है।" - आप इस निष्कर्ष पर कैसे पहुंचे कि एक JSON केवल मूल स्तर पर ऑब्जेक्ट या सरणी हो सकता है? मैं इस कल्पना में नहीं देख सकता, और न ही "अच्छी तरह से बनाई गई JSON संरचनाओं" के बारे में कुछ भी

— Relequestual

पढ़ें दूसरा पैराग्राफ उस के साथ शुरू होता है "JSON दो संरचनाओं पर बनाया गया है ..." @ json.org या की 4 और 5 वीं पैरा ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf

— ओनुर Yıldırım

json.org केवल सूचनात्मक है। आपके द्वारा जुड़ी गई युक्ति को पढ़ने से आपके सुझाव का समर्थन नहीं होता है। कल्पना में RFC 8259 का नवीनतम RFC के रूप में उल्लेख है। मान्य JSON टेक्स के उदाहरणों पर एक नज़र डालें, जिसमें केवल वेल्यू टूल्स .ietf.org / html / rfc8259#section - 13 - RFC 8259 को इस तरह से संभव अस्पष्टताओं और भ्रमों को हल करने के लिए डिज़ाइन किया गया है।

— रीलेक्वेस्टल

जवाब फिर से पढ़ें। मैं मान रहा हूँ जैसे कि आदिम (RFC उदाहरणों में पाठ मान) JSON "संरचना" नहीं है। कोई अस्पष्टता नहीं है। आप उन्हें JSON कह सकते हैं, ऐसा करना मान्य है। लेकिन वे संरचित डेटा नहीं हैं। JSON को मुख्य रूप से एक इंटरचेंज प्रारूप के रूप में आविष्कार किया जाता है »जो संरचित डेटा के लिए उपयोग किया जाता है» जो एक वस्तु या सरणी हो सकता है।

— ओनुर येल्ड्रिम

ठीक है, तो मुझे लगता है कि हम सहमत हैं। प्रिमिटिव्स विनिर्देशन के अनुसार वैध JSON हैं, लेकिन "संरचनाएं" नहीं हैं। कोई बात नहीं। लेकिन, आपने कहा "तर्क: सत्य, असत्य, अशक्त जैसे मान मान्य JSON (?) हैं। तथ्य: हाँ और नहीं!" - तथ्य विनिर्देशन के अनुसार वैध JSON हैं। इस तथ्य पर राय कि वे उपयोगी हैं या नहीं, इस तथ्य के लिए अप्रासंगिक हैं।

— रीलेक्वेस्टल

Answer 4

यदि सर्वर JSON के साथ प्रतिक्रिया कर रहा है, तो उसके पास एक application/jsonसामग्री-प्रकार होगा, यदि वह एक सादे पाठ संदेश के साथ जवाब दे रहा है, तो उसके पास text/plainसामग्री-प्रकार होना चाहिए । सुनिश्चित करें कि सर्वर सही सामग्री-प्रकार के साथ प्रतिक्रिया कर रहा है और परीक्षण करें।

Comments

यह गलत है, कई अन्य जैसन-संगत मेडियाटिप हैं। इसके अलावा overrideMimeTypeसामग्री प्रकार हेडर को ओवरराइड कर सकते हैं।

— क्नू

Answer 5

jQuery $.ajax()प्रतिक्रिया का उपयोग करते समय responseJSONसंपत्ति होगी यदि प्रतिक्रिया JSON थी, तो इसे इस तरह से चेक किया जा सकता है:

if (xhr.hasOwnProperty('responseJSON')) {}

Comments

यह मुझे संदेह है कि वास्तव में जवाब है कि ज्यादातर लोग तलाश कर रहे हैं, शायद यहां तक ​​कि ओपी

— किर्बी

यह कोशिश पकड़ने वाले ब्लॉक का उपयोग करने की तुलना में बहुत अधिक सुरुचिपूर्ण है

— अनुराग सिन्हा

Answer 6

मुझे सबसे अच्छा जवाब पसंद है लेकिन अगर यह एक खाली स्ट्रिंग है तो यह सच है। तो यहाँ एक तय है:

function isJSON(MyTestStr){
    try {
        var MyJSON = JSON.stringify(MyTestStr);
        var json = JSON.parse(MyJSON);
        if(typeof(MyTestStr) == 'string')
            if(MyTestStr.length == 0)
                return false;
    }
    catch(e){
        return false;
    }
    return true;
}

Comments

var json का उपयोग नहीं किया गया है? या सिर्फ त्रुटि को पकड़ने के लिए?

— स्टैकडेव

Answer 7

var parsedData;

try {
    parsedData = JSON.parse(data)
} catch (e) {
    // is not a valid JSON string
}

हालाँकि, मैं आपको सुझाव दूंगा कि आपकी http कॉल / सेवा हमेशा एक ही प्रारूप में एक डेटा लौटाए। इसलिए यदि आपके पास कोई त्रुटि है, तो आपके पास एक JSON ऑब्जेक्ट होना चाहिए जो इस त्रुटि को लपेटता है:

{"error" : { "code" : 123, "message" : "Foo not supported" } } 

और शायद HTTP स्थिति 5xx कोड का भी उपयोग करें।

Answer 8

खैर ... यह आपके डेटा प्राप्त करने के तरीके पर निर्भर करता है। मुझे लगता है कि सर्वर JSON तैयार स्ट्रिंग (PHP, जैसे json_encode () का उपयोग करके) के साथ प्रतिक्रिया कर रहा है। यदि आप JQuery पोस्ट का उपयोग कर रहे हैं और प्रतिक्रिया डेटा सेट करने के लिए एक JSON प्रारूप है और यह एक विकृत JSON है, तो यह एक त्रुटि उत्पन्न करेगा:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        //Supposing x is a JSON property...
        alert(response.x);

  },
  dataType: 'json',
  //Invalid JSON
  error: function (){ alert("error!"); }
});

लेकिन, यदि आप पाठ के रूप में प्रकार की प्रतिक्रिया का उपयोग कर रहे हैं, तो आपको $ .parseJSON का उपयोग करने की आवश्यकता है। Jquery साइट के अनुसार: "एक विकृत JSON स्ट्रिंग में पास होने के परिणामस्वरूप एक अपवाद को फेंक दिया जा सकता है"। इस प्रकार आपका कोड होगा:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        try {
            parsedData = JSON.parse(response);
        } catch (e) {
            // is not a valid JSON string
        }

  },
  dataType: 'text',
});

Comments

जब तक, निश्चित रूप से आप उपरोक्त उदाहरण में त्रुटि फ़ंक्शन में त्रुटि पाठ को पार्स करने की कोशिश कर रहे हैं और यह सुनिश्चित नहीं है कि यह JSON है ...

— Kirby

शानदार उत्तर, हालाँकि यदि responseखाली है, तो यह जाएगा success: '(

— हेनरिक पेटर्सन

Answer 9

उदाहरण के लिए, संभवतः आप ऐसे परीक्षण कर सकते हैं, यदि आप जानते हैं कि JSON लौटाया जा रहा है, तो वह हमेशा घिरे रहने वाला है {और }फिर आप उन वर्णों के लिए परीक्षण कर सकते हैं, या कोई अन्य हैक करने का तरीका। या आप json.org JS लाइब्रेरी का उपयोग करने की कोशिश कर सकते हैं और इसे पार्स और परीक्षण कर सकते हैं यदि यह सफल होता है।

मैं हालांकि एक अलग दृष्टिकोण का सुझाव दूंगा। यदि कॉल सफल हो, तो आपकी PHP स्क्रिप्ट वर्तमान में JSON लौटाती है, लेकिन ऐसा नहीं होने पर कुछ और। हमेशा क्यों नहीं JSON लौटाते?

उदाहरण के लिए

सफल कॉल:

{ "status": "success", "data": [ <your data here> ] }

त्रुटिपूर्ण कॉल:

{ "status": "error", "error": "Database not found" }

यह आपके क्लाइंट पक्ष को JS को बहुत आसान बना देगा - आपको बस इतना करना है कि "स्थिति" के सदस्य और उसके अनुसार कार्य की जाँच करें।

Answer 10

मैं प्रदर्शन करने के लिए सिर्फ 2 लाइनों का उपयोग करता हूं:

var isValidJSON = true;
try { JSON.parse(jsonString) } catch { isValidJSON = false }

बस इतना ही!

लेकिन ध्यान रखें कि 2 जाल हैं:
1. JSON.parse(null)रिटर्न null
2. JSON.parse()विधि के साथ किसी भी संख्या या स्ट्रिंग को पार्स किया जा सकता है ।
   JSON.parse("5")प्रतिफल 5
   JSON.parse(5)मिलता है5

कुछ कोड पर खेलते हैं:

// TEST 1
var data = '{ "a": 1 }'

// Avoiding 'null' trap! Null is confirmed as JSON.
var isValidJSON = data ? true : false
try { JSON.parse(data) } catch(e) { isValidJSON = false }

console.log("data isValidJSON: ", isValidJSON);
console.log("data isJSONArray: ", isValidJSON && JSON.parse(data).length ? true : false);

Console outputs:
data isValidJSON:  true
data isJSONArray:  false


// TEST 2
var data2 = '[{ "b": 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data2) } catch(e) { isValidJSON = false }

console.log("data2 isValidJSON: ", isValidJSON);
console.log("data2 isJSONArray: ", isValidJSON && JSON.parse(data2).length ? true : false);

Console outputs:
data2 isValidJSON:  true
data2 isJSONArray:  true


// TEST 3
var data3 = '[{ 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data3) } catch(e) { isValidJSON = false }

console.log("data3 isValidJSON: ", isValidJSON);
console.log("data3 isJSONArray: ", isValidJSON && JSON.parse(data3).length ? true : false);

Console outputs:
data3 isValidJSON:  false
data3 isJSONArray:  false


// TEST 4
var data4 = '2'

var isValidJSON = data ? true : false
try { JSON.parse(data4) } catch(e) { isValidJSON = false }

console.log("data4 isValidJSON: ", isValidJSON);
console.log("data4 isJSONArray: ", isValidJSON && JSON.parse(data4).length ? true : false);


Console outputs:
data4 isValidJSON:  true
data4 isJSONArray:  false


// TEST 5
var data5 = ''

var isValidJSON = data ? true : false
try { JSON.parse(data5) } catch(e) { isValidJSON = false }

console.log("data5 isValidJSON: ", isValidJSON);
console.log("data5 isJSONArray: ", isValidJSON && JSON.parse(data5).length ? true : false);


Console outputs:
data5 isValidJSON:  false
data5 isJSONArray:  false

// TEST 6
var data6; // undefined

var isValidJSON = data ? true : false
try { JSON.parse(data6) } catch(e) { isValidJSON = false }

console.log("data6 isValidJSON: ", isValidJSON);
console.log("data6 isJSONArray: ", isValidJSON && JSON.parse(data6).length ? true : false);

Console outputs:
data6 isValidJSON:  false
data6 isJSONArray:  false

Comments

मैंने jsfiddle.net/fatmonk/gpn4eyav पर इस उत्तर के लिए एक फिडेल बनाया है जिसमें आपके स्वयं के उपयोगकर्ता परीक्षण डेटा को जोड़ने का विकल्प भी शामिल है। यह मेरे लिए एक अच्छे पुस्तकालय समारोह के आधार जैसा दिखता है, लेकिन मैं इस बारे में अधिक समझना चाहूंगा कि टेस्ट 1 एक वैध JSON सरणी क्यों नहीं है।

— मोटा भिक्षु

क्योंकि एक सरणी का उपयोग करके निर्दिष्ट किया जाना चाहिए [और ]। उदाहरण के लिए, [1, 2, 3]एक संख्या सरणी है। ["a", "b", "c"]एक स्ट्रिंग सरणी है। और [{"a":1}, {"b":2}]एक JSON सरणी है। आपका jsfiddle काम वास्तव में उपयोगी लगता है!

— 13

इतना सरल है?! तो टेस्ट 1 एक JSON ऑब्जेक्ट है और टेस्ट 2 एक JSON सरणी है जिसमें एकल JSON ऑब्जेक्ट तत्व शामिल है। क्या मैं इसे सही तरीके से समझ पाया हूं?

— मोटा भिक्षु

प्रश्न इस के एक संभावित डुप्लिकेट के रूप में चिह्नित किया गया था ( stackoverflow.com/questions/3710204/… ) कोशिश / कैच का उपयोग किए बिना इसे प्राप्त करने के बारे में पूछता है, इसलिए मैंने अपने लक्ष्य को हासिल करने के लिए उस लक्ष्य को प्राप्त करने की कोशिश की। कांटा jsfiddle.net/fatmonk/827jsuvr पर है और उपरोक्त सभी परीक्षणों के साथ काम करता है सिवाय टेस्ट 3 के जो त्रुटियों पर JSON.parse। क्या कोई यह सलाह दे सकता है कि बिना प्रयास किए उस त्रुटि से कैसे बचा जाए?

— मोटा भिक्षु

आपके jsfiddleआवेदन में त्रुटि है क्योंकि टेस्ट 3 में वैध JSON अभिव्यक्ति नहीं है। तो try-catchउस त्रुटि को पकड़ने के लिए और अभिव्यक्ति के रूप में किसी भी त्रुटि का मूल्यांकन करने के लिए उपयोग किया जाना चाहिए, जब JSON ऊपर टेस्ट 3 की तरह पार्स नहीं कर रहा हो:try { JSON.parse(data3) } catch(e) { isValidJSON = false }

— efkan

Answer 11

आप इसे डिकोड करने और अपवाद को पकड़ने की कोशिश कर सकते हैं (देशी या json2.js ):

try {
  newObj = JSON.parse(myJsonString);
} catch (e) {
  console.log('Not JSON');
}

हालाँकि, मैं सुझाव दूंगा कि प्रतिक्रिया हमेशा मान्य JSON हो। यदि आपको अपनी MySQL क्वेरी से कोई त्रुटि मिलती है, तो बस JSON को त्रुटि के साथ वापस भेजें:

{"error":"The MySQL error string."}

और तब:

if (myParsedJSON.error) {
  console.log('An error occurred: ' + myParsedJSON.error);
}

Answer 12

चेतावनी: तरीकों पर भरोसा करने के लिए JSON.parse- ऐरे और उद्धरण घिरे तार भी (यानी।console.log(JSON.parse('[3]'), JSON.parse('"\uD800"')) )

सभी गैर-वस्तु JSON प्राइमेटिव (बूलियन, नल, सरणी, संख्या, स्ट्रिंग) से बचने के लिए, मैं निम्नलिखित का उपयोग करने का सुझाव देता हूं:

/* Validate a possible object ie. o = { "a": 2 } */
const isJSONObject = (o) => 
  !!o && (typeof o === 'object') && !Array.isArray(o) && 
  (() => { try { return Boolean(JSON.stringify(o)); } catch { return false } })()

/* Validate a possible JSON object represented as string ie. s = '{ "a": 3 }' */
function isJSONObjectString(s) {
    try {
        const o = JSON.parse(s);
        return !!o && (typeof o === 'object') && !Array.isArray(o)
    } catch {
        return false
    }
}

कोड स्पष्टीकरण

• !! ओ - मिथ्या नहीं है (अशक्त को छोड़कर, जो टाइपोफ 'ऑब्जेक्ट' के रूप में पंजीकृत है)
• (टाइपऑफ ओ === 'ऑब्जेक्ट') - बूलियन, संख्या और स्ट्रिंग को छोड़ देता है
• Array.isArray (o) - सरणियों को छोड़ दें (जो टाइपोफ़ 'ऑब्जेक्ट' के रूप में पंजीकृत हैं)
• प्रयास करें ... JSON.stringify / JSON.parse - मान्य JSON का निर्धारण करने के लिए जावास्क्रिप्ट इंजन पूछता है

HasJsonStructure () उत्तर का उपयोग क्यों नहीं करें?

पर भरोसा toString() अच्छा विचार नहीं है। ऐसा इसलिए है क्योंकि विभिन्न जावास्क्रिप्ट इंजन एक अलग स्ट्रिंग प्रतिनिधित्व लौटा सकते हैं। सामान्य तौर पर, इस पर निर्भर करने वाले तरीके अलग-अलग वातावरण में विफल हो सकते हैं या बाद में विफल हो सकते हैं, इंजन को कभी स्ट्रिंग परिणाम बदलना चाहिए

एक अपवाद हैक क्यों नहीं पकड़ रहा है?

यह लाया गया था कि किसी चीज की वैधता का निर्धारण करने के लिए अपवाद को पकड़ना कभी भी सही रास्ता नहीं है। यह आमतौर पर अच्छी सलाह है, लेकिन हमेशा नहीं। इस मामले में, अपवाद को पकड़ने की संभावना सबसे अच्छा मार्ग है क्योंकि यह जावास्क्रिप्ट इंजन को JSON डेटा को मान्य करने के कार्यान्वयन पर निर्भर करता है।

जेएस इंजन पर भरोसा करने से निम्नलिखित लाभ मिलते हैं:

1. JSON कल्पना में परिवर्तन के रूप में अधिक गहन और लगातार अप-टू-डेट
2. तेजी से चलाने के लिए संभव है (क्योंकि यह निचले स्तर का कोड है)

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

Answer 13

यहां बॉर्न के जवाब में कुछ मामूली संशोधन के साथ एक कोड है। चूंकि JSON.parse (संख्या) बिना किसी अपवाद के ठीक काम करता है, इसलिए isNaN जोड़ा गया।

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return isNaN(str);
}

Answer 14

सभी json तार '{' या '[' से शुरू होते हैं और इसी '}' या ']' के साथ समाप्त होते हैं, इसलिए बस उसी की जाँच करें।

यहां बताया गया है कि Angular.js इसे कैसे करता है:

var JSON_START = /^\[|^\{(?!\{)/;
var JSON_ENDS = {
  '[': /]$/,
  '{': /}$/
};

function isJsonLike(str) {
    var jsonStart = str.match(JSON_START);
    return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
}

https://github.com/angular/angular.js/blob/v1.6.x/src/ng/http.js

Comments

@DukeDougal देखभाल स्पष्ट करने के लिए? कभी-कभी लोग एक '[' के साथ अपना जुसन शुरू करते हैं, लेकिन यह बहुत सामान्य नहीं है।

— carlin.scott

आपको इसे बाहर काम करने के लिए पार्स करने की आवश्यकता है जो वैध JSON है। यदि यह JSON अमान्य है तो यह JSON नहीं है। सवाल यह है कि "कैसे बताएं कि एक स्ट्रिंग JSON है या नहीं?"। आपके दृष्टिकोण से, यह JSON {रेशेदार - होगा और यह वास्तव में JSON नहीं है। अपने दम पर नंबर 1 जैसे मामलों पर भी विचार करें - जो वैध JSON है।

— ड्यूक डगल

"यदि यह अमान्य JSON है तो यह JSON नहीं है"। तथ्य यह है कि आपको "वैध" शब्द का उपयोग करना है, यह दर्शाता है कि आप इस तथ्य के लिए एक योग्यता जोड़ रहे हैं कि यह सिर्फ json से अधिक है। सवाल बस यह था कि "क्या यह जस का तस है" और मेरे कोड उदाहरण का जवाब है कि अतिरिक्त आवश्यकताओं को संभालने के बिना पूरी तरह से सवाल है।

— carlin.scott

बुरा विचार यदि आप कुछ टेम्पलेट सिस्टम का उपयोग कर रहे हैं और आपके पास कुछ ऐसा है जो { someValue }स्वचालित रूप से सत्यापन पास करेगा।

— ncubica

@ncubica इसलिए आप json के अलावा किसी अन्य चीज़ के लिए टेम्पलेट का उपयोग कर रहे हैं, स्ट्रिंग में केवल एक प्लेसहोल्डर है जो घुंघराले ब्रेसिज़ का उपयोग करता है, और टेम्पलेट इंजन वास्तविक मूल्य के साथ प्लेसहोल्डर को बदलने में विफल रहता है? यह भी ध्यान रखें, जैसे मैंने पहले ही ड्यूक को समझाया था, मूल प्रश्न में सत्यापन का उल्लेख नहीं है। वे केवल यह जानना चाहते थे कि यह जौन की तरह दिखता है या नहीं।

— carlin.scott

Answer 15

मैं टाइपस्क्रिप्ट मोड में सुझाव देता हूं:

export function stringify(data: any): string {
    try {
         return JSON.stringify(data)
    } catch (e) {
         return 'NOT_STRINGIFIABLE!'
    }
}

Answer 16

मैंने इस एक का उपयोग किया (विभिन्न उत्तरों के मिश्रण का, लेकिन फिर भी):

const isJSON = str => {
  if (typeof str === 'string'){
    try {
      JSON.parse(str)
      return true
    } catch(e){
    }
  }
  return false
}



[null, undefined, false, true, [], {}, 
 '', 'asdf', '{}', '[]', "{\"abc\": 2}","{\"abc\": \"2\"}"]
  .map(el => {
      console.log(`[>${el}<] - ${isJSON(el)}`)
})

console.log('-----------------')

Answer 17

आप निम्न की कोशिश कर सकते हैं क्योंकि यह संख्या, अशक्त, स्ट्रिंग को मान्य करता है, लेकिन उपरोक्त चिह्नित उत्तर सही ढंग से काम नहीं कर रहा है, यह उपरोक्त फ़ंक्शन का केवल एक निर्धारण है:

function isJson(str) {
  try {
      const obj = JSON.parse(str);
      if (obj && typeof obj === `object`) {
        return true;
      }
    } catch (err) {
      return false;
    }
   return false;
}

Answer 18

पिछले उत्तरों के अलावा, आपको "{}" जैसे JSON प्रारूप को मान्य करने की आवश्यकता है, आप निम्नलिखित कोड का उपयोग कर सकते हैं:

const validateJSON = (str) => {
  try {
    const json = JSON.parse(str);
    if (Object.prototype.toString.call(json).slice(8,-1) !== 'Object') {
      return false;
    }
  } catch (e) {
    return false;
  }
  return true;
}

उपयोग के उदाहरण:

validateJSON('{}')
true
validateJSON('[]')
false
validateJSON('')
false
validateJSON('2134')
false
validateJSON('{ "Id": 1, "Name": "Coke" }')
true