Cách kiểm tra xem một chuỗi có phải là chuỗi JSON hợp lệ trong JavaScript hay không mà không cần sử dụng Thử / Bắt

Cái gì đó như:

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

//should be true
IsJsonString(jsonString);

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

Các giải pháp không nên chứa thử / bắt. Một số người trong chúng ta bật "phá vỡ tất cả các lỗi" và họ không thích trình gỡ lỗi phá vỡ các chuỗi JSON không hợp lệ đó.

Một bình luận đầu tiên. Câu hỏi là về việc không sử dụng try/catch.
Nếu bạn không phiền khi sử dụng nó, hãy đọc câu trả lời dưới đây. Ở đây chúng tôi chỉ kiểm tra một JSONchuỗi bằng cách sử dụng biểu thức chính, và nó sẽ hoạt động trong hầu hết các trường hợp, không phải tất cả các trường hợp.

Có một cái nhìn xung quanh dòng 450 trong https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Có một biểu thức chính để kiểm tra JSON hợp lệ, đại loại như:

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

}

EDIT : Phiên bản mới của json2.js tạo phân tích cú pháp nâng cao hơn so với ở trên, nhưng vẫn dựa trên thay thế regrec (từ nhận xét của @Mrchief )

Sử dụng trình phân tích cú pháp JSON như JSON.parse:

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

Tôi biết tôi trễ 3 năm với câu hỏi này, nhưng tôi cảm thấy như đang chen vào.

Mặc dù giải pháp của Gumbo hoạt động rất tốt, nhưng nó không xử lý một vài trường hợp không có ngoại lệ nào được nêu ra cho JSON.parse({something that isn't JSON})

Tôi cũng thích trả về JSON được phân tích cùng một lúc, vì vậy mã gọi không phải gọi JSON.parse(jsonString)lần thứ hai.

Điều này dường như hoạt động tốt cho nhu cầu của tôi:

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

Cách sử dụng: isJSON({}) sẽ được false, isJSON('{}')sẽ có true.

Để kiểm tra xem một cái gì đó là một Arrayhoặc Object( phân tích cú pháp 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;

Cách sử dụng: isAO({}) sẽ được true, isAO('{}')sẽ có false.

Đây là mã làm việc của tôi:

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

Tôi đã sử dụng một phương thức thực sự đơn giản để kiểm tra một chuỗi xem đó có phải là JSON hợp lệ hay không.

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

Kết quả với một chuỗi JSON hợp lệ:

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

Kết quả với một chuỗi đơn giản;

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

Kết quả với một đối tượng:

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

Kết quả với đầu vào null:

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

Cái cuối cùng trả về false vì loại biến null là đối tượng.

Điều này hoạt động mọi lúc. :)

Trong nguyên mẫuJS , chúng ta có phương thức isJSON . Bạn có thể thử điều đó. Ngay cả json cũng có thể giúp đỡ.

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

Từ String.isJSONđịnh nghĩa khung Prototype tại đây

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

Vì vậy, đây là phiên bản có thể được sử dụng để truyền một đối tượng chuỗi

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

Câu trả lời này để giảm chi phí của tuyên bố trycatch.

Tôi đã sử dụng JQuery để phân tích các chuỗi JSON và tôi đã sử dụng câu lệnh trycatch để xử lý các ngoại lệ, nhưng việc ném các ngoại lệ cho các chuỗi không thể phân tích cú pháp đã làm chậm mã của tôi, vì vậy tôi đã sử dụng Regex đơn giản để kiểm tra chuỗi đó có phải là chuỗi JSON có thể hay không bằng cách kiểm tra cú pháp của nó, sau đó tôi đã sử dụng cách thông thường bằng cách phân tích chuỗi bằng JQuery:

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

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

}

Tôi đã bọc mã trước đó trong một hàm đệ quy để phân tích các phản hồi JSON lồng nhau.

Có lẽ nó sẽ hữu ích:

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

đầu ra:

IE7: chuỗi , đối tượng, chuỗi, chuỗi

CHROME: đối tượng, đối tượng, chuỗi, chuỗi

Tôi nghĩ tôi biết tại sao bạn muốn tránh điều đó. Nhưng có thể thử và bắt! == thử & bắt. ; o) Điều này xuất hiện trong tâm trí của tôi:

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

