Wie teste ich, ob eine Zeichenfolge JSON ist oder nicht?

Ich habe einen einfachen AJAX-Aufruf und der Server gibt entweder eine JSON-Zeichenfolge mit nützlichen Daten oder eine von der PHP-Funktion erzeugte Fehlermeldung zurück mysql_error(). Wie kann ich testen, ob diese Daten eine JSON-Zeichenfolge oder die Fehlermeldung sind?

Es wäre schön, eine Funktion zu verwenden, die aufgerufen wird, isJSONgenau wie Sie die Funktion verwenden können, um instanceofzu testen, ob etwas ein Array ist.

Das ist was ich will:

if (isJSON(data)){
    //do some data stuff
}else{
    //report the error
    alert(data);
}

Verwenden Sie JSON.parse

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

Dieser Code ist JSON.parse(1234)oder JSON.parse(0)oder JSON.parse(false)oder JSON.parse(null)alle geben true zurück.

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

Also habe ich den Code folgendermaßen umgeschrieben:

function isJson(item) {
    item = typeof item !== "string"
        ? JSON.stringify(item)
        : item;

    try {
        item = JSON.parse(item);
    } catch (e) {
        return false;
    }

    if (typeof item === "object" && item !== null) {
        return true;
    }

    return false;
}

Testergebnis:

isJson Testergebnis

Lassen Sie uns dies noch einmal zusammenfassen (für 2019+).

Argument : Werte wie true, false, nullgelten JSON (?)

FAKT : Diese primitiven Werte sind JSON-analysierbar, aber keine wohlgeformten JSON-Strukturen . Die JSON- Spezifikation gibt an, dass JSON auf zwei Strukturen basiert: einer Sammlung von Name / Wert-Paaren (Objekt) oder einer geordneten Liste von Werten (Array).

Argument : Die Ausnahmebehandlung sollte nicht verwendet werden, um etwas zu tun, was erwartet wird.
(Dies ist ein Kommentar mit mehr als 25 positiven Stimmen!)

Tatsache : Nein! Es ist definitiv legal, try / catch zu verwenden, insbesondere in einem solchen Fall. Andernfalls müssten Sie viele Zeichenfolgenanalysen durchführen, z. B. Tokenisierungs- / Regex-Operationen. das hätte schreckliche Leistung.

hasJsonStructure()

Dies ist nützlich, wenn Sie überprüfen möchten, ob einige Daten / Texte das richtige JSON-Austauschformat haben.

function hasJsonStructure(str) {
    if (typeof str !== 'string') return false;
    try {
        const result = JSON.parse(str);
        const type = Object.prototype.toString.call(result);
        return type === '[object Object]' 
            || type === '[object Array]';
    } catch (err) {
        return false;
    }
}

Verwendung:

hasJsonStructure('true')             // —» false
hasJsonStructure('{"x":true}')       // —» true
hasJsonStructure('[1, false, null]') // —» true

safeJsonParse()

Dies ist nützlich, wenn Sie beim Parsen einiger Daten auf einen JavaScript-Wert vorsichtig sein möchten.

function safeJsonParse(str) {
    try {
        return [null, JSON.parse(str)];
    } catch (err) {
        return [err];
    }
}

Verwendung:

const [err, result] = safeJsonParse('[Invalid JSON}');
if (err) {
    console.log('Failed to parse JSON: ' + err.message);
} else {
    console.log(result);
}

Wenn der Server mit JSON antwortet, hat er einen application/jsonInhaltstyp. Wenn er mit einer Nur-Text-Nachricht antwortet, sollte er einen text/plainInhaltstyp haben. Stellen Sie sicher, dass der Server mit dem richtigen Inhaltstyp antwortet, und testen Sie dies.

Wenn jQuery $.ajax()die Antwort verwendet wird, hat sie die responseJSONEigenschaft, wenn die Antwort JSON war. Dies kann folgendermaßen überprüft werden:

if (xhr.hasOwnProperty('responseJSON')) {}

Ich mag die beste Antwort, aber wenn es eine leere Zeichenfolge ist, gibt sie true zurück. Also hier ist eine Lösung:

function isJSON(MyTestStr){
    try {
        var MyJSON = JSON.stringify(MyTestStr);
        var json = JSON.parse(MyJSON);
        if(typeof(MyTestStr) == 'string')
            if(MyTestStr.length == 0)
                return false;
    }
    catch(e){
        return false;
    }
    return true;
}

var parsedData;

try {
    parsedData = JSON.parse(data)
} catch (e) {
    // is not a valid JSON string
}

Ich werde Ihnen jedoch vorschlagen, dass Ihr http-Anruf / Dienst http immer Daten im gleichen Format zurückgibt. Wenn Sie also einen Fehler haben, sollten Sie ein JSON-Objekt haben, das diesen Fehler umschließt:

