So überprüfen Sie, ob eine Zeichenfolge eine gültige JSON-Zeichenfolge in JavaScript ist, ohne Try / Catch zu verwenden

Etwas wie:

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

//should be true
IsJsonString(jsonString);

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

Die Lösung sollte kein try / catch enthalten. Einige von uns aktivieren "Bei allen Fehlern brechen" und sie mögen es nicht, wenn der Debugger bei diesen ungültigen JSON-Zeichenfolgen bricht.

Ein Kommentar zuerst. Die Frage war, nicht zu verwenden try/catch.
Wenn es Ihnen nichts ausmacht, es zu verwenden, lesen Sie die Antwort unten. Hier überprüfen wir nur einen JSONString mit einem regulären Ausdruck, und er funktioniert in den meisten Fällen, nicht in allen Fällen.

Schauen Sie sich in https://github.com/douglascrockford/JSON-js/blob/master/json2.js in der Zeile 450 um

Es gibt einen regulären Ausdruck, der nach einem gültigen JSON sucht, etwa:

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

}

BEARBEITEN : Die neue Version von json2.js führt eine erweiterte Analyse durch als oben, basiert jedoch immer noch auf einem regulären Ausdruck (aus dem Kommentar von @Mrchief ).

Verwenden Sie einen JSON-Parser wie JSON.parse:

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

Ich weiß, dass ich 3 Jahre zu spät zu dieser Frage komme, aber ich wollte mich einmischen.

Die Lösung von Gumbo funktioniert zwar hervorragend, behandelt jedoch nicht einige Fälle, in denen keine Ausnahme gemacht wird JSON.parse({something that isn't JSON})

Ich ziehe es auch vor, den analysierten JSON gleichzeitig zurückzugeben, damit der aufrufende Code nicht aufgerufen werden muss JSON.parse(jsonString) zweites Mal werden muss.

Dies scheint für meine Bedürfnisse gut zu funktionieren:

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

Verwendung: isJSON({}) wird sein false, isJSON('{}')wird sein true.

So überprüfen Sie, ob es sich bei einem um einen Arrayoder Object( analysierten JSON) handelt:

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

Verwendung: isAO({}) wird sein true, isAO('{}')wird sein false.

Hier mein Arbeitscode:

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

Ich habe eine wirklich einfache Methode verwendet, um eine Zeichenfolge zu überprüfen, ob es sich um einen gültigen JSON handelt oder nicht.

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

Ergebnis mit einer gültigen JSON-Zeichenfolge:

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

Ergebnis mit einer einfachen Zeichenfolge;

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

Ergebnis mit einem Objekt:

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

Ergebnis mit Null-Eingabe:

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

Der letzte gibt false zurück, da der Typ der Nullvariablen Objekt ist.

Das funktioniert immer. :) :)

In prototypeJS haben wir die Methode isJSON . Das kannst du versuchen. Sogar json könnte helfen.

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

Aus der String.isJSONDefinition des Prototyp-Frameworks hier

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

Dies ist also die Version, die zum Übergeben eines Zeichenfolgenobjekts verwendet werden kann

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

Diese Antwort, um die Kosten der Trycatch-Anweisung zu reduzieren.

Ich habe JQuery verwendet, um JSON-Zeichenfolgen zu analysieren, und ich habe die trycatch-Anweisung verwendet, um Ausnahmen zu behandeln, aber das Auslösen von Ausnahmen für nicht analysierbare Zeichenfolgen hat meinen Code verlangsamt. Daher habe ich mit einfachem Regex die Zeichenfolge überprüft, ob es sich um eine mögliche JSON-Zeichenfolge handelt oder nicht Nachdem ich die Syntax überprüft habe, habe ich die Zeichenfolge wie gewohnt mithilfe von JQuery analysiert:

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

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

}

Ich habe den vorherigen Code in eine rekursive Funktion eingeschlossen, um verschachtelte JSON-Antworten zu analysieren.

Vielleicht wird es nützlich sein:

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

Ausgabe:

IE7: Zeichenfolge , Objekt, Zeichenfolge, Zeichenfolge

