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


548

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.


25
Apakah ada alasan yang sah untuk tidak menggunakan try?
Nick T

7
@NickT Karena jika Anda mengaktifkan "break on all errors" di debugger, itu akan terjadi. Chrome sekarang memiliki opsi untuk memecahkan kesalahan yang tidak tertangkap.
Chi Chan

6
Gunakan hanya 2 baris untuk memeriksanya dengan try catch. var isValidJSON = true; coba {JSON.parse (jsonString)} catch {isValidJSON = false; }
efkan

18
Sementara itu berhasil, itu sangat kotor dan praktik yang buruk. Coba / tangkap dimaksudkan untuk penanganan perilaku dan kesalahan yang luar biasa, bukan alur program umum.
Tasgall

7
@ Targall Sebagai aturan umum, ya. Tetapi apa yang Anda lakukan jika pendekatan coba / tangkap lebih performan daripada pendekatan berbasis validator? Pergi dengan opsi (kadang-kadang secara signifikan) lebih lambat hanya karena alternatifnya adalah "praktik buruk"? Secara fungsional tidak ada yang salah dengan metode coba / tangkap, jadi tidak ada alasan untuk tidak menggunakannya. Sangat penting untuk memiliki programmer baru mengembangkan standar pengkodean yang baik, tetapi sama pentingnya untuk tidak memperkuat kepatuhan buta terhadap pedoman konvensional, terutama dalam kasus di mana pedoman membuat hal-hal lebih sulit daripada yang seharusnya.
Abion47

Jawaban:


172

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 )


59
Ini hanya memeriksa apakah kode aman untuk digunakan eval. Misalnya string berikut '2011-6-27' akan lulus tes itu.
SystemicPlural

4
@ SystemicPlural, ya tapi pertanyaannya adalah tentang tidak menggunakan try / catch
Mic

8
Anda tidak dapat menguji apakah suatu string adalah JSON yang valid dengan regex dalam JavaScript, karena JS regex tidak mendukung ekstensi yang diperlukan (regex rekursif) yang memungkinkan Anda melakukannya. Kode Anda di atas gagal pada "{".
Pembalasan

2
@Mic json2.js tidak lagi menggunakan pemeriksaan sederhana itu (melainkan menggunakan penguraian 4 tahap untuk menentukan JSON yang valid). Sarankan untuk merevisi atau menghapus jawaban Anda. Perhatikan bahwa saya tidak berpikir ada kesalahan dengan "tidak mencoba / menangkap sebagai satu-satunya mekanisme untuk memeriksa JSON" sebagai pendekatan.
Mrchief

8
Hanya karena itu membantunya, tidak berarti itu membantu kita semua yang, bertahun-tahun kemudian, memiliki pertanyaan yang sama.
McKay

916

Gunakan parser JSON seperti JSON.parse:

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

7
Terima kasih, tetapi saya hanya menjalankan ini dengan tim dan mereka menginginkan sesuatu yang tidak menggunakan coba / tangkap. Pertanyaannya diedit bersama dengan judul baru. Maaf soal itu.
Chi Chan

4
@trejder: ia melakukannya karena 1 bukan string, coba dengan "1"
Purefan

31
@Gumbo Komentar saya berumur 1,5 tahun! :] Saya tidak ingat, apa yang saya lakukan dua minggu lalu dan Anda meminta saya untuk mengingat proyek itu? :] Tidak, jalan ...:]
trejder

9
Masalah dengan jawaban ini adalah, jika string benar-benar keluar, dan Anda menguraikannya, Anda akan menguraikannya dua kali. Tidak bisakah Anda sebaliknya mengembalikan false pada parse buruk, tetapi mengembalikan objek pada kesuksesan?
Carcigenicate

5
@Carcigenicate Anda bisa melakukannya. Namun, JSON.parse("false")mengevaluasi ke false juga.
Gumbo

446

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

9
Dari jawaban di halaman, ini adalah yang paling kuat dan dapat diandalkan.
Jonline

28
o && o !== nullberlebihan.
Aleksei Matiushkin

4
Begitu juga dengan menggunakan triple-sama dengan typeof, yang selalu mengembalikan string. :)
Hein Haraldson Berg

5
Meskipun pos tua, saya pikir itu berharga untuk menempatkan biola up menunjukkan @matth jawaban Anda, mohon perhatikan bahwa benda-benda tidak akan berlaku .. Anda harus lulus string JSON. Mungkin berguna bagi siapa pun yang memulai, saya kira.
MindVox

2
Fungsi harus kembali undefined, bukan falsekarena falsestring json yang valid dan tidak ada cara untuk membedakan antara tryParseJSON("false")dantryParseJSON("garbage")
sparebytes

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


4
Hati-hati sejak nullmelewati validasi ini.
Farzad YZ

2
return !!(JSON.parse(str) && str);harus memblokir nilai nol. Saya akan memperbarui jawabannya dengan kode ini.
Machado

1
Ini adalah jawaban terbaik, karena ini juga memungkinkan Anda untuk memeriksa apakah JSON telah diobjektifikasi , dan dengan demikian tidak lulus parse()tes, menyebabkan WTF.
not2qubit

30

Di sini kode kerja saya:

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

1
IsJsonString (null); // mengembalikan true. Itu dapat diperbaiki dengan membandingkantypeof str === 'string'
gramcha

23

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. :)


1
JSON.parse (null), JSON.parse ("false") tidak melempar kesalahan, mungkin ada lebih banyak contoh
klodoma

Ya, Anda benar, saya lupa memeriksa bagaimana inputnya adalah string atau tidak, Jika saya melakukan itu, metode ini dengan nullinput itu memberikan kembali salah. Tetapi input "false" adalah string JSON yang valid. Ini akan diuraikan menjadi boolean (false). Sekarang saya memodifikasi kodenya menjadi lebih akurat.
kukko

15

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

9
Terima kasih, tapi saya pikir menggunakan perpustakaan prototipe untuk melakukan ini sedikit berlebihan.
Chi Chan

4
Anda memberi EMPAT contoh tetapi hanya TIGA hasil. Untuk apa hasilnya "{ foo: 42 }".isJSON()? Jika false, seperti yang saya asumsikan (hasil harus mengikuti fungsinya mendokumentasikan), maka pertanyaan yang bagus adalah, mengapa itu salah? { foo: 42 }tampaknya JSON yang benar-benar valid.
trejder

4
@trejder Sayangnya, spesifikasi JSON membutuhkan kunci yang dikutip.
mikermcneil

4
Dan "2002-12-15" .isJSON mengembalikan true, sedangkan JSON.parse ("2002-12-15") melempar kesalahan.
ychaouche

4
Saya pikir jawaban yang lebih baik di sini adalah untuk menarik fungsi itu keluar dari perpustakaan prototipe dan letakkan di sini. Terutama karena api.prototypejs.org/language/string/prototype/isjson adalah 404.
jcollum

5

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


1
Adakah yang memiliki rangkaian tes untuk membandingkan semua jawaban ini? Saya ingin melihat apakah ini benar.
Lonnie Best

1
@Lonnie Poin terbaik. 2 sen saya. Saya telah menggunakan selama bertahun-tahun dalam produksi dan selalu bekerja dengan baik dan dengan waktu eksekusi yang wajar.
loretoparisi

4

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.


Apa yang tidak dilakukan oleh jQuery yang tidak dilakukan JSON.parse?
ADJenks

3

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


2

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.


2

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

Naskah bukan javascript, tetapi jawaban Anda tampaknya.
Lonnie Best

1

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


1

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.


Solusi hybrid ini sepertinya akan menjadi cara yang efisien untuk menghindari keharusan melakukan try catch di sebagian besar kasus non-JSON. Saya suka aspek pendekatan Anda itu.
Lonnie Best

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

Saya harap ini juga bekerja untuk Anda


0
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


4
Dalam pertanyaan: "Solusinya tidak boleh mengandung try / catch".
ddmps

1
Mengapa? Ini dijamin cara ... Akan bodoh untuk tidak digunakan! Saya minta maaf karena tidak tahu bahasa Inggris. Saya menggunakan Google Translate
Emrah Tuncel

Menarik. Saya ingin melihat perbandingan kinerja JSON.parse versus solusi berbasis eval ini. Namun ini terlihat menakutkan dari perspektif keamanan / injeksi.
Lonnie Best

0

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.


Contoh pertama menggunakan eval mengatakan bahwa "<div> foo </div>" adalah JSON yang valid. Ini mungkin bekerja secara berbeda di browser yang berbeda, tetapi tampaknya di FireFox, eval () menerima XML.
Mark Lutton

Terima kasih, tetapi saya hanya menjalankan ini dengan tim dan mereka menginginkan sesuatu yang tidak menggunakan coba / tangkap. Pertanyaannya diedit bersama dengan judul baru. Maaf soal itu.
Chi Chan

@ Mark Lutton, tipe objek tidak akan dari JSON tetapi dari XML Dom Document (Saya lupa apa tipe persisnya di firefox).
Buhake Sindi

1
eval juga menerima JavaScript yang valid, seperti "alert (5);" dan string dalam tanda kutip tunggal, yang bukan JSON valid.
Mark Lutton

12
Ini adalah eval murni.
Chris Baker

0

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

0

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

0

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

-2

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.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.