{"error" : { "code" : 123, "message" : "Foo not supported" } } 

Und vielleicht verwenden Sie neben dem HTTP-Status auch einen 5xx-Code.

Nun ... Es hängt davon ab, wie Sie Ihre Daten erhalten. Ich denke, der Server antwortet mit einer JSON-formatierten Zeichenfolge (z. B. mit json_encode () in PHP). Wenn Sie JQuery post verwenden und die Antwortdaten auf ein JSON-Format festlegen und es sich um ein fehlerhaftes JSON handelt, wird ein Fehler ausgegeben:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        //Supposing x is a JSON property...
        alert(response.x);

  },
  dataType: 'json',
  //Invalid JSON
  error: function (){ alert("error!"); }
});

Wenn Sie jedoch die Typantwort als Text verwenden, müssen Sie $ .parseJSON verwenden. Laut jquery site: "Das Übergeben einer fehlerhaften JSON-Zeichenfolge kann dazu führen, dass eine Ausnahme ausgelöst wird". Ihr Code lautet also:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        try {
            parsedData = JSON.parse(response);
        } catch (e) {
            // is not a valid JSON string
        }

  },
  dataType: 'text',
});

Es gibt wahrscheinlich Tests, die Sie durchführen können, zum Beispiel wenn Sie wissen, dass der zurückgegebene JSON immer von umgeben sein wird, {und }dann könnten Sie nach diesen Zeichen oder einer anderen hackigen Methode testen. Oder Sie können die JS-Bibliothek von json.org verwenden, um zu versuchen, sie zu analysieren und zu testen, ob sie erfolgreich ist.

Ich würde jedoch einen anderen Ansatz vorschlagen. Ihr PHP-Skript gibt derzeit JSON zurück, wenn der Aufruf erfolgreich ist, aber etwas anderes, wenn dies nicht der Fall ist. Warum nicht immer JSON zurückgeben?

Z.B

Erfolgreicher Anruf:

{ "status": "success", "data": [ <your data here> ] }

Fehlerhafter Anruf:

{ "status": "error", "error": "Database not found" }

Dies würde das Schreiben Ihrer clientseitigen JS erheblich vereinfachen. Sie müssen lediglich das "Status" -Mitglied überprüfen und entsprechend handeln.

Ich benutze nur 2 Zeilen, um das auszuführen:

var isValidJSON = true;
try { JSON.parse(jsonString) } catch { isValidJSON = false }

Das ist alles!

Beachten Sie jedoch, dass es zwei Traps gibt:
1. JSON.parse(null)Gibt null
2. zurück . Jede Zahl oder Zeichenfolge kann mit der JSON.parse()Methode analysiert werden.
   JSON.parse("5")gibt 5
   JSON.parse(5)zurück gibt zurück5

Lassen Sie uns etwas mit Code spielen:

// TEST 1
var data = '{ "a": 1 }'

// Avoiding 'null' trap! Null is confirmed as JSON.
var isValidJSON = data ? true : false
try { JSON.parse(data) } catch(e) { isValidJSON = false }

console.log("data isValidJSON: ", isValidJSON);
console.log("data isJSONArray: ", isValidJSON && JSON.parse(data).length ? true : false);

Console outputs:
data isValidJSON:  true
data isJSONArray:  false


// TEST 2
var data2 = '[{ "b": 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data2) } catch(e) { isValidJSON = false }

console.log("data2 isValidJSON: ", isValidJSON);
console.log("data2 isJSONArray: ", isValidJSON && JSON.parse(data2).length ? true : false);

Console outputs:
data2 isValidJSON:  true
data2 isJSONArray:  true


// TEST 3
var data3 = '[{ 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data3) } catch(e) { isValidJSON = false }

console.log("data3 isValidJSON: ", isValidJSON);
console.log("data3 isJSONArray: ", isValidJSON && JSON.parse(data3).length ? true : false);

Console outputs:
data3 isValidJSON:  false
data3 isJSONArray:  false


// TEST 4
var data4 = '2'

var isValidJSON = data ? true : false
try { JSON.parse(data4) } catch(e) { isValidJSON = false }

console.log("data4 isValidJSON: ", isValidJSON);
console.log("data4 isJSONArray: ", isValidJSON && JSON.parse(data4).length ? true : false);


Console outputs:
data4 isValidJSON:  true
data4 isJSONArray:  false


// TEST 5
var data5 = ''

var isValidJSON = data ? true : false
try { JSON.parse(data5) } catch(e) { isValidJSON = false }

console.log("data5 isValidJSON: ", isValidJSON);
console.log("data5 isJSONArray: ", isValidJSON && JSON.parse(data5).length ? true : false);


Console outputs:
data5 isValidJSON:  false
data5 isJSONArray:  false

// TEST 6
var data6; // undefined

