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

Ich brauche eine sehr, sehr schnelle Methode, um zu überprüfen, ob eine Zeichenfolge JSON ist oder nicht. Ich denke, das ist nicht der beste Weg:

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

Möchten Performance-Enthusiasten diese Methode verbessern?

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

Antwort auf die Frage

Die Funktion json_last_errorgibt den letzten Fehler zurück, der während der JSON-Codierung und -Decodierung aufgetreten ist. Der schnellste Weg, um den gültigen JSON zu überprüfen, ist

// 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_errordies nur in PHP> = 5.3.0 unterstützt wird.

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

Es ist immer gut, den genauen Fehler während der Entwicklungszeit zu kennen. Hier ist ein vollständiges Programm, um den genauen Fehler basierend auf PHP-Dokumenten zu überprüfen.

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ültiger AUSGANG

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ültige AUSGABE

Syntax error, malformed JSON.

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

Da json_last_errordies in PHP 5.2 nicht unterstützt wird, können Sie überprüfen, ob die Codierung oder Decodierung boolesch ist FALSE. Hier ist ein Beispiel

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

Hoffe das ist hilfreich. Viel Spaß beim Codieren!

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

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

Diese Anfrage erfordert nicht einmal eine separate Funktion. Wickeln Sie einfach is_object um json_decode und fahren Sie fort. Anscheinend haben die Leute bei dieser Lösung viel zu viel darüber nachgedacht.

Mit json_decode"prüfen" ist dies möglicherweise nicht der schnellste Weg. Wenn es sich um eine tief verschachtelte Struktur handelt, ist es eine Verschwendung von Speicher und Zeit, viele Objekte von Arrays zu instanziieren, um sie einfach wegzuwerfen.

So ist es schneller sein könnte , zu verwenden preg_matchund der RFC4627 regex auch Gültigkeit zu gewährleisten :

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

Das gleiche in PHP:

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

Nicht genug von einem Performance-Enthusiasten, um sich hier mit Benchmarks zu beschäftigen.

Dies gibt true zurück, wenn Ihre Zeichenfolge ein JSON-Array oder -Objekt darstellt :

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

Es lehnt JSON-Zeichenfolgen ab, die nur eine Zahl, eine Zeichenfolge oder einen Booleschen Wert enthalten, obwohl diese Zeichenfolgen technisch gültige JSON-Zeichenfolgen 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)

Es ist der kürzeste Weg, den ich finden kann.

Der einfachste und schnellste Weg, den ich benutze, ist der folgende;

$json_array = json_decode( $raw_json , true );

if( $json_array == NULL )   //check if it was invalid json string
    die ('Invalid');  // Invalid JSON error

 // you can execute some else condition over here in case of valid JSON

Dies liegt daran, dass json_decode () NULL zurückgibt, wenn die eingegebene Zeichenfolge nicht json oder ungültiger json ist.

Einfache Funktion zum Validieren von JSON

Wenn Sie Ihren JSON an mehreren Stellen validieren müssen, können Sie immer die folgende Funktion verwenden.

function is_valid_json( $raw_json ){
    return ( json_decode( $raw_json , true ) == NULL ) ? false : true ; // Yes! thats it.
}

In der obigen Funktion erhalten Sie im Gegenzug true, wenn es sich um einen gültigen JSON handelt.

function is_json($str){ 
    return json_decode($str) != null;
}

http://tr.php.net/manual/en/function.json-decode.php Der Rückgabewert ist null, wenn eine ungültige Codierung festgestellt wird.

Sie müssen Ihre Eingabe überprüfen, um sicherzustellen, dass die übergebene Zeichenfolge nicht leer und tatsächlich eine Zeichenfolge ist. Eine leere Zeichenfolge ist kein gültiger JSON.

function is_json($string) {
  return !empty($string) && is_string($string) && is_array(json_decode($string, true)) && json_last_error() == 0;
}

Ich denke , in PHP es wichtiger ist , zu bestimmen , ob das JSON - Objekt selbst hat Daten, da die Daten zu nutzen , müssen Sie anrufen json_encode()oder json_decode(). Ich schlage vor, leere JSON-Objekte zu verweigern, damit Sie nicht unnötig Codierungen und Decodierungen für leere Daten ausführen.

function has_json_data($string) {
  $array = json_decode($string, true);
  return !empty($string) && is_string($string) && is_array($array) && !empty($array) && json_last_error() == 0;
}

Dies wird es tun:

