दिलचस्प पोस्ट
टीडी के अंदर एक डीआईवी एक बुरा विचार है? स्टोरीबोर्ड के साथ कस्टम दृश्य एंड्रॉइड में हवाई जहाज मोड टॉगल करें जावास्क्रिप्ट हैशमैप समतुल्य अगले पृष्ठ पर PHP पास चर जो कि जीटग्नोर नियम मेरी फाइल की अनदेखी कर रहा है टैबिंडेक्स से एचटीएमएल तत्व की उपेक्षा कैसे करें? कैसे पृष्ठ लोड के बाद jQuery के माध्यम से गतिशील रूप से एक <स्क्रिप्ट> टैग डालें? अपलोड किए गए फ़ाइल को एक निर्देशिका में सहेजने से पहले उसका नाम कैसे बदलें? HttpServletRequest JSON POST डेटा प्राप्त करें खाली पकड़ क्यों एक बुरा विचार रोकता है? $ स्थान / html5 और हैशबैंग मोड / लिंक रीरलाईटिंग के बीच स्विचिंग आउटलुक '07 / '10 / '13 पर पूर्ण चौड़ाई वाली पृष्ठभूमि निर्देशिका में सभी फ़ाइलों और फ़ोल्डरों को कैसे हटाएं? केवल विशिष्ट पंक्तियां पढ़ना (पायथन)

जाँच करने के लिए सबसे तेज़ तरीका है कि स्ट्रिंग JSON में PHP है या नहीं?

मुझे स्ट्रिंग JSON है या नहीं, यह जाँचने के लिए वास्तव में, वास्तव में तेजी से विधि की आवश्यकता है I मुझे लगता है कि यह सबसे अच्छा तरीका नहीं है:

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

कोई प्रदर्शन उत्साही इस पद्धति में सुधार करना चाहते हैं?

वेब के समाधान से एकत्रित समाधान "जाँच करने के लिए सबसे तेज़ तरीका है कि स्ट्रिंग JSON में PHP है या नहीं?"

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

सवाल का जवाब है

फ़ंक्शन json_last_error JSON एन्कोडिंग और डिकोडिंग के दौरान हुई अंतिम त्रुटि देता है। तो मान्य JSON की जांच करने का सबसे तेज़ तरीका है

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

ध्यान दें कि json_last_error PHP में समर्थित है> = 5.3.0 केवल

सटीक त्रुटि की जांच करने के लिए पूर्ण कार्यक्रम

विकास के समय के दौरान सटीक त्रुटि को जानने में हमेशा अच्छा होता है 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; } 

मान्य JSON INPUT के साथ परीक्षण

 $json = '[{"user_id":13,"username":"stack"},{"user_id":14,"username":"over"}]'; $output = json_validate($json); print_r($output); 

वैध आउटपुट

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

अवैध JSON के साथ परीक्षण

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

अमान्य आउटपुट

 Syntax error, malformed JSON. 

(PHP> = 5.2 && PHP <5.3.0) के लिए अतिरिक्त नोट

चूंकि json_last_error PHP 5.2 में समर्थित नहीं है, आप देख सकते हैं कि एन्कोडिंग या डिकोडिंग बूलियन FALSE वापस आता है। यहाँ एक उदाहरण है

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

आशा है कि यह उपयोगी है हैप्पी कोडिंग!

json_decode का उपयोग करने के लिए "जांच" यह वास्तव में सबसे तेज़ तरीका नहीं हो सकता है अगर यह गहराई से नेस्टेड संरचना है, तो उन्हें सिर्फ फेंकने के लिए बहुत सारे ऑरेंजों को तत्काल तर्ज करना स्मृति और समय की बर्बादी है

इसलिए यह वैधता सुनिश्चित करने के लिए preg_match और RFC4627 regex का उपयोग करने के लिए तेज़ हो सकता है:

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

PHP में एक ही है:

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

बेंचमार्क के साथ परेशान करने के लिए पर्याप्त प्रदर्शन करने वाला उत्साही नहीं है।

आप सभी को वास्तव में करने की ज़रूरत है …

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

इस अनुरोध के लिए एक अलग फ़ंक्शन भी आवश्यक नहीं है। बस json_decode के आसपास is_object लपेटो और आगे बढ़ें। इस समाधान को लगता है कि लोगों ने इसे बहुत ज्यादा सोचा है।

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

http://tr.php.net/manual/en/function.json-decode.php वापसी मान अयोग्य है जब अमान्य एन्कोडिंग का पता चला।

यह सुनिश्चित करने के लिए आपको अपने इनपुट को मान्य करना होगा कि आप पास की गई स्ट्रिंग खाली नहीं है और वास्तव में, एक स्ट्रिंग है एक खाली स्ट्रिंग मान्य JSON नहीं है

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

