Le moyen le plus rapide de vérifier si une chaîne est JSON en PHP?

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

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

Des amateurs de performances veulent améliorer cette méthode?

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

Réponse à la question

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

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

Notez que cela json_last_errorn'est pris en charge qu'en PHP> = 5.3.0.

Programme complet pour vérifier l'erreur exacte

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

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

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 JSON invalide

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

SORTIE invalide

Syntax error, malformed JSON.

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

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

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

J'espère que cela vous sera utile. Codage heureux!

Tout ce que vous devez vraiment faire, c'est ceci ...

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

Cette demande ne nécessite même pas de fonction distincte. Enroulez simplement is_object autour de json_decode et continuez. Il semble que cette solution incite les gens à y réfléchir beaucoup trop.

Utiliser json_decodepour "sonder" ce n'est peut-être pas le moyen le plus rapide. S'il s'agit d'une structure profondément imbriquée, instancier de nombreux objets de tableaux pour les jeter est une perte de mémoire et de temps.

Il pourrait donc être plus rapide à utiliser preg_matchet RFC4627 regex aussi assurer la validité :

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

La même chose en PHP:

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

Cependant, pas assez d'un passionné de performance pour se soucier des repères.

Cela retournera vrai si votre chaîne représente un tableau ou un objet json :

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

Il rejette les chaînes json qui ne contiennent qu'un nombre, une chaîne ou un booléen, bien que ces chaînes soient techniquement valides json.

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)

C'est le moyen le plus court que je puisse trouver.

Le moyen le plus simple et le plus rapide que j'utilise est le suivant;

$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

C'est parce que json_decode () renvoie NULL si la chaîne entrée n'est pas json ou json invalide.

Fonction simple pour valider JSON

Si vous devez valider votre JSON à plusieurs endroits, vous pouvez toujours utiliser la fonction suivante.

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

Dans la fonction ci-dessus, vous obtiendrez true en retour s'il s'agit d'un JSON valide.

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

http://tr.php.net/manual/en/function.json-decode.php la valeur de retour est nulle lorsqu'un encodage non valide a été détecté.

Vous devez valider votre entrée pour vous assurer que la chaîne que vous passez n'est pas vide et est en fait une chaîne. Une chaîne vide n'est pas un JSON valide.

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

Je pense qu'en PHP, il est plus important de déterminer si l'objet JSON a même des données, car pour utiliser les données, vous devrez appeler json_encode()ou json_decode(). Je suggère de refuser les objets JSON vides afin de ne pas exécuter inutilement les encodages et décodages sur les données vides.

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

Cela le fera:

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

Comme indiqué dans d'autres réponses, json_last_error()retourne toute erreur de notre dernier json_decode (). Cependant, il existe certains cas d'utilisation de pointe où cette fonction seule n'est pas suffisamment complète. Par exemple, si vous êtes json_decode()un entier (par exemple:) 123, ou une chaîne de nombres sans espaces ou autres caractères (par exemple:) "123", la json_last_error()fonction ne détectera pas d'erreur.

Pour lutter contre cela, j'ai ajouté une étape supplémentaire qui garantit que le résultat de notre json_decode()soit un objet ou un tableau. Si ce n'est pas le cas, nous revenons false.

Pour voir cela en action, vérifiez ces deux exemples:

• Vérifier uniquement auprès de json_last_error()
• Vérification de l'objet / du tableau en premier

La méthode la plus simple consiste à vérifier le résultat json.

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

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

Plus tôt, je vérifiais simplement une valeur nulle, ce qui était faux en fait.

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

Le morceau de code ci-dessus fonctionne correctement avec les chaînes. Cependant, dès que je fournis un numéro, il se casse, par exemple.

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

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

Pour y remédier, ce que j'ai fait était très simple.

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

Un autre moyen simple

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

Nous devons vérifier si la chaîne passée n'est pas numérique car dans ce cas json_decode ne déclenche aucune erreur.

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

    return $result;
}

J'ai trouvé cette question après avoir rencontré quelque chose de similaire dans mon travail, hier. Ma solution à la fin était un hybride de certaines des approches ci-dessus:

function is_JSON($string) {

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

  return $String_Is_JSON;
}

J'ai essayé certaines de ces solutions mais rien ne fonctionnait pour moi. J'essaie cette chose simple:

$isJson = json_decode($myJSON);

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

Je pense que c'est une bonne solutiuon puisque le décodage JSON sans le second paramètre donne un objet.

EDIT: Si vous savez quelle sera l'entrée, vous pouvez adapter ce code à vos besoins. Dans mon cas, je sais que j'ai un Json qui commence par "{", donc je n'ai pas besoin de vérifier s'il s'agit d'un tableau.

En utilisant PHPBench avec la classe suivante, les résultats ci-dessous ont été obtenus:

<?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 |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+

Conclusion: le moyen le plus rapide de vérifier si json est valide est de revenir json_decode($json, true) !== null).

Je ne connais pas les performances ou l'élégance de ma solution, mais c'est ce que j'utilise:

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

Étant donné que toutes mes chaînes codées JSON commencent par {", il suffit de tester cela avec un RegEx. Je ne suis pas du tout à l'aise avec RegEx, donc il pourrait y avoir une meilleure façon de le faire. Aussi: strpos () pourrait être plus rapide.

J'essaye juste de donner ma valeur de tuppence.

PS Nous venons de mettre à jour la chaîne RegEx /^[\[\{]\"/pour trouver également les chaînes de tableau JSON. Il recherche donc maintenant ["ou {" au début de la chaîne.

Devrait être quelque chose comme ça:

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

Test de l'unité

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

Développer cette réponse Que diriez-vous de ce qui suit:

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

Salut, voici un petit extrait de ma bibliothèque, dans cette première condition, je vérifie simplement si les données sont json puis les retourne si elles sont correctement décodées, veuillez noter l'utilisation de substr pour les performances (je n'ai encore vu aucun fichier json ne commençant pas non plus) par {ou [

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

Le moyen le plus rapide de décoder peut-être un objet JSON possible en un objet / tableau PHP:

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

Voici une fonction performante et simple que j'ai créée (qui utilise la validation de chaîne de base avant d'utiliser json_decodepour des chaînes plus grandes):

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