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?
function isJson($string) {
json_decode($string);
return (json_last_error() == JSON_ERROR_NONE);
}
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!
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.
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.
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.
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.
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.
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;
}
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';
}
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";
}
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";
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;
}
Ein anderer einfacher Weg
function is_json($str)
{
return is_array(json_decode($str,true));
}
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;
}
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.
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);
}
}
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.
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);
?>
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)
Noch ein Vorschlag von mir :)
function isJson(string $string) {
return ($result = json_decode($string, true)) ? $result : $string;
}
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
}
}
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));
}
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;
}
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
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;
}