Jak sprawdzić, czy ciąg jest poprawnym ciągiem JSON w JavaScript bez użycia Try / Catch

Coś jak:

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

//should be true
IsJsonString(jsonString);

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

Rozwiązanie nie powinno zawierać try / catch. Niektórzy z nas włączają opcję „zepsuć na wszystkich błędach” i nie podoba im się to, że debugger łamie te nieprawidłowe łańcuchy JSON.

Najpierw komentarz. Pytanie dotyczyło nieużywania try/catch.
Jeśli nie masz nic przeciwko, aby z niego skorzystać, przeczytaj odpowiedź poniżej. Tutaj po prostu sprawdzamy JSONciąg za pomocą wyrażenia regularnego i będzie on działał w większości przypadków, nie we wszystkich przypadkach.

Rozejrzyj się po linii 450 w https://github.com/douglascrockford/JSON-js/blob/master/json2.js

Istnieje wyrażenie regularne, które sprawdza poprawność JSON, coś w stylu:

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

}

EDYCJA : Nowa wersja json2.js umożliwia bardziej zaawansowane parsowanie niż powyżej, ale wciąż opiera się na regexp replace (z komentarza @Mrchief )

Użyj parsera JSON, takiego jak JSON.parse:

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

Wiem, że spóźniłem się na to pytanie o 3 lata, ale miałem ochotę się wtrącić.

Chociaż rozwiązanie Gumbo działa świetnie, nie obsługuje kilku przypadków, w których nie zgłoszono żadnego wyjątku JSON.parse({something that isn't JSON})

Wolę także zwrócić przeanalizowany JSON w tym samym czasie, aby kod wywołujący nie musiał wywoływać JSON.parse(jsonString) się po raz drugi.

To wydaje się działać dobrze dla moich potrzeb:

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

Zastosowanie: isJSON({}) będzie false, isJSON('{}')będzie true.

Aby sprawdzić, czy coś jest Arraylub Object( przeanalizowany 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;

Zastosowanie: isAO({}) będzie true, isAO('{}')będzie false.

Oto mój działający kod:

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

Użyłem bardzo prostej metody, aby sprawdzić ciąg znaków, czy jest to poprawny JSON, czy nie.

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

Wynik z prawidłowym łańcuchem JSON:

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

Wynik z prostym ciągiem;

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

Wynik z obiektem:

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

Wynik z wejściem zerowym:

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

Ostatni zwraca false, ponieważ typ zmiennych zerowych to object.

Działa to za każdym razem. :)

W prototypeJS mamy metodę isJSON . Możesz tego spróbować. Nawet Json może pomóc.

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

Z String.isJSONdefinicji szkieletu prototypów tutaj

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

więc jest to wersja, której można użyć, przekazując obiekt łańcuchowy

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

Ta odpowiedź na obniżenie kosztu instrukcji Trycatch.

Użyłem JQuery do parsowania ciągów JSON i użyłem instrukcji trycatch do obsługi wyjątków, ale rzucanie wyjątków dla nieparsowalnych ciągów spowolniło mój kod, więc użyłem prostej Regex, aby sprawdzić ciąg, czy jest to możliwy ciąg JSON, czy nie, bez przechodzenia w pióro sprawdzając jego składnię, użyłem normalnego sposobu, parsując ciąg za pomocą JQuery:

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

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

}

Owinęłem poprzedni kod funkcją rekurencyjną, aby przeanalizować zagnieżdżone odpowiedzi JSON.

Może przyda się:

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

wynik:

IE7: ciąg , obiekt, ciąg, ciąg

CHROM: obiekt, obiekt, ciąg, ciąg

Myślę, że wiem, dlaczego chcesz tego uniknąć. Ale może spróbuj i złap! == spróbuj i złap. ; o) Przyszło mi to na myśl:

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

Możesz więc również wyczyścić obiekt JSON, np .:

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

Ponieważ jest to możliwie najbardziej enkapsulowane, nie może ulec awarii po błędzie.

Oto także wersja maszynopisu:

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

Wnioskuję z komentarza otwierającego, że przypadek użycia określa, czy odpowiedzią jest HTML, czy JSON. W takim przypadku, kiedy to zrobisz odbierać JSON, prawdopodobnie powinno być analizowania go i obsługi nieprawidłową JSON w pewnym momencie w kodzie tak. Poza tym, wyobrażam sobie, że chciałbyś być informowany przez swoją przeglądarkę, jeśli JSON powinien się spodziewać, ale otrzyma niepoprawny JSON (podobnie jak użytkownicy przez proxy jakiegoś znaczącego komunikatu o błędzie)!

Wykonanie pełnego wyrażenia regularnego dla JSON jest zatem niepotrzebne (tak jak byłoby - z mojego doświadczenia - w większości przypadków użycia). Prawdopodobnie lepiej byłoby użyć czegoś takiego:

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

powinno to zaoszczędzić Ci konieczności obsługi wyjątkowego kodu innego niż JSON i jednoczesnego dbania o duff json.

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

mam nadzieję, że to również dla ciebie działa

function get_json(txt)
{  var data

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

   return data;
}

Jeśli występują błędy, zwróć false.

Jeśli nie ma błędów, zwróć dane JSON

Możesz użyć javascript eval () aby sprawdzić, czy jest poprawna.

na przykład

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
}

Alternatywnie możesz użyć JSON.parsefunkcji z json.org :

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

if (json) {
  //this is json
}

Mam nadzieję że to pomoże.

OSTRZEŻENIE : eval()jest niebezpieczne, jeśli ktoś doda złośliwy kod JS, ponieważ go wykona. Upewnij się, że łańcuch JSON jest godny zaufania , tzn. Otrzymałeś go z zaufanego źródła.

Edytuj Dla mojego pierwszego rozwiązania, zaleca się to zrobić.

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

Aby zagwarantować json-ness. Jeśli jsonStringnie jest to czysty JSON, eval zgłosi wyjątek.

Och, zdecydowanie możesz użyć try catch, aby sprawdzić, czy jest to poprawny JSON

Testowany na Firfox Quantom 60.0.1

użyj funkcji wewnątrz funkcji, aby przetestować JSON i użyj tego wyjścia do sprawdzenia poprawności łańcucha. słyszy przykład.

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

Funkcja IsJsonString(str), która używa JSON.parse(str), nie działa w moim przypadku.
Próbowałem sprawdzić poprawność danych wyjściowych Json z GraphiQL , zawsze zwracają wartość false. Na szczęście isJSON działa lepiej:

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

});

Przykładowe dane wyjściowe:

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

Dla osób, które lubią konwencję .Net funkcji „try”, które zwracają wartość logiczną i obsługują parametr byref zawierający wynik. Jeśli nie potrzebujesz parametru out, możesz go pominąć i po prostu użyć wartości zwracanej.

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

Bardzo prosty kod jednowierszowy (ale podejście Hacky)

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

UWAGA: Działa to tylko wtedy, gdy oczekujesz, że coś jest ciągiem JSON, takim jak id. Używam go do interfejsu API i oczekuję wyniku w JSON lub w pewnym łańcuchu błędów.