Vì vậy, bạn cũng có thể làm bẩn clip đối tượng JSON, như:

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

Vì điều này được gói gọn nhất có thể, nó có thể không bị lỗi.

Đây cũng là phiên bản bản thảo:

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

Tôi suy luận từ nhận xét mở đầu rằng ca sử dụng đang phân định xem phản hồi là HTML hay JSON. Trong trường hợp này, khi bạn làm nhận JSON, bạn có lẽ nên được phân tích nó và xử lý JSON không hợp lệ tại một số điểm trong mã của bạn anyway. Ngoài mọi thứ, tôi tưởng tượng bạn muốn được trình duyệt của mình thông báo nếu JSON được mong đợi nhưng nhận được JSON không hợp lệ (người dùng cũng sẽ ủy quyền bằng một số thông báo lỗi có ý nghĩa)!

Do đó, thực hiện một regex đầy đủ cho JSON là không cần thiết (theo kinh nghiệm của tôi - đối với hầu hết các trường hợp sử dụng). Bạn có thể sẽ tốt hơn khi sử dụng một cái gì đó như dưới đây:

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

điều đó sẽ giúp bạn tiết kiệm được việc xử lý ngoại lệ mã phi JSON hợp lệ và chăm sóc duff json cùng một lúc.

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

hy vọng điều này cũng có hiệu quả với bạn

function get_json(txt)
{  var data

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

   return data;
}

Nếu có lỗi, trả về false.

Nếu không có lỗi, trả về dữ liệu json

Bạn có thể sử dụng hàm javascript eval () để xác minh xem nó có hợp lệ không.

ví dụ

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
}

Ngoài ra, bạn có thể sử dụng JSON.parsechức năng từ json.org :

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

if (json) {
  //this is json
}

Hi vọng điêu nay co ich.

CẢNH BÁO : eval()là nguy hiểm nếu ai đó thêm mã JS độc hại, vì nó sẽ thực hiện nó. Hãy chắc chắn rằng Chuỗi JSON đáng tin cậy , tức là bạn đã nhận được nó từ một nguồn đáng tin cậy.

Chỉnh sửa Đối với giải pháp đầu tiên của tôi, bạn nên làm điều này.

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

Để đảm bảo json-ness. Nếu jsonStringJSON không thuần túy, eval sẽ đưa ra một ngoại lệ.

Ồ, bạn chắc chắn có thể sử dụng thử bắt để kiểm tra xem JSON của nó có hợp lệ hay không

Đã thử nghiệm trên Firfox Quantom 60.0.1

sử dụng hàm bên trong một hàm để kiểm tra JSON và sử dụng đầu ra đó để xác thực chuỗi. nghe một ví dụ

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

Hàm IsJsonString(str)đang sử dụng JSON.parse(str)không hoạt động trong trường hợp của tôi.
Tôi đã cố gắng xác nhận đầu ra json từ GraphiQL, nó luôn trả về false. May mắn cho tôi, isson làm việc tốt hơn:

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

});

Đầu ra mẫu:

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

Đối với những người thích quy ước .Net của các hàm "thử" trả về giá trị boolean và xử lý một tham số byref chứa kết quả. Nếu bạn không cần tham số out, bạn có thể bỏ qua nó và chỉ sử dụng giá trị trả về.

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

Mã một lớp rất đơn giản (Nhưng cách tiếp cận Hacky)

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

LƯU Ý: Điều này chỉ hoạt động nếu bạn đang mong đợi một cái gì đó là chuỗi JSON như id. Tôi đang sử dụng nó cho một API và mong đợi kết quả trong JSON hoặc một số chuỗi lỗi.