function isJson($string) {
    $decoded = json_decode($string); // decode our JSON string
    if ( !is_object($decoded) && !is_array($decoded) ) {
        /*
        If our string doesn't produce an object or array
        it's invalid, so we should return false
        */
        return false;
    }
    /*
    If the following line resolves to true, then there was
    no error and our JSON is valid, so we return true.
    Otherwise it isn't, so we return false.
    */
    return (json_last_error() == JSON_ERROR_NONE);
}

if ( isJson($someJsonString) ) {
    echo "valid JSON";
} else {
    echo "not valid JSON";
}

json_last_error()Gibt, wie in anderen Antworten gezeigt, alle Fehler von unserem letzten json_decode () zurück. Es gibt jedoch einige Edge-Anwendungsfälle, in denen diese Funktion allein nicht umfassend genug ist. Wenn Sie beispielsweise json_decode()eine Ganzzahl (z. B. :) 123oder eine Folge von Zahlen ohne Leerzeichen oder andere Zeichen (z. B. :) verwenden "123", wird die json_last_error()Funktion keinen Fehler abfangen.

Um dem entgegenzuwirken, habe ich einen zusätzlichen Schritt hinzugefügt, der sicherstellt, dass das Ergebnis json_decode()entweder ein Objekt oder ein Array ist. Wenn nicht, kehren wir zurück false.

Überprüfen Sie diese beiden Beispiele, um dies in Aktion zu sehen:

• Nur mit überprüfen json_last_error()
• Zuerst nach Objekt / Array suchen

Einfache Methode ist es, das JSON-Ergebnis zu überprüfen.

$result = @json_decode($json,true);
    if (is_array($result)) {
        echo 'JSON is valid';
    }else{
        echo 'JSON is not valid';
    }

in GuzzleHttp :

/**
 * Wrapper for json_decode that throws when an error occurs.
 *
 * @param string $json    JSON data to parse
 * @param bool $assoc     When true, returned objects will be converted
 *                        into associative arrays.
 * @param int    $depth   User specified recursion depth.
 * @param int    $options Bitmask of JSON decode options.
 *
 * @return mixed
 * @throws \InvalidArgumentException if the JSON cannot be decoded.
 * @link http://www.php.net/manual/en/function.json-decode.php
 */
function json_decode($json, $assoc = false, $depth = 512, $options = 0)
{
    $data = \json_decode($json, $assoc, $depth, $options);
    if (JSON_ERROR_NONE !== json_last_error()) {
        throw new \InvalidArgumentException(
            'json_decode error: ' . json_last_error_msg());
    }

    return $data;
}

/**
 * Wrapper for JSON encoding that throws when an error occurs.
 *
 * @param mixed $value   The value being encoded
 * @param int    $options JSON encode option bitmask
 * @param int    $depth   Set the maximum depth. Must be greater than zero.
 *
 * @return string
 * @throws \InvalidArgumentException if the JSON cannot be encoded.
 * @link http://www.php.net/manual/en/function.json-encode.php
 */
function json_encode($value, $options = 0, $depth = 512)
{
    $json = \json_encode($value, $options, $depth);
    if (JSON_ERROR_NONE !== json_last_error()) {
        throw new \InvalidArgumentException(
            'json_encode error: ' . json_last_error_msg());
    }

    return $json;
}

Früher habe ich nur nach einem Nullwert gesucht, was eigentlich falsch war.

    $data = "ahad";
    $r_data = json_decode($data);
    if($r_data){//json_decode will return null, which is the behavior we expect
        //success
    }

Der obige Code funktioniert gut mit Zeichenfolgen. Sobald ich jedoch eine Nummer gebe, löst sie sich auf. Zum Beispiel.

    $data = "1213145";
    $r_data = json_decode($data);

    if($r_data){//json_decode will return 1213145, which is the behavior we don't expect
        //success
    }

Es war sehr einfach, das zu reparieren, was ich getan habe.

    $data = "ahad";
    $r_data = json_decode($data);

    if(($r_data != $data) && $r_data)
        print "Json success";
    else
        print "Json error";

//Tested thoroughly, Should do the job:
public static function is_json(string $json):bool
{
    json_decode($json);
    if (json_last_error() === JSON_ERROR_NONE) {
        return true;
    }
    return false;
}

Ein anderer einfacher Weg

function is_json($str)
{
    return is_array(json_decode($str,true));
}

Wir müssen überprüfen, ob die übergebene Zeichenfolge nicht numerisch ist, da in diesem Fall json_decode keinen Fehler auslöst.

function isJson($str) {
    $result = false;
    if (!preg_match("/^\d+$/", trim($str))) {
        json_decode($str);
        $result = (json_last_error() == JSON_ERROR_NONE);
    }

    return $result;
}

Ich habe diese Frage gefunden, nachdem ich gestern in meiner Arbeit auf etwas Ähnliches gestoßen bin. Meine Lösung war am Ende eine Mischung aus einigen der oben genannten Ansätze:

