วิธีตรวจสอบว่าสตริงเป็นสตริง JSON ที่ถูกต้องใน JavaScript โดยไม่ต้องใช้ลอง / จับ

สิ่งที่ต้องการ:

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

//should be true
IsJsonString(jsonString);

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

การแก้ปัญหาไม่ควรมีลอง / จับ พวกเราบางคนเปิดใช้งาน "หยุดข้อผิดพลาดทั้งหมด" และพวกเขาไม่ต้องการให้ดีบั๊กตัวแบ่งสตริง JSON ที่ไม่ถูกต้อง

ความคิดเห็นแรก 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 รุ่นใหม่ทำให้การแยกวิเคราะห์ขั้นสูงกว่าข้างต้น แต่ยังคงอยู่บนพื้นฐานของการแทนที่ regexp (จากความคิดเห็นของ @Mrchief )

ใช้ตัวแยกวิเคราะห์ JSON เช่นJSON.parse:

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

ฉันรู้ว่าฉันมาสายคำถามนี้มา 3 ปีแล้ว แต่ฉันก็รู้สึกอยากตีระฆัง

ในขณะที่วิธีแก้ปัญหาของ Gumbo นั้นใช้งานได้ดี แต่ก็ไม่ได้จัดการกับบางกรณีที่ไม่มีข้อยกเว้นเกิดขึ้น 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;
};

// 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

นี่คือรหัสการทำงานของฉัน:

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

ฉันใช้วิธีที่ง่ายมากในการตรวจสอบสตริงว่า 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;

ผลลัพธ์ที่มีอินพุต Null:

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

คนสุดท้ายส่งกลับเท็จเพราะประเภทของตัวแปร null เป็นวัตถุ

ใช้ได้ผลทุกครั้ง :)

ใน prototypeJS เรามีวิธีการisJSON คุณสามารถลอง แม้แต่jsonก็อาจช่วยได้

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

จาก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 }" ) )

คำตอบนี้เพื่อลดต้นทุนของคำสั่ง trycatch

ฉันใช้ JQuery เพื่อแยกสตริง JSON และฉันใช้คำสั่ง trycatch เพื่อจัดการข้อยกเว้น แต่การโยนข้อยกเว้นสำหรับสตริงที่ไม่สามารถแยกวิเคราะห์ได้ทำให้โค้ดของฉันช้าลงดังนั้นฉันจึงใช้ Regex ง่าย ๆ ในการตรวจสอบสตริงว่าเป็นสตริง JSON ที่เป็นไปได้หรือไม่ โดยตรวจสอบไวยากรณ์มันแล้วฉันใช้วิธีปกติโดยแยกสตริงโดยใช้ JQuery:

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

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

}

ฉันใส่โค้ดก่อนหน้าในฟังก์ชันเวียนเกิดเพื่อแยกการตอบสนอง JSON ที่ซ้อนกัน

อาจจะมีประโยชน์:

    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: สตริง , วัตถุ, สตริง, สตริง

โครม: วัตถุวัตถุสตริงสตริง

ฉันคิดว่าฉันรู้ว่าทำไมคุณต้องการหลีกเลี่ยง แต่อาจลอง & catch! == ลองและจับ ; o) สิ่งนี้อยู่ในใจของฉัน:

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; }};

เนื่องจากสิ่งนี้ถูกห่อหุ้มไว้มากที่สุดจึงอาจไม่ผิดพลาด

นี่คือเวอร์ชัน typescript ด้วย:

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;
};

ฉันอนุมานจากความคิดเห็นในการเปิดว่ากรณีการใช้งานเป็นการวิเคราะห์ว่าคำตอบคือ HTML หรือ JSON ซึ่งในกรณีนี้เมื่อคุณทำรับ JSON คุณอาจควรจะแยกมันและการจัดการ JSON ที่ไม่ถูกต้องที่จุดในรหัสของคุณบางอยู่แล้ว นอกเหนือจากสิ่งใดฉันคิดว่าคุณต้องการรับทราบโดยเบราว์เซอร์ของคุณควรคาดว่า JSON แต่ได้รับ JSON ที่ไม่ถูกต้อง

การทำ regex แบบเต็มสำหรับ 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 ในเวลาเดียวกัน

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

หวังว่าสิ่งนี้จะได้ผลกับคุณเช่นกัน

function get_json(txt)
{  var data

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

   return data;
}

หากมีข้อผิดพลาดส่งคืนเท็จ

หากไม่มีข้อผิดพลาดส่งคืนข้อมูล json

คุณสามารถใช้ฟังก์ชัน javascript 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.parseฟังก์ชั่นจากjson.org :

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

if (json) {
  //this is json
}

หวังว่านี่จะช่วยได้

คำเตือน : eval()เป็นอันตรายหากมีคนเพิ่มรหัส JS ที่เป็นอันตรายเนื่องจากมันจะดำเนินการ ตรวจสอบให้แน่ใจว่า JSON String นั้นเชื่อถือได้เช่นคุณได้มาจากแหล่งที่เชื่อถือได้

แก้ไขสำหรับวิธีที่ 1 ของฉันขอแนะนำให้ทำเช่นนี้

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

เพื่อรับประกัน json-ness หากjsonStringJSON ไม่บริสุทธิ์ eval จะส่งข้อยกเว้น

โอ้คุณสามารถลองลองใช้เพื่อตรวจสอบว่าเป็น 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}')

ฟังก์ชั่นIsJsonString(str)ที่ใช้JSON.parse(str)ไม่ทำงานในกรณีของฉัน
ฉันพยายามตรวจสอบ json output จากGraphiQLมันจะคืนค่า false เสมอ โชคดีฉัน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

สำหรับคนที่ชอบการประชุมแบบ. net ของ "ลอง" ฟังก์ชั่นที่ส่งกลับค่าบูลีนและจัดการกับพารามิเตอร์ไบต์ที่มีผลลัพธ์ หากคุณไม่ต้องการพารามิเตอร์ out คุณสามารถละเว้นมันได้และใช้ค่าส่งคืน

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
});

โค้ดหนึ่งซับง่ายมาก (แต่ใช้วิธีแฮ็ค)

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

หมายเหตุ: ใช้งานได้เฉพาะเมื่อคุณคาดหวังว่าบางสิ่งบางอย่างเป็นสตริง JSON เช่น id ฉันใช้มันสำหรับ API และคาดหวังผลลัพธ์ใน JSON หรือสตริงข้อผิดพลาดบางอย่าง