Der schnellste Weg, um zu überprüfen, ob eine Zeichenfolge JSON in PHP ist?

Question

Ich brauche eine wirklich, wirklich schnelle Methode der Überprüfung, ob eine Zeichenfolge JSON ist oder nicht. Ich fühle mich wie dies ist nicht der beste Weg:

function isJson($string) {
    return ((is_string($string) &&
            (is_object(json_decode($string)) ||
            is_array(json_decode($string))))) ? true : false;
}

Gibt es da draußen Leistungsenthusiasten, die diese Methode verbessern wollen?

Answer 1

function isJson($string) {
   json_decode($string);
   return json_last_error() === JSON_ERROR_NONE;
}

Answer 2

Antwort auf die Frage

Die Funktion json_last_error gibt den letzten Fehler zurück, der während der JSON-Kodierung und -Dekodierung aufgetreten ist. Der schnellste Weg, das gültige JSON zu überprüfen, ist also

// decode the JSON data
// set second parameter boolean TRUE for associative array output.
$result = json_decode($json);

if (json_last_error() === JSON_ERROR_NONE) {
    // JSON is valid
}

// OR this is equivalent

if (json_last_error() === 0) {
    // JSON is valid
}

Beachten Sie, dass json_last_error wird nur in PHP >= 5.3.0 unterstützt.

Vollständiges Programm zur Überprüfung des genauen ERROR

Es ist immer gut, wenn man den genauen Fehler während der Entwicklungszeit kennt. Hier ist ein komplettes Programm zur Überprüfung des genauen Fehlers auf der Grundlage der PHP-Dokumente.

function json_validate($string)
{
    // decode the JSON data
    $result = json_decode($string);

    // switch and check possible JSON errors
    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            $error = ''; // JSON is valid // No error has occurred
            break;
        case JSON_ERROR_DEPTH:
            $error = 'The maximum stack depth has been exceeded.';
            break;
        case JSON_ERROR_STATE_MISMATCH:
            $error = 'Invalid or malformed JSON.';
            break;
        case JSON_ERROR_CTRL_CHAR:
            $error = 'Control character error, possibly incorrectly encoded.';
            break;
        case JSON_ERROR_SYNTAX:
            $error = 'Syntax error, malformed JSON.';
            break;
        // PHP >= 5.3.3
        case JSON_ERROR_UTF8:
            $error = 'Malformed UTF-8 characters, possibly incorrectly encoded.';
            break;
        // PHP >= 5.5.0
        case JSON_ERROR_RECURSION:
            $error = 'One or more recursive references in the value to be encoded.';
            break;
        // PHP >= 5.5.0
        case JSON_ERROR_INF_OR_NAN:
            $error = 'One or more NAN or INF values in the value to be encoded.';
            break;
        case JSON_ERROR_UNSUPPORTED_TYPE:
            $error = 'A value of a type that cannot be encoded was given.';
            break;
        default:
            $error = 'Unknown JSON error occured.';
            break;
    }

    if ($error !== '') {
        // throw the Exception or exit // or whatever :)
        exit($error);
    }

    // everything is OK
    return $result;
}

Testen mit gültigem JSON INPUT

$json = '[{"user_id":13,"username":"stack"},{"user_id":14,"username":"over"}]';
$output = json_validate($json);
print_r($output);

Gültig OUTPUT

Array
(
    [0] => stdClass Object
        (
            [user_id] => 13
            [username] => stack
        )

    [1] => stdClass Object
        (
            [user_id] => 14
            [username] => over
        )
)

Testen mit ungültigem JSON

$json = '{background-color:yellow;color:#000;padding:10px;width:650px;}';
$output = json_validate($json);
print_r($output);

Ungültiges OUTPUT

Syntax error, malformed JSON.

Zusätzlicher Hinweis für (PHP >= 5.2 && PHP < 5.3.0)

Desde json_last_error in PHP 5.2 nicht unterstützt wird, können Sie prüfen, ob die Kodierung oder Dekodierung boolesche Werte liefert FALSE . Hier ist ein Beispiel

// decode the JSON data
$result = json_decode($json);
if ($result === FALSE) {
    // JSON is invalid
}

Answer 3

Alles, was Sie wirklich tun müssen, ist dies...

if (is_object(json_decode($MyJSONArray))) 
{ 
    ... do something ...
}

Für diesen Antrag ist nicht einmal eine eigene Funktion erforderlich. Wickeln Sie einfach is_object um json_decode und fahren Sie fort. Scheint diese Lösung hat Menschen setzen viel zu viel Gedanken in sie.

Answer 4

Verwendung von json_decode zu "sondieren", ist vielleicht nicht der schnellste Weg. Wenn es sich um eine tief verschachtelte Struktur handelt, dann ist die Instanziierung vieler Objekte von Arrays, um sie einfach wegzuwerfen, eine Verschwendung von Speicher und Zeit.

Es könnte also schneller sein, wenn Sie preg_match y el RFC4627 regex auch für Gültigkeit sicherstellen :

  // in JS:
  var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
         text.replace(/"(\\.|[^"\\])*"/g, '')));

Dasselbe gilt für PHP:

  return !preg_match('/[^,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t]/',
       preg_replace('/"(\\.|[^"\\\\])*"/', '', $json_string));

Ich bin jedoch nicht so sehr ein Leistungsenthusiast, dass ich mich hier mit Benchmarks beschäftigen würde.

Answer 5

Dies ergibt wahr wenn Ihre Zeichenkette eine json-Array oder -Objekt :

function isJson($str) {
    $json = json_decode($str);
    return $json && $str != $json;
}

Es lehnt json-Strings ab, die nur eine Zahl, einen String oder einen Boolean enthalten, obwohl diese Strings technisch gesehen gültige json-Strings sind.

var_dump(isJson('{"a":5}')); // bool(true)
var_dump(isJson('[1,2,3]')); // bool(true)
var_dump(isJson('1')); // bool(false)
var_dump(isJson('1.5')); // bool(false)
var_dump(isJson('true')); // bool(false)
var_dump(isJson('false')); // bool(false)
var_dump(isJson('null')); // bool(false)
var_dump(isJson('hello')); // bool(false)
var_dump(isJson('')); // bool(false)

Das ist der kürzeste Weg, den ich mir vorstellen kann.