var isValidJSON = data ? true : false
try { JSON.parse(data6) } catch(e) { isValidJSON = false }

console.log("data6 isValidJSON: ", isValidJSON);
console.log("data6 isJSONArray: ", isValidJSON && JSON.parse(data6).length ? true : false);

Console outputs:
data6 isValidJSON:  false
data6 isJSONArray:  false

Sie könnten versuchen, es zu dekodieren und die Ausnahme abzufangen (native oder json2.js ):

try {
  newObj = JSON.parse(myJsonString);
} catch (e) {
  console.log('Not JSON');
}

Ich würde jedoch vorschlagen, dass die Antwort immer gültig ist. Wenn Sie von Ihrer MySQL-Abfrage einen Fehler zurückerhalten, senden Sie einfach JSON mit dem Fehler zurück:

{"error":"The MySQL error string."}

Und dann:

if (myParsedJSON.error) {
  console.log('An error occurred: ' + myParsedJSON.error);
}

Warnung: Bei Methoden, die sich auf JSON.parse- Arrays und in Anführungszeichen umgebene Zeichenfolgen verlassen, werden diese ebenfalls übergeben (z. B. console.log(JSON.parse('[3]'), JSON.parse('"\uD800"'))).

Um alle Nicht-Objekt-JSON-Grundelemente (Boolescher Wert, Nullwert, Array, Zahl, Zeichenfolge) zu vermeiden, empfehle ich Folgendes:

/* Validate a possible object ie. o = { "a": 2 } */
const isJSONObject = (o) => 
  !!o && (typeof o === 'object') && !Array.isArray(o) && 
  (() => { try { return Boolean(JSON.stringify(o)); } catch { return false } })()

/* Validate a possible JSON object represented as string ie. s = '{ "a": 3 }' */
function isJSONObjectString(s) {
    try {
        const o = JSON.parse(s);
        return !!o && (typeof o === 'object') && !Array.isArray(o)
    } catch {
        return false
    }
}

Code Erklärung

• !! o - Nicht falsch (ausgenommen null, das als Typ von 'Objekt' registriert wird)
• (typeof o === 'object') - Schließt Boolesche Werte , Zahlen und Zeichenfolgen aus
• ! Array.isArray (o) - Arrays ausschließen (die sich als Typ von 'Objekt' registrieren)
• try ... JSON.stringify / JSON.parse - Fordert die JavaScript-Engine auf, festzustellen, ob JSON gültig ist

Warum nicht die Antwort hasJsonStructure () verwenden?

Sich darauf zu verlassen toString()ist keine gute Idee. Dies liegt daran, dass verschiedene JavaScript-Engines möglicherweise eine andere Zeichenfolgendarstellung zurückgeben. Im Allgemeinen können Methoden, die darauf basieren, in verschiedenen Umgebungen fehlschlagen oder später fehlschlagen, falls die Engine jemals das Ergebnis der Zeichenfolge ändert

Warum ist das Fangen einer Ausnahme kein Hack?

Es wurde darauf hingewiesen, dass das Abfangen einer Ausnahme zur Bestimmung der Gültigkeit von etwas niemals der richtige Weg ist. Dies ist im Allgemeinen ein guter Rat, aber nicht immer. In diesem Fall ist das Abfangen von Ausnahmen wahrscheinlich der beste Weg, da es auf der Implementierung der JSON-Daten durch die JavaScript-Engine beruht.

Das Verlassen auf die JS-Engine bietet die folgenden Vorteile:

1. Gründlicher und ständig auf dem neuesten Stand, wenn sich die JSON-Spezifikationen ändern
2. Läuft wahrscheinlich schneller (da es sich um Code auf niedrigerer Ebene handelt)

Wenn Sie die Möglichkeit haben, sich auf die JavaScript-Engine zu stützen, würde ich vorschlagen, dies zu tun. Besonders in diesem Fall. Obwohl es sich hackig anfühlt, eine Ausnahme abzufangen, behandeln Sie wirklich nur zwei mögliche Rückgabezustände von einer externen Methode.

Hier ist ein Code mit geringfügigen Änderungen in Bournes Antwort. Da JSON.parse (Nummer) ausnahmslos einwandfrei funktioniert, wird isNaN hinzugefügt.

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return isNaN(str);
}

Alle JSON-Zeichenfolgen beginnen mit '{' oder '[' und enden mit dem entsprechenden '}' oder ']'. Überprüfen Sie dies einfach.

So macht es Angular.js:

var JSON_START = /^\[|^\{(?!\{)/;
var JSON_ENDS = {
  '[': /]$/,
  '{': /}$/
};

function isJsonLike(str) {
    var jsonStart = str.match(JSON_START);
    return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
}

https://github.com/angular/angular.js/blob/v1.6.x/src/ng/http.js