it-swarm.com.de

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

Ich brauche eine wirklich sehr schnelle Methode, um zu überprüfen, ob eine Zeichenfolge JSON ist oder nicht. Ich finde, 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?

316
Kirk Ouimet
function isJson($string) {
 json_decode($string);
 return (json_last_error() == JSON_ERROR_NONE);
}
496

Antwort auf die Frage

Die Funktion json_last_error gibt den letzten Fehler zurück, der während der JSON-Codierung und -Decodierung aufgetreten ist. Der schnellste Weg, den gültigen 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 nur in PHP> = 5.3.0 unterstützt wird.

Vollständiges Programm, um den genauen Fehler zu überprüfen

Es ist immer gut, den genauen Fehler während der Entwicklungszeit zu kennen. Hier ist das vollständige 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ültige Ausgabe

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

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

Testen mit ungültiger 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ätzliche Anmerkung für (PHP> = 5.2 && PHP <5.3.0)

Da json_last_error in PHP 5.2 nicht unterstützt wird, können Sie überprüfen, ob die Kodierung oder Dekodierung boolean FALSE zurückgibt. 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!

137
Madan Sapkota

Bei Verwendung von json_decode zum "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, wenn viele Objekte von Arrays instantiiert werden, um sie einfach wegzuwerfen. 

Daher ist es möglicherweise schneller, preg_match und RFC4627 regex zu verwenden, um auch Gültigkeit sicherzustellen:

  // 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 eines Performance-Enthusiasten, sich hier jedoch mit Benchmarks zu beschäftigen. 

69
mario

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

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

Diese Anfrage erfordert auch keine eigene Funktion. Wickeln Sie einfach is_object um json_decode und fahren Sie fort. Anscheinend hat diese Lösung zu viel Nachdenken.

69
user1653711

Dies gibt true zurück, wenn Ihre Zeichenfolge ein json-Array oder ein 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 ein boolesches Zeichen enthalten, obwohl diese Zeichenfolgen technisch gültig 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.

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

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

16
AhmetB - Google

Der einfachste und schnellste Weg, den ich benutze, ist zu folgen;

$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ültig ist. 


Einfache Funktion zur Überprüfung von JSON

Wenn Sie Ihre 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 true, wenn es sich um eine gültige JSON handelt.

14

Sie müssen Ihre Eingabe überprüfen, um sicherzustellen, dass die übergebene Zeichenfolge nicht leer ist 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 ist es wichtiger zu bestimmen, ob das JSON-Objekt sogar über data verfügt, da zur Verwendung der Daten json_encode() oder json_decode() aufgerufen werden muss. Ich empfehle, leere JSON-Objekte zu verweigern, damit Sie keine unnötigen Codierungen und Dekodierungen 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;
}
11
upful

Einfache Methode ist die Überprüfung des Json-Ergebnisses.

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

Das wird es tun:

function isJson($string) {
    $decoded = json_decode($string);
    if ( !is_object($decoded) && !is_array($decoded) ) {
        return false;
    }
    return (json_last_error() == JSON_ERROR_NONE);
}

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

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 Strings. Sobald ich jedoch eine Nummer gebe, bricht sie zum Beispiel auf.

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

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

Um es zu beheben, was ich tat, war es sehr einfach.

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

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

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

Ein anderer einfacher Weg

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

Wir müssen überprüfen, ob der übergebene String 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;
}
4

Ich habe einige dieser Lösungen ausprobiert, aber für mich funktionierte nichts. 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 ohne den zweiten Parameter ein Objekt decodiert.

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. Ich muss also nicht prüfen, ob es sich um ein Array handelt.

3
Greco Jonathan

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);
    }
}
1
Tinh Dang

Ich weiß nicht über die Leistung oder die Eleganz meiner Lösung Bescheid, aber es ist was ich verwende:

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

