La façon la plus rapide de vérifier si une chaîne est du JSON en PHP?

Question

J'ai besoin d'une méthode vraiment, vraiment rapide pour vérifier si une chaîne est en JSON ou non. J'ai l'impression que ce n'est pas la meilleure façon de le faire :

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

Des passionnés de performance veulent-ils améliorer cette méthode ?

Answer 1

fonction isJson($string) {
   json_decode($string);
   retourner json_last_error() === JSON_ERROR_NONE;
}

Solution PHP >= 8.3 :

utiliser fonction intégré json_validate()

Answer 2

Réponse à la question

La fonction json_last_error renvoie la dernière erreur survenue lors de l'encodage et du décodage JSON. Ainsi, la manière la plus rapide de vérifier le JSON valide est

// décoder les données JSON
// définir le deuxième paramètre booléen TRUE pour une sortie de tableau associatif.
$result = json_decode($json);

if (json_last_error() === JSON_ERROR_NONE) {
    // JSON est valide
}

// OU c'est équivalent

if (json_last_error() === 0) {
    // JSON est valide
}

Notez que json_last_error est supporté uniquement dans PHP >= 5.3.0.

Programme complet pour vérifier l'ERREUR exacte

Il est toujours bon de connaître l'erreur exacte pendant le développement. Voici un programme complet pour vérifier l'erreur exacte basé sur la documentation PHP.

function json_validate($string)
{
    // décoder les données JSON
    $result = json_decode($string);

    // switch et vérifier les erreurs JSON possibles
    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            $error = ''; // JSON est valide // Aucune erreur ne s'est produite
            break;
        case JSON_ERROR_DEPTH:
            $error = 'La profondeur maximale de la pile a été dépassée.';
            break;
        case JSON_ERROR_STATE_MISMATCH:
            $error = 'JSON invalide ou malformé.';
            break;
        case JSON_ERROR_CTRL_CHAR:
            $error = 'Erreur de caractère de contrôle, peut-être encodé de manière incorrecte.';
            break;
        case JSON_ERROR_SYNTAX:
            $error = 'Erreur de syntaxe, JSON malformé.';
            break;
        // PHP >= 5.3.3
        case JSON_ERROR_UTF8:
            $error = 'Caractères UTF-8 mal formés, peut-être encodés de manière incorrecte.';
            break;
        // PHP >= 5.5.0
        case JSON_ERROR_RECURSION:
            $error = 'Une ou plusieurs références récursives dans la valeur à encoder.';
            break;
        // PHP >= 5.5.0
        case JSON_ERROR_INF_OR_NAN:
            $error = 'Une ou plusieurs valeurs NAN ou INF dans la valeur à encoder.';
            break;
        case JSON_ERROR_UNSUPPORTED_TYPE:
            $error = 'Une valeur d'un type qui ne peut pas être encodé a été donnée.';
            break;
        default:
            $error = 'Une erreur JSON inconnue s\'est produite.';
            break;
    }

    if ($error !== '') {
        // générer l'exception ou quitter // ou autre chose :)
        exit($error);
    }

    // tout va bien
    return $result;
}

Test avec une ENTRÉE JSON valide

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

Sortie valide

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

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

Test avec un JSON invalide

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

Sortie invalide

Erreur de syntaxe, JSON malformé.

Note supplémentaire pour (PHP >= 5.2 && PHP < 5.3.0)

Étant donné que json_last_error n'est pas pris en charge dans PHP 5.2, vous pouvez vérifier si l'encodage ou le décodage renvoie un booléen FALSE. Voici un exemple

// décoder les données JSON
$result = json_decode($json);
if ($result === FALSE) {
    // JSON est invalide
}

Answer 3

Tout ce que vous avez vraiment besoin de faire est cela...

if (is_object(json_decode($MyJSONArray))) 
{ 
    ... faire quelque chose ...
}

Cette requête ne nécessite même pas une fonction séparée. Il suffit d'envelopper is_object autour de json_decode et de continuer. Il semble que cette solution fait réfléchir les gens beaucoup trop.

Answer 4

Utiliser json_decode pour le "sonder" pourrait ne pas être la manière la plus rapide. S'il s'agit d'une structure profondément imbriquée, instancier beaucoup d'objets ou de tableaux pour ensuite les jeter est une perte de mémoire et de temps.

Il peut donc être plus rapide d'utiliser preg_match et l'regex RFC4627 pour également assurer la validité:

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

Le même en PHP:

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

Je ne suis pas assez enthousiaste de la performance pour m'embêter avec des benchmarks ici cependant.

Answer 5

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

http://tr.php.net/manual/fr/function.json-decode.php la valeur de retour est null lorsque l'encodage invalide est détecté.