CHROM: Objekt, Objekt, Zeichenfolge, Zeichenfolge

Ich glaube ich weiß warum du das vermeiden willst. Aber vielleicht versuchen & fangen! == versuchen & fangen. ; o) Das kam mir in den Sinn:

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

Sie können also auch einen schmutzigen Clip zum JSON-Objekt erstellen, z.

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

Da dies so gekapselt wie möglich ist, kann es bei einem Fehler nicht brechen.

Hier ist auch die Typoskript-Version:

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

Ich schließe aus dem einleitenden Kommentar, dass der Anwendungsfall beschreibt, ob eine Antwort HTML oder JSON ist. In diesem Fall, wenn Sie dies tun JSON erhalten, sollten Sie es wahrscheinlich sein , Parsen und Umgang mit ungültigen JSON an einem gewissen Punkt in Ihrem Code sowieso. Abgesehen von allem stelle ich mir vor, dass Sie von Ihrem Browser informiert werden möchten, falls JSON erwartet wird, aber ungültiges JSON empfangen wird (ebenso wie Benutzer per Proxy einer aussagekräftigen Fehlermeldung)!

Eine vollständige Regex für JSON ist daher nicht erforderlich (wie es meiner Erfahrung nach für die meisten Anwendungsfälle der Fall wäre). Sie sind wahrscheinlich besser dran, wenn Sie Folgendes verwenden:

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

Das sollte Ihnen ersparen, dass Sie einen gültigen Nicht-JSON-Code ausnahmsweise behandeln und sich gleichzeitig um Duff Json kümmern müssen.

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

hoffe, das funktioniert auch bei dir

function get_json(txt)
{  var data

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

   return data;
}

Wenn es Fehler gibt, geben Sie false zurück.

Wenn keine Fehler vorliegen, geben Sie json-Daten zurück

Sie können die Javascript- Funktion eval () verwenden, um zu überprüfen, ob sie gültig ist.

z.B

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
}

Alternativ können Sie die JSON.parseFunktion von json.org verwenden :

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

if (json) {
  //this is json
}

Hoffe das hilft.

WARNUNG : eval()ist gefährlich , wenn jemand böswillig JS Code fügt, da sie es ausgeführt wird. Stellen Sie sicher, dass der JSON-String vertrauenswürdig ist , dh Sie haben ihn von einer vertrauenswürdigen Quelle erhalten.

Bearbeiten Für meine erste Lösung wird empfohlen, dies zu tun.

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

Um json-ness zu garantieren . Wenn der jsonStringJSON nicht rein ist, löst die Auswertung eine Ausnahme aus.

Oh, Sie können auf jeden Fall try catch verwenden, um zu überprüfen, ob es sich um einen gültigen JSON handelt oder nicht

Getestet mit Firfox Quantom 60.0.1

Verwenden Sie die Funktion innerhalb einer Funktion, um den JSON zu testen, und verwenden Sie diese Ausgabe, um die Zeichenfolge zu validieren. hört ein Beispiel.

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

Die Funktion IsJsonString(str), die verwendet wird JSON.parse(str), funktioniert in meinem Fall nicht.
Ich habe versucht, die JSON- Ausgabe von GraphiQL zu validieren. Es wird immer false zurückgegeben. Glück für mich, isJSON besser funktioniert:

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

});

Beispielausgabe:

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

Für Leute, die die .Net-Konvention von "try" -Funktionen mögen, die einen Booleschen Wert zurückgeben und einen byref-Parameter verarbeiten, der das Ergebnis enthält. Wenn Sie den out-Parameter nicht benötigen, können Sie ihn weglassen und einfach den Rückgabewert verwenden.

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

Sehr einfacher Einzeiler-Code (aber Hacky-Ansatz)

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

HINWEIS: Dies funktioniert nur, wenn Sie erwarten, dass es sich um eine JSON-Zeichenfolge wie id handelt. Ich verwende es für eine API und erwarte das Ergebnis entweder in JSON oder in einer Fehlerzeichenfolge.