Da alle meine JSON-codierten Zeichenfolgen mit {"beginnen, genügt es, dies mit einem RegEx zu testen. Ich bin mit RegEx überhaupt nicht fließend, daher könnte es einen besseren Weg geben, dies zu tun. Außerdem: strpos () könnte schneller sein.

Ich versuche nur, mein Geld wert zu geben.

P.S. Die RegEx-Zeichenfolge wurde einfach auf /^[\[\{]\"/ aktualisiert, um auch JSON-Array-Zeichenfolgen zu finden. Also sucht es jetzt entweder nach ["oder {" am Anfang des Strings.

1
maxpower9000

Erweiterung auf diese 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);
?>
1
Sevenearths

Neue Funktion für die Kompatibilität von PHP 5.2, wenn Sie die decodierten Daten zum Erfolg benötigen:

function try_json_decode( $json, & $success = null ){
  // non-strings may cause warnings
  if( !is_string( $json )){
    $success = false;
    return $json;
  }

  $data = json_decode( $json );

  // output arg
  $success =

    // non-null data: success!
    $data !==  null  ||

    // null data from 'null' json: success!
    $json === 'null' ||

    // null data from '  null  ' json padded with whitespaces: success!
    preg_match('/^\s*null\s*$/', $json );

  // return decoded or original data
  return $success ? $data : $json;
}

Verwendungszweck:

$json_or_not = ...;

$data = try_json_decode( $json_or_not, $success );

if( $success )
     process_data( $data );
else what_the_hell_is_it( $data );

Einige Tests:

var_dump( try_json_decode( array(), $success ), $success );
// ret = array(0){}, $success == bool(false)

var_dump( try_json_decode( 123, $success ), $success );
// ret = int(123), $success == bool(false)

var_dump( try_json_decode('      ', $success ), $success );
// ret = string(6) "      ", $success == bool(false)

var_dump( try_json_decode( null, $success ), $success );
// ret = NULL, $success == bool(false)

var_dump( try_json_decode('null', $success ), $success );
// ret = NULL, $success == bool(true)

var_dump( try_json_decode('  null  ', $success ), $success );
// ret = NULL, $success == bool(true)

var_dump( try_json_decode('  true  ', $success ), $success );
// ret = bool(true), $success == bool(true)

var_dump( try_json_decode('  "hello"  ', $success ), $success );
// ret = string(5) "hello", $success == bool(true)

var_dump( try_json_decode('  {"a":123}  ', $success ), $success );
// ret = object(stdClass)#2 (1) { ["a"]=> int(123) }, $success == bool(true)
0
biziclop

Noch ein Vorschlag von mir :)

function isJson(string $string) {
  return ($result = json_decode($string, true)) ? $result : $string;
}
0
kalicki2k

Hallo, hier ist ein kleiner Ausschnitt aus meiner Bibliothek. In dieser ersten Bedingung prüfe ich nur, ob die Daten json sind, und bringe sie zurück, wenn sie richtig dekodiert wurde 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
    }
}
0
Jack
function is_json($input) {

    $input = trim($input);

    if (substr($input,0,1)!='{' OR substr($input,-1,1)!='}')
        return false;

    return is_array(@json_decode($input, true));
}
0
GONZO

Der schnellste Weg zum vielleicht Dekodieren eines möglichen JSON-Objekts zu 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;
}
0
Philipp

Die benutzerdefinierte Funktion

function custom_json_decode(&$contents=NULL, $normalize_contents=true, $force_array=true){

    //---------------decode contents---------------------

    $decoded_contents=NULL;

    if(is_string($contents)){

        $decoded_contents=json_decode($contents,$force_array);

    }

    //---------------normalize contents---------------------

    if($normalize_contents===true){

        if(is_string($decoded_contents)){

            if($decoded_contents==='NULL'||$decoded_contents==='null'){

                $contents=NULL;
            }
            elseif($decoded_contents==='FALSE'||$decoded_contents==='false'){

                $contents=false;
            }
        }
        elseif(!is_null($decoded_contents)){

            $contents=$decoded_contents;
        }
    }
    else{

        //---------------validation contents---------------------

        $contents=$decoded_contents;
    }

    return $contents;
}

Fälle

$none_json_str='hello';

//------------decoding a none json str---------------

$contents=custom_json_decode($none_json_str); // returns 'hello'

//------------checking a none json str---------------

custom_json_decode($none_json_str,false);

$valid_json=false;

if(!is_null($none_json_str)){

    $valid_json=true;

}

Ressourcen

https://Gist.github.com/rafasashi/93d06bae83cc1a1f440b

0
RafaSashi

Eine einfache Änderung an Henriks Antwort, um die meisten erforderlichen Möglichkeiten zu berühren.

(einschließlich "{} und []")

function isValidJson($string) {
    json_decode($string);
    if(json_last_error() == JSON_ERROR_NONE) {

        if( $string[0] == "{" || $string[0] == "[" ) { 
            $first = $string [0];

            if( substr($string, -1) == "}" || substr($string, -1) == "]" ) {
                $last = substr($string, -1);

                if($first == "{" && $last == "}"){
                    return true;
                }

                if($first == "[" && $last == "]"){
                    return true;
                }

                return false;

            }
            return false;
        }

        return false;
    }

    return false;

}
0
user4395445