function is_JSON($string) {

  $String_Is_JSON = (is_null(json_decode($string, TRUE))) ? FALSE : TRUE;

  return $String_Is_JSON;
}

Ich habe einige dieser Lösungen ausprobiert, aber nichts hat für mich funktioniert. Ich versuche diese einfache Sache:

$isJson = json_decode($myJSON);

if ($isJson instanceof \stdClass || is_array($isJson)) {
   echo("it's JSON confirmed");
} else {
   echo("nope");
}

Ich denke, es ist eine gute Lösung, da JSON-Dekodierung ohne den zweiten Parameter ein Objekt ergibt.

BEARBEITEN: Wenn Sie wissen, was die Eingabe sein wird, können Sie diesen Code an Ihre Bedürfnisse anpassen. In meinem Fall weiß ich, dass ich einen Json habe, der mit "{" beginnt, daher muss ich nicht überprüfen, ob es sich um ein Array handelt.

Unter Verwendung von PHPBench mit der folgenden Klasse wurden die folgenden Ergebnisse erzielt:

<?php

declare(strict_types=1);

/**
 * Benchmark doctrine persistent collection count method vs sizeof toArray
 * Revs is the number of times you want the benchmark to run
 * @Revs(1000)
 * @Iterations(100)
 */
class BenchmarkJson
{
    public function benchCatchValid(): bool
    {
        $validJson = '{"validJson":true}';
        try {
            json_decode($validJson, true, 512, JSON_THROW_ON_ERROR);
            return true;
        } catch(\JsonException $exception) {}
        return false;
    }

    public function benchCatchInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        try {
            json_decode($invalidJson, true, 512, JSON_THROW_ON_ERROR);
            return true;
        } catch(\JsonException $exception) {}
        return false;
    }

    public function benchLastErrorValid(): bool
    {
        $validJson = '{"validJson":true}';
        json_decode($validJson, true);
        return (json_last_error() === JSON_ERROR_NONE);
    }

    public function benchLastErrorInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        json_decode($invalidJson, true);
        return (json_last_error() === JSON_ERROR_NONE);
    }

    public function benchNullValid(): bool
    {
        $validJson = '{"validJson":true}';
        return (json_decode($validJson, true) !== null);
    }

    public function benchNullInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        return (json_decode($invalidJson, true) !== null);
    }
}

6 subjects, 600 iterations, 6,000 revs, 0 rejects, 0 failures, 0 warnings
(best [mean mode] worst) = 0.714 [1.203 1.175] 1.073 (μs)
⅀T: 721.504μs μSD/r 0.089μs μRSD/r: 7.270%
suite: 1343ab9a3590de6065bc0bc6eeb344c9f6eba642, date: 2020-01-21, stime: 12:50:14
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+
| benchmark     | subject               | set | revs | its | mem_peak   | best    | mean    | mode    | worst   | stdev   | rstdev | diff  |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+
| BenchmarkJson | benchCatchValid       | 0   | 1000 | 100 | 2,980,168b | 0.954μs | 1.032μs | 1.016μs | 1.428μs | 0.062μs | 6.04%  | 1.33x |
| BenchmarkJson | benchCatchInvalid     | 0   | 1000 | 100 | 2,980,184b | 2.033μs | 2.228μs | 2.166μs | 3.001μs | 0.168μs | 7.55%  | 2.88x |
| BenchmarkJson | benchLastErrorValid   | 0   | 1000 | 100 | 2,980,184b | 1.076μs | 1.195μs | 1.169μs | 1.616μs | 0.083μs | 6.97%  | 1.54x |
| BenchmarkJson | benchLastErrorInvalid | 0   | 1000 | 100 | 2,980,184b | 0.785μs | 0.861μs | 0.863μs | 1.132μs | 0.056μs | 6.54%  | 1.11x |
| BenchmarkJson | benchNullValid        | 0   | 1000 | 100 | 2,980,168b | 0.985μs | 1.124μs | 1.077μs | 1.731μs | 0.114μs | 10.15% | 1.45x |
| BenchmarkJson | benchNullInvalid      | 0   | 1000 | 100 | 2,980,184b | 0.714μs | 0.775μs | 0.759μs | 1.073μs | 0.049μs | 6.36%  | 1.00x |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+

Fazit: Der schnellste Weg, um zu überprüfen, ob json gültig ist, ist die Rückkehr json_decode($json, true) !== null).

Ich weiß nichts über die Leistung oder Eleganz meiner Lösung, aber ich verwende Folgendes:

