error-handling example - Schnellste Möglichkeit zu überprüfen, ob eine Zeichenkette JSON in PHP ist?




auslesen decode (21)

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

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?


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.


Mit json_decode zum " json_decode " ist es vielleicht 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 instanziieren, um sie einfach wegzuwerfen.

Es könnte also schneller sein, preg_match und den Regex RFC4627 zu verwenden, um auch die 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, der sich hier jedoch mit Benchmarks herumärgert.


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


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 ohne den zweiten Parameter ein Objekt dekodiert.

EDIT: 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, also muss ich nicht überprüfen, ob es ein Array ist.


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;

}

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

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

Ein weiterer einfacher Weg

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

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!


if(!empty(json_decode($data)))
{
echo "real json";
}

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.


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)

Der schnellste Weg, ein mögliches JSON-Objekt zu einem PHP-Objekt / Array zu dekodieren:

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

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

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


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

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

Es gibt viele Möglichkeiten, SQL-Injektionen und andere SQL-Hacks zu verhindern. Sie können es leicht im Internet finden (Google-Suche). Natürlich ist PDO eine der guten Lösungen. Aber ich möchte Ihnen einige gute Links vorbeugen, die durch SQL Injection verhindert werden.

Was ist SQL-Injection und wie kann man das verhindern?

PHP-Handbuch zur SQL-Injection

Microsoft Erklärung der SQL-Injection und -Vermeidung in PHP

und einige andere wie SQL-Injection mit MySQL und PHP verhindern

Nun, warum tun Sie Sie benötigen , um Ihre Abfrage von SQL - Injection zu verhindern?

Ich möchte Sie wissen lassen: Warum versuchen wir die SQL-Injektion mit einem kurzen Beispiel zu verhindern:

Abfrage zur Übereinstimmung der Anmeldeauthentifizierung:

$query="select * from users where email='".$_POST['email']."' and password='".$_POST['password']."' ";

Nun, wenn jemand (ein Hacker) setzt

$_POST['email']= [email protected]' OR '1=1

und Passwort alles ....

Die Abfrage wird nur bis zu:

$query="select * from users where email='[email protected]' OR '1=1';

Der andere Teil wird verworfen. Was wird also passieren? Ein nicht autorisierter Benutzer (Hacker) kann sich ohne sein Passwort als Administrator anmelden. Jetzt kann er alles tun, was der Administrator / E-Mail-Mitarbeiter tun kann. Es ist sehr gefährlich, wenn die SQL-Injection nicht verhindert wird.





php json error-handling json-deserialization jsonresult