example - php string to json encode




Schnellste Möglichkeit zu überprüfen, ob eine Zeichenkette JSON in PHP ist? (16)

Antwort auf die Frage

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

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

Volles Programm, um den genauen FEHLER zu überprüfen

Es ist immer gut den genauen Fehler während der Entwicklungszeit zu kennen. Hier ist ein vollständiges Programm, um den genauen Fehler anhand von 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ültigem JSON

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

Ungültiger OUTPUT

Syntax error, malformed JSON.

Zusätzliche Notiz 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 den Wahrheitswert FALSE zurückgibt. Hier ist ein Beispiel

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

Ich hoffe, das ist hilfreich. Glückliche Kodierung!

Ich brauche eine wirklich 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;
}

Irgendwelche Performance-Enthusiasten da draußen wollen diese Methode verbessern?


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

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

Diese Anforderung erfordert keine separate Funktion. Wickeln Sie einfach is_object um json_decode und gehen Sie weiter. Es scheint, dass diese Lösung die Leute dazu bringt, viel zu viel nachzudenken.


Die einfachste und schnellste Art, die ich verwende, ist das Folgen;

$json_array = json_decode( $raw_json , true );


if( $json_array == NULL )   //check if it was invalid json string

die ('Invalid');  // json error


 // you can enter some else condition to display success message over here

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


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 weist JSON-Strings zurück, die nur eine Zahl, einen String oder einen Booleschen Wert enthalten, obwohl diese Strings 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 mir vorstellen kann.


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;

}

Eine einfache Methode ist 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';
    }

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
    }

Das obige Stück Code funktioniert gut mit Strings. Sobald ich jedoch Nummer zur Verfügung stelle, bricht es 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
    }

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

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

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

Frisch erstellte Funktion für PHP 5.2 Kompatibilität, wenn Sie die dekodierten 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;
}

Verwendung:

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

Ich habe so etwas probiert

<?php 
/* valid json */
$json1 = 
json_encode([
    'foo' => 'bar',
    'bar',
    'foo2   ' => [
        'bar' => 'foo',
        'try'=> 32,
        'foo',
        'bar',
        [[[[[[]]]]]]
    ],
    'foobar'=>[
        'foo'=>'bar',
        'bar'=>'foo'
    ]
]);
$json2 = 
json_encode([
    'foo' => 'bar',
    'bar',
    'foo2   ' => [
        'bar' => 'foo',
        'try'=> 32,
        'foo',
        'bar',
        [[[[[[]]]]]]
    ],
    'foobar'=>[
        'foo'=>'bar',
        'bar'=>'foo'
    ]
]) . ';'; // << invalid json

$mt = microtime(1);
for($i=0;$i<1000000;$i++){
    check1($json1);
    check1($json2);
}
echo "PROCESS TOOK: " . (microtime(1) - $mt) . " seconds\n";

$mt = microtime(1);
for($i=0;$i<1000000;$i++){
    check2($json1);
    check2($json2);
}
echo "PROCESS TOOK: " . (microtime(1) - $mt) . " seconds\n";

function check1($json){
    return preg_match('/(?(DEFINE)(?<number>-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?)(?<boolean>true|false|null)(?<string>"([^"\\\\]*|\\\\["\\\\bfnrt\/]|\\\\u[0-9a-f]{4})*")(?<array>\[(?:(?&json)(?:,(?&json))*)?\s*\])(?<pair>\s*(?&string)\s*:(?&json))(?<object>\{(?:(?&pair)(?:,(?&pair))*)?\s*\})(?<json>\s*(?:(?&number)|(?&boolean)|(?&string)|(?&array)|(?&object))\s*))\A(?&json)\Z/six', $json);
}

function check2($json){
    json_decode($json);
    return (json_last_error() === JSON_ERROR_NONE);
}

Ausgabe

PROCESS TOOK: 7.5640170574188 seconds
PROCESS TOOK: 4.4907619953156 seconds

Es gibt ~ 3 Sekunden Unterschied zwischen der regulären Ausdruckfunktion und der nativen json_decode-Funktion, aber es passiert nach 1 Million Wiederholungen, so dass es sowieso nicht zu kurz ist

edit: nach ein paar Gedanken bevorzuge ich das;

if(checkjson($json)){
    echo "this is json :3\n";
    var_dump($json);
} else {
    die('omg this is not json!!!');
}

function checkjson(&$json){
    $json = json_decode($json);
    return (json_last_error() === JSON_ERROR_NONE);
}

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

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

Da alle meine JSON-codierten Strings mit {beginnen "genügt es, dies mit einer RegEx zu testen. Ich bin mit RegEx überhaupt nicht flüssig, also könnte es einen besseren Weg dazu geben. Auch: strpos() könnte schneller sein.

Ich versuche nur, meinen tupence Wert zu geben.

PS: Habe gerade die RegEx-Zeichenkette auf /^[\[\{]\"/ aktualisiert, um auch JSON-Array-Zeichenketten zu finden. Daher sucht sie nun am Anfang der Zeichenkette entweder nach [" oder "".


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 Daten enthält, denn um die Daten zu verwenden, müssen Sie json_encode() oder json_decode() . Ich schlage vor, 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;
}

Wir müssen prü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;
}

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


Sollte in etwa so 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);
    }
}

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





jsonresult