if (preg_match('/^[\[\{]\"/', $string)) {
    $aJson = json_decode($string, true);
    if (!is_null($aJson)) {
       ... do stuff here ...
    }
}

Da alle meine JSON-codierten Zeichenfolgen mit {"beginnen, reicht es aus, dies mit einem RegEx zu testen. Ich spreche überhaupt nicht fließend mit RegEx, daher gibt es möglicherweise einen besseren Weg, dies zu tun. Außerdem: strpos () ist möglicherweise schneller.

Ich versuche nur, meine Tuppence wert zu geben.

PS Gerade die RegEx-Zeichenfolge aktualisiert, /^[\[\{]\"/um auch JSON-Array-Zeichenfolgen zu finden. Daher wird am Anfang des Strings entweder nach ["oder {" gesucht.

Sollte so etwas sein:

 function isJson($string)
 {
    // 1. Speed up the checking & prevent exception throw when non string is passed
    if (is_numeric($string) ||
        !is_string($string) ||
        !$string) {
        return false;
    }

    $cleaned_str = trim($string);
    if (!$cleaned_str || !in_array($cleaned_str[0], ['{', '['])) {
        return false;
    }

    // 2. Actual checking
    $str = json_decode($string);
    return (json_last_error() == JSON_ERROR_NONE) && $str && $str != $string;
}

Gerätetest

public function testIsJson()
{
    $non_json_values = [
        "12",
        0,
        1,
        12,
        -1,
        '',
        null,
        0.1,
        '.',
        "''",
        true,
        false,
        [],
        '""',
        '[]',
        '   {',
        '   [',
    ];

   $json_values = [
        '{}',
        '{"foo": "bar"}',
        '[{}]',
        '  {}',
        ' {}  '
    ];

   foreach ($non_json_values as $non_json_value) {
        $is_json = isJson($non_json_value);
        $this->assertFalse($is_json);
    }

    foreach ($json_values as $json_value) {
        $is_json = isJson($json_value);
        $this->assertTrue($is_json);
    }
}

Erweitern dieser Antwort Wie wäre es mit Folgendem:

<?php

    $json = '[{"user_id":13,"username":"stack"},{"user_id":14,"username":"over"}]';
    //$json = '12';

    function isJson($string) {
        json_decode($string);
        if(json_last_error() == JSON_ERROR_NONE) {
            if(substr($string,0,1) == '[' && substr($string,-1) == ']') { return TRUE; }
            else if(substr($string,0,1) == '{' && substr($string,-1) == '}') { return TRUE; }
            else { return FALSE; }
        }
    }

    echo isJson($json);
?>

Hallo, hier ist ein kleiner Ausschnitt aus meiner Bibliothek. In diesem ersten Zustand überprüfe ich nur, ob die Daten json sind, und gebe sie dann zurück, wenn sie korrekt dekodiert sind. Bitte beachten Sie die Substr-Verwendung für die Leistung (ich habe noch keine json-Datei gesehen, die auch nicht beginnt von {oder [

$input=trim($input);
if ((substr($input, 0, 1) == '{' && substr($input, -1) == '}') or (substr($input, 0, 1) == '[' && substr($input, -1) == ']')) {
    $output = json_decode($input, 1);
    if (in_array(gettype($output),['object','array'])) {
        #then it's definitely JSON
    }
}

Der schnellste Weg , um vielleicht zu entschlüsseln ein mögliche JSON - Objekt an einem PHP - Objekt / Array:

/**
 * If $value is a JSON encoded object or array it will be decoded 
 * and returned.
 * If $value is not JSON format, then it will be returned unmodified.
 */
function get_data( $value ) {
    if ( ! is_string( $value ) ) { return $value; }
    if ( strlen( $value ) < 2 ) { return $value; }
    if ( '{' != $value[0] && '[' != $value[0] ) { return $value; }

    $json_data = json_decode( $value );
    if ( ! $json_data ) { return $value; }
    return $json_data;
}

Hier ist eine performante und einfache Funktion, die ich erstellt habe (die die grundlegende Zeichenfolgenüberprüfung verwendet, bevor sie json_decodefür größere Zeichenfolgen verwendet wird):

function isJson($string) {
    $response = false;

    if (
        is_string($string) &&
        ($string = trim($string)) &&
        ($stringLength = strlen($string)) &&
        (
            (
                stripos($string, '{') === 0 &&
                (stripos($string, '}', -1) + 1) === $stringLength
            ) ||
            (
                stripos($string, '[{') === 0 &&
                (stripos($string, '}]', -1) + 2) === $stringLength
            )
        ) &&
        ($decodedString = json_decode($string, true)) &&
        is_array($decodedString)
    ) {
        $response = true;
    }

    return $response;
}