मुझे लगता है कि PHP में यह निर्धारित करना अधिक महत्वपूर्ण है कि JSON ऑब्जेक्ट में डेटा भी है , क्योंकि डेटा का उपयोग करने के लिए आपको json_encode() या json_decode() कॉल करने की आवश्यकता होगी। मैं खाली JSON ऑब्जेक्ट को नकारने का सुझाव देता हूं ताकि आप अनावश्यक रूप से रिक्त डेटा पर एन्कोड और डीकोड नहीं चलाएं।

 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 isJson($str) { $json = json_decode($str); return $json && $str != $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) 

यह कम से कम तरीका है जिसका मैं साथ आ सकता हूं।

आसान तरीका जेएसन परिणाम की जांच करना है ..

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

एक और आसान तरीका

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

इससे पहले मैं सिर्फ एक शून्य मूल्य की जांच कर रहा था, जो वास्तव में गलत था।

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

कोड के उपरोक्त टुकड़े तारों के साथ ठीक काम करता है हालांकि जैसे ही मैं नंबर प्रदान करता हूं, यह टूट जाता है। उदाहरण के लिए।

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

इसे ठीक करने के लिए मैंने जो किया वह बहुत सरल था।

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

सबसे आसान और तेज़ तरीका है जिसका मैं उपयोग करता हूं;

 $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 () नल देता है यदि प्रविष्ट स्ट्रिंग JSON या अमान्य जेसन नहीं है

हमें यह जांचना होगा कि पारित स्ट्रिंग संख्यात्मक नहीं है क्योंकि इस मामले में json_decode कोई त्रुटि नहीं उठाती है।

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

गज़ले में एचटीटीपी :

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

मुझे अपने समाधान के प्रदर्शन या सुंदरता के बारे में नहीं पता है, लेकिन मैं इसका उपयोग कर रहा हूं:

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

चूंकि मेरी सभी JSON एन्कोडेड स्ट्रिंग्स शुरू होती हैं ("यह एक RegEx के साथ परीक्षण करने के लिए पर्याप्त है। मैं RegEx के साथ बिल्कुल धारणा नहीं हूं, इसलिए ऐसा करने का एक बेहतर तरीका हो सकता है। इसके अलावा: स्ट्रॉप्स () तेज हो सकता है।

बस मेरी ट्यूपेंस के लायक में देने की कोशिश कर रहा है

पीएस ने /^[\[\{]\"/ JSON सरणी स्ट्रिंग्स को भी खोजने के लिए RegEx स्ट्रिंग को अपडेट किया है। इसलिए यह अब [" या {"स्ट्रिंग की शुरुआत में दिखता है।

इस उत्तर को विस्तृत करना निम्न के बारे में कैसे:

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

कस्टम फ़ंक्शन

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

मामले

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

साधन

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

PHP 5.2 संगतता के लिए ताज़ा ढंग से निर्मित फ़ंक्शन, यदि आपको सफलता पर डीकोड किए गए डेटा की आवश्यकता है:

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

उपयोग:

 $json_or_not = ...; $data = try_json_decode( $json_or_not, $success ); if( $success ) process_data( $data ); else what_the_hell_is_it( $data ); 

कुछ परीक्षण:

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

सबसे आवश्यक संभावनाओं को स्पर्श करने के लिए हेनरिक के उत्तर के लिए एक सरल संशोधन।

("{} और []" सहित)

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

किसी संभव ऑब्जेक्ट / सरणी में संभव JSON ऑब्जेक्ट को डीकोड करने का सबसे तेज़ तरीका:

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

मैंने उन समाधानों में से कुछ की कोशिश की है, लेकिन कुछ भी मेरे लिए काम नहीं कर रहा था मैं इस साधारण बात की कोशिश करता हूं:

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

मुझे लगता है कि यह एक अच्छा solutiuon है क्योंकि JSON डीकोड दूसरे पैरामीटर के बिना एक ऑब्जेक्ट दे।

ive ऐसा कुछ करने की कोशिश की

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

उत्पादन

 PROCESS TOOK: 7.5640170574188 seconds PROCESS TOOK: 4.4907619953156 seconds 

नियमित अभिव्यक्ति समारोह और देशी json_decode फ़ंक्शन के बीच अंतर का ~ 3 सेकंड है, लेकिन यह दोहराने के 1 मिलियन गुना के बाद होता है, इसलिए यह बहुत छोटा नहीं है

संपादित करें: कुछ विचारों के बाद मुझे यह पसंद है;

 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); } 
 if(!empty(json_decode($data))) { echo "real json"; } 

इस फ़ंक्शन के साथ इसे जांचें:

 function is_json($string) { if (is_string($string) && !is_int($string) && !is_array($string)) { json_decode($string); return (json_last_error() == JSON_ERROR_NONE); } else { return false; } }