Bir dizenin Try / Catch kullanmadan JavaScript'te geçerli bir JSON dizesi olup olmadığı nasıl kontrol edilir

Gibi bir şey:

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

//should be true
IsJsonString(jsonString);

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

Çözelti try / catch içermemelidir. Bazılarımız "tüm hataları kes" i açar ve hata ayıklayıcının bu geçersiz JSON dizelerini kırmasını sevmezler.

Önce bir yorum. Soru, kullanmamakla ilgiliydi try/catch.
Kullanmak sakıncası yoksa, aşağıdaki cevabı okuyun. Burada sadece JSONbir regexp kullanarak bir dizeyi kontrol ediyoruz ve çoğu durumda işe yarayacak, her durumda değil.

Https://github.com/douglascrockford/JSON-js/blob/master/json2.js adresindeki 450 hattına bir göz atın.

Geçerli bir JSON olup olmadığını kontrol eden bir regexp var:

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 : json2.js'nin yeni sürümü yukarıdakinden daha gelişmiş bir ayrıştırma yapar, ancak yine de normal ifade yerine ( @Mrchief yorumundan )

Aşağıdaki gibi bir JSON ayrıştırıcı kullanın JSON.parse:

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

Bu soruya 3 yıl geç kaldığımı biliyorum, ama içeri giriyormuş gibi hissettim.

Gumbo'nun çözümü harika çalışırken, istisna olmadığı birkaç durumu ele almıyor JSON.parse({something that isn't JSON})

Ayrıştırılan JSON'u aynı anda iade etmeyi de tercih ediyorum, bu nedenle arama kodunun JSON.parse(jsonString)ikinci kez çağırması gerekmiyor .

Bu benim ihtiyaçlarım için iyi çalışıyor gibi görünüyor:

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

Kullanımı: isJSON({}) olacak false, isJSON('{}')olacak true.

Bir şeyin Arrayveya Object( ayrıştırılmış JSON) olup olmadığını kontrol etmek için :

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

Kullanımı: isAO({}) olacak true, isAO('{}')olacak false.

İşte benim çalışma kodu:

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

Geçerli bir JSON olup olmadığını bir dize kontrol etmek için gerçekten basit bir yöntem kullandım.

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

Geçerli bir JSON dizesiyle sonuç:

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

Basit bir dize ile sonuç;

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

Bir nesne ile sonuç:

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

Boş girdi ile sonuç:

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

Null değişkenlerin türü nesne olduğu için sonuncusu false değerini döndürür.

Bu her zaman işe yarar. :)

Prototip js , biz yöntemi varJSON . Bunu deneyebilirsiniz. Json bile yardımcı olabilir.

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

Prototip çerçeve String.isJSONtanımından burada

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

yani bu bir dize nesnesini geçirirken kullanılabilecek sürüm

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

Bu cevap trycatch ifadesinin maliyetini azaltmak için.

JSON dizelerini ayrıştırmak için JQuery kullandım ve istisnaları işlemek için trycatch deyimini kullandım, ancak ayrıştırılamayan dizeler için istisnalar atmak kodumu yavaşlattı, bu yüzden olası bir JSON dizesi olup olmadığını kontrol etmek için basit Regex kullandım. sözdizimini kontrol ederek, sonra JQuery kullanarak dizeyi ayrıştırarak normal şekilde kullanılır:

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

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

}

Yuvalanmış JSON yanıtları ayrıştırmak için önceki kodu özyinelemeli bir işlevde sarılmış.

Belki faydalı olacaktır:

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

çıktı:

IE7: dize , nesne, dize, dize

CHROME: nesne, nesne, dize, dize

Sanırım bundan neden kaçınmak istediğini biliyorum. Ama belki deneyin ve yakalayın! == deneyin ve yakalayın. ; o) Bu aklıma geldi:

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

Böylece JSON nesnesine kirli klip de ekleyebilirsiniz, örneğin:

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

Mümkün olduğu kadar kapsüllenmiş olduğu için hatadan kopmayabilir.

İşte daktilo versiyonu:

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

Açılış yorumdan kullanım durumunun bir yanıtın HTML veya JSON olup olmadığını belirlediği sonucuna varıyorum. Bu durumda, ne zaman yapmak JSON almak, muhtemelen ayrıştırma ve yine kodunuzda bir noktada geçersiz JSON işleme olmalı. Bir şey dışında, JSON beklenen ancak geçersiz JSON alındığında tarayıcınız tarafından bilgilendirilmek istediğinizi hayal ediyorum (proxy tarafından bazı anlamlı hata mesajlarının kullanıcıları gibi)!

Bu nedenle JSON için tam bir regex yapmak gereksizdir (benim durumumda olduğu gibi - çoğu kullanım vakası için). Muhtemelen aşağıdaki gibi bir şey kullanarak daha iyi olurdu:

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

o Eğer istisna tanıtıcı geçerli olmayan JSON koduna sahip kaydetmek gerekir ve aynı zamanda Duff json ilgileneceğim.

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

umarım bu senin için de işe yarar

function get_json(txt)
{  var data

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

   return data;
}

Hatalar varsa false değerini döndürün.

Hata yoksa, json verilerini döndürün

Geçerli olup olmadığını doğrulamak için javascript eval () işlevini kullanabilirsiniz.

Örneğin

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
}

Alternatif olarak, json.org'dakiJSON.parse işlevi kullanabilirsiniz :

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

if (json) {
  //this is json
}

Bu yardımcı olur umarım.

UYARI : eval()olan tehlikeli birisi kötü niyetli JS kodu eklerse onu çalıştırır beri. JSON String'in güvenilir olduğundan emin olun , yani güvenilir bir kaynaktan aldınız.

Düzenle İlk çözümüm için bunu yapmanız önerilir.

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

Json-ness'i garanti etmek . Eğer jsonStringsaf JSON değil, eval bir özel durum oluşturur.

Oh kesinlikle geçerli bir JSON olup olmadığını kontrol etmek için try catch kullanabilirsiniz

Firfox Quantom 60.0.1 üzerinde test edildi

JSON'u sınamak için bir işlevin içindeki işlevi kullanın ve dizeyi doğrulamak için bu çıktıyı kullanın. bir örnek duyar.

    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)Kullanmakta olan işlev JSON.parse(str)benim durumumda çalışmıyor.
Ben her zaman yanlış döndürür GraphiQL json çıktı doğrulamak için çalıştı . Şanslıyım, isJSON daha iyi çalışıyor:

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

});

Örnek çıktı:

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

Bir Boole döndüren ve sonucu içeren bir byref parametresini işleyen "try" işlevlerinin .Net kuralını sevenler için. Out parametresine ihtiyacınız yoksa, parametreyi atlayabilir ve yalnızca dönüş değerini kullanabilirsiniz.

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

Çok basit bir satırlık kod (Ama Hacky yaklaşımı)

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

NOT: Bu sadece id gibi JSON dizesi bir şey bekliyorsanız çalışır. Bir API için kullanıyorum ve JSON ya da bazı hata dizesinde sonuç bekliyor.