Cara memeriksa apakah string adalah string JSON yang valid dalam JavaScript tanpa menggunakan Try / Catch

Sesuatu seperti:

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

//should be true
IsJsonString(jsonString);

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

Solusinya tidak boleh mengandung try / catch. Beberapa dari kita mengaktifkan "break on all errors" dan mereka tidak suka debugger memecahkan string JSON yang tidak valid itu.

Komentar dulu. Pertanyaannya adalah tentang tidak menggunakan try/catch.
Jika Anda tidak keberatan menggunakannya, baca jawaban di bawah ini. Di sini kita hanya memeriksa JSONstring menggunakan regexp, dan itu akan berfungsi dalam kebanyakan kasus, tidak semua kasus.

Lihat garis 450 di https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Ada regexp yang memeriksa JSON yang valid, seperti:

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 : Versi baru json2.js membuat penguraian lebih maju daripada di atas, tetapi masih didasarkan pada penggantian regexp (dari komentar @Mrchief )

Gunakan parser JSON seperti JSON.parse:

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

Saya tahu saya terlambat 3 tahun untuk pertanyaan ini, tetapi saya merasa ingin berdebat.

Meskipun solusi Gumbo bekerja sangat baik, solusi ini tidak menangani beberapa kasus di mana tidak ada pengecualian yang muncul JSON.parse({something that isn't JSON})

Saya juga lebih suka mengembalikan JSON yang diuraikan pada saat yang sama, sehingga kode panggilan tidak harus memanggil JSON.parse(jsonString)yang kedua kalinya.

Ini sepertinya bekerja dengan baik untuk kebutuhan saya:

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

Penggunaan: isJSON({}) akan false, isJSON('{}')akan true.

Untuk memeriksa apakah ada sesuatu Arrayatau Object( parsing 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;

Penggunaan: isAO({}) akan true, isAO('{}')akan false.

Di sini kode kerja saya:

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

Saya menggunakan metode yang sangat sederhana untuk memeriksa string bagaimana JSON yang valid atau tidak.

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

Hasil dengan string JSON yang valid:

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

Hasil dengan string sederhana;

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

Hasil dengan objek:

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

Hasil dengan input nol:

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

Yang terakhir mengembalikan false karena jenis variabel nol adalah objek.

Ini berfungsi setiap saat. :)

Dalam prototipeJS, kami memiliki metode isJSON . Anda bisa mencobanya. Bahkan json mungkin bisa membantu.

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

Dari String.isJSONdefinisi kerangka kerja Prototipe di sini

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

jadi ini adalah versi yang bisa digunakan lewat objek string

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

Jawaban ini untuk mengurangi biaya pernyataan trycatch.

Saya menggunakan JQuery untuk mem-parsing string JSON dan saya menggunakan pernyataan trycatch untuk menangani pengecualian, tetapi melempar pengecualian untuk string un-parsable memperlambat kode saya, jadi saya menggunakan Regex sederhana untuk memeriksa string jika itu adalah string JSON yang mungkin atau tidak tanpa menjadi bulu. dengan memeriksa sintaksnya, maka saya menggunakan cara biasa dengan mem-parsing string menggunakan JQuery:

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

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

}

Saya membungkus kode sebelumnya dalam fungsi rekursif untuk mem-parsing respon JSON bersarang.

Mungkin ini akan berguna:

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

keluaran:

IE7: string , objek, string, string

CHROME: objek, objek, string, string

Saya rasa saya tahu mengapa Anda ingin menghindarinya. Tapi mungkin coba & tangkap! == coba & tangkap. ; o) Ini muncul di benak saya:

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

Jadi, Anda juga dapat mengotori klip ke objek JSON, seperti:

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

Karena ini sebagai encapsuled mungkin, itu tidak dapat rusak karena kesalahan.

Ini juga versi naskahnya:

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

Saya menyimpulkan dari komentar pembukaan bahwa use case menggambarkan apakah suatu respons adalah HTML atau JSON. Dalam hal ini, ketika Anda melakukan menerima JSON, Anda mungkin seharusnya parsing dan penanganan JSON tidak valid di beberapa titik dalam kode Anda tetap. Selain dari apa pun, saya bayangkan Anda ingin diinformasikan oleh browser Anda jika JSON diharapkan tetapi JSON tidak valid diterima (seperti halnya pengguna dengan proksi dari beberapa pesan kesalahan yang berarti)!

Oleh karena itu, melakukan regex penuh untuk JSON tidak perlu (seperti yang akan - menurut pengalaman saya - untuk sebagian besar kasus penggunaan). Anda mungkin akan lebih baik menggunakan sesuatu seperti di bawah ini:

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

yang akan menyelamatkan Anda dari pengecualian menangani kode non-JSON yang valid dan mengurus duff json pada saat yang sama.

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

Saya harap ini juga bekerja untuk Anda

function get_json(txt)
{  var data

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

   return data;
}

Jika ada kesalahan, kembalikan salah.

Jika tidak ada kesalahan, kembalikan data json

Anda dapat menggunakan fungsi javascript eval () untuk memverifikasi apakah itu valid.

misalnya

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
}

Atau, Anda dapat menggunakan JSON.parsefungsi dari json.org :

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

if (json) {
  //this is json
}

Semoga ini membantu.

PERINGATAN : eval()ini berbahaya jika seseorang menambahkan kode JS berbahaya, karena akan melaksanakannya. Pastikan String JSON dapat dipercaya , yaitu Anda mendapatkannya dari sumber tepercaya.

Sunting Untuk solusi pertama saya, disarankan untuk melakukan ini.

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

Untuk menjamin ketidaknyamanan. Jika jsonStringJSON tidak murni, eval akan mengeluarkan pengecualian.

Oh, Anda pasti dapat menggunakan try catch untuk memeriksa apakah JSONnya valid atau tidak

Diuji pada Firfox Quantom 60.0.1

gunakan fungsi di dalam fungsi untuk mendapatkan JSON diuji dan gunakan output itu untuk memvalidasi string. mendengar contoh.

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

Fungsi IsJsonString(str), yang menggunakan JSON.parse(str), tidak berfungsi dalam kasus saya.
Saya mencoba untuk memvalidasi output json dari GraphiQL selalu mengembalikan false. Beruntung saya, isJSON bekerja lebih baik:

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

});

Output sampel:

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

Untuk orang-orang yang menyukai konvensi .Net dari fungsi "coba" yang mengembalikan boolean dan menangani parameter byref yang berisi hasilnya. Jika Anda tidak membutuhkan parameter keluar, Anda dapat menghilangkannya dan hanya menggunakan nilai balik.

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

Kode one-liner yang sangat sederhana (pendekatan But Hacky)

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

CATATAN: Ini hanya berfungsi jika Anda mengharapkan sesuatu string JSON seperti id. Saya menggunakannya untuk API dan mengharapkan hasilnya di JSON atau string kesalahan.