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

Question

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

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

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

Comments

केवल json_decodeएक बार उपयोग करने पर विचार करें ... इसके अलावा, इनपुट और रिटर्न मान की जांच करें json_decode।

तो, कौन सा जवाब है?

— फरीद आरएन

यहाँ का टर्नरी स्विच बेमानी है। आपका कथन पहले से ही एक बूलियन के रूप में मूल्यांकन करता है।

— मैंने एक बार एक भालू को कुश्ती दी।

संभव डुप्लिकेट कैसे निर्धारित करने के लिए कि एक स्ट्रिंग वैध JSON है?

— एएल

लुईस डोनोवन के उत्तर को स्वीकार करें ... यह ठीक काम कर रहा है

— पूनम भट्ट

Answer 1

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

Comments

लगता है कि हर कोई इस जवाब को प्यार कर रहा है। कोई स्पष्टीकरण क्यों?

— किर्क ओईमेट

मेरा मानना ​​है कि PHP 5.3> को json_last_error फ़ंक्शन का उपयोग करने की आवश्यकता है

— क्रिस हैरिसन

स्ट्रिंग के पहले चरित्र की जाँच करना {, [या किसी भी अन्य शाब्दिक के पहले प्रतीक को संभावित रूप से इस एक को गति दे सकता है जब आने वाले कई तार गैर-JSON होने की उम्मीद है।

— ओलेग वी। वोल्कोव

$ फोन = '021234567'; var_dump (isJson ($ फोन)); सच लौटा दो ना! यह गलत होना चाहिए।

— वी

खबरदार, यह फ़ंक्शन किसी भी संख्या के लिए भी सही होगा, चाहे आप इसे स्ट्रिंग के रूप में निर्दिष्ट करें या सही संख्या। 6.5 = true, '300' = true, 9 = trueआदि तो यह एक वैध JSON मान हो सकता है लेकिन फ़ंक्शन आपकी अपेक्षा के अनुरूप व्यवहार नहीं कर सकता है, यदि आप केवल मान्य JSON स्ट्रिंग्स के लिए {}या उसके साथ ही जांच करना चाहते हैं [];

— 16

Answer 2

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

फ़ंक्शन json_last_errorJSON एन्कोडिंग और डीकोडिंग के दौरान हुई अंतिम त्रुटि देता है। तो वैध 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_errorPHP> = 5.3.0 में ही समर्थित है।

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

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

मान्य 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_errorPHP 5.2 में समर्थित नहीं है, आप जाँच सकते हैं कि एन्कोडिंग या डिकोडिंग रिटर्न बूलियन है या नहीं FALSE। यहाँ एक उदाहरण है

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

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

Comments

थोड़ी सी सटीकता: यदि यह जस्सन वैध है, लेकिन पिछली डिकोडेड अमान्य है, तो आपका कोड सही तरीके से काम करने वाला है, क्योंकि: " अंतिम JSON एन्कोडिंग / डिकोडिंग के दौरान हुई अंतिम त्रुटि (यदि कोई हो) वापस आती है। "

— ब्रूनो

धन्यवाद @Madan, "json_decode" सत्यापन ने मुझे हल कर दिया कि मैं PHP 7.0 चला रहा हूं।

— फ्रांसिस रोड्रिग्स

निश्चित रूप से json_decode केवल शाब्दिक असत्य के लिए गलत वापसी कर सकता है, इसलिए ((strlen($json) === 5) && ($json !== 'false'))उस किनारे से बचने के लिए एक चेक भी किया जाना चाहिए?

— MrMesees

@ ब्रूनो यदि अंतिम डिकोडिंग त्रुटियों के बिना काम करता है तो json_last_error वापस आ जाता है JSON_ERROR_NONE।

— एंड्रिया

Answer 3

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

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

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

Comments

@ RomanM.Kos बस स्पष्ट होने के लिए, यदि सरणी एक सरल सरणी है, तो आपको is_arrayइसके अलावा उपयोग करने की आवश्यकता है is_object, अन्यथा is_objectJSON के रूप में एन्कोड किए गए सरल सरणियों के लिए गलत वापस आ जाएगी। इसलिए @ggutenberg इस मामले में सही है। json_decodeकिसी ऑब्जेक्ट को एक सरणी के रूप में वापस करने के लिए बाध्य करने के लिए सच्चा तर्क पास करना । आप सिद्धांत में हमेशा एक सरणी के लिए डिकोड को बाध्य कर सकते हैं और बस is_arrayकाम करना चाहिए।

— userabuser

@userabuser यदि मैं json_encode($array)सरल PHP सरणी के लिए json_decode($str)हूँ , और फिर क्या मुझे ऑब्जेक्ट प्राप्त होगा, लेकिन सरणी नहीं। json_decode($str, true)सरणी में परिवर्तित करने के लिए बल। आपके कोड में जटिल स्ट्रिंग क्यों है? के लिए जाँच करें is_array(json_decode($str, true))और कुछ समय बाद जब आप इसे पढ़ेंगे तो आप समझेंगे कि डिकोड किया जाना केवल एक सरणी होना चाहिए। is_object(json_decode($MyJSONArray))"ओह, यहां मैं डिकोड करने के लिए जाँच कर रहा हूं, यह अनुमान लगाना कठिन है कि कोई सरणी है या नहीं?"

— रोमन एम। कोस

@ RomanM.Kos नहीं, यह सही नहीं है, codepad.viper-7.com/OFrtsq - जैसा कि मैंने कहा, आप हमेशा json_decodeऑब्जेक्ट और एरे के लिए जाँच करने के लिए आपको सहेजने के लिए एक सरणी वापस करने के लिए बाध्य कर सकते हैं , लेकिन यदि आप नहीं और आप json_decodeक्या करते हैं के साथ शुरू करने के लिए एक सरल सरणी थी, आप एक वस्तु नहीं, बल्कि डिकोड पर बदले में एक सरणी प्राप्त करेंगे। JSON_FORCE_OBJECTयदि आप किसी ऑब्जेक्ट को हमेशा एन्कोड पर देना चाहते हैं, तो एक साधारण ऐरे से गुजरते हुए उसका उपयोग करना चाहिए ।

— 5

कह के लिए downvote: This request does not require a separate function even। कड़ाई से बोलते हुए, किसी समाधान के लिए अलग फ़ंक्शन की आवश्यकता नहीं होती है। एक फ़ंक्शन का बिंदु कोड की कई पंक्तियों को कोड की एक पंक्ति की तरह बनाना नहीं है। फ़ंक्शन का बिंदु आपके एप्लिकेशन में हर जगह JSON-जाँच प्रक्रिया को मानक बनाना है, ताकि विभिन्न प्रोग्रामर (या समय के साथ एक ही प्रोग्रामर) प्रोग्राम के प्रवाह में विभिन्न चरणों में अलग-अलग जाँच प्रक्रियाओं का उपयोग न करें।

— कार्टेफोरहॉर्स

Answer 4

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

हालाँकि, बेंचमार्क से परेशान होने के लिए प्रदर्शन के लिए पर्याप्त नहीं है।

Comments

JSON को यहां सत्यापित करने के लिए पुनरावर्ती रीजेक्स को पूरा करें: stackoverflow.com/questions/2583472/regex-to-validate-json/… - लेकिन यह PHPs को बदल देता हैjson_decode हमेशा एक PCRE regex की तुलना में तेज़ होता है। (हालांकि यह बहुत अनुकूल नहीं है, कोई कृत्रिम परीक्षणों में पाया गया है, और पर्ल में अलग ढंग से व्यवहार हो सकता है ..)

— मारियो

@vee हाँ, नोट के लिए धन्यवाद। लेकिन इसे यहां [गलत तरीके से] रखें, इसलिए कोई भी वास्तव में उत्पादन में इसका उपयोग नहीं करता है।

— mario

@cartbeforehorse ठीक है, धन्यवाद। मैं तो PHP के दोहरे उद्धृत स्ट्रिंग संदर्भ के लिए भागने पौष्टिक तय की।

— मारियो

@ cartbeforehorse यह नहीं है। ज्यादातर सजावट। यह सिर्फ शाब्दिक बैकलैश है जिसमें वास्तव में दोगुना भागने की आवश्यकता होती है। इसके लिए \r \n \tकेवल यह समझ में आता है कि PHP उन्हें प्रक्षेपित नहीं करता है, लेकिन PCRE को उनकी व्याख्या करने दें (केवल /xमोड के लिए आवश्यक था )। अन्य घटनाओं को इसकी सख्त आवश्यकता नहीं है; अभी भी सभी स्ट्रिंग PHP संदर्भों में "बैकस्लैश खुद बच जाता है"। तो कोई इसे अधिक सटीक समझ सकता है।

— mario

@mario ठीक है, मैं देखता हूं। इसलिए मूल रूप से, रेज-एक्सप इंजन को देखने से पहले PHP बैकस्लैश से बच जाती है। जहाँ तक reg-exp इंजन की बात है, स्ट्रिंग में बैकस्लैश की आधी संख्या है जैसा कि हम मनुष्य देखते हैं। "जैसे reg-exp काफी पहले से ही जटिल नहीं था"

— कार्टेफोर्सहोर्स

Answer 5

यह सच है अगर आपका स्ट्रिंग एक json सरणी या ऑब्जेक्ट का प्रतिनिधित्व करता है :

function isJson($str) {
    $json = json_decode($str);
    return $json && $str != $json;
}

यह json strings को अस्वीकार करता है जिसमें केवल एक संख्या, स्ट्रिंग या बूलियन होता है, हालांकि वे तार तकनीकी रूप से मान्य 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)

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

Comments

Var_dump के बजाय, आप इसे PHPUnit परीक्षण-मामले में रख सकते हैं। अन्यथा मैं यह जानकर हैरान और खुश हूं कि यह सच है।

— ममेरीज़

जब यह महान काम करता है तो बाकी सभी के पास इतने लंबे घुमावदार जवाब क्यों होते हैं? धन्यवाद।

— टोडरमो

बस, प्यारी! "सबसे तेज़ तरीके" या प्रदर्शन के हिसाब से जाँच न करें, लेकिन यह सुनिश्चित करता है कि उन सभी मामलों को शामिल किया जाए जिनकी मैं कभी जाँच करता हूँ। यह कुख्यात कहावत के लिए एक उत्कृष्ट उदाहरण है "अखरोट को तोड़ने के लिए स्लेजहेमर का उपयोग न करें" । एक प्रोग्रामर के दृष्टिकोण से, कोड को सरल, छोटा और समझने में आसान रखना हमेशा बेहतर होता है, प्रदर्शन बनाम सरलता इस थ्रेड के लिए एक और बहस की गुंजाइश है।

— Fr0zenFyr

यह तर्क का एक छोटा सा हिस्सा है, लेकिन यह भी ध्यान दें कि यह खाली सरणियों के लिए गलत है। उदाहरण के लिए var_dump(isJson('[]')); // bool(false):। बूलियन्स पर प्रलेखन के अनुसार, यह इसलिए है क्योंकि PHP शून्य तत्वों के साथ सरणियों का मूल्यांकन करता है। वापसी विवरण को समायोजित करने के लिए यहां एक मामूली संशोधन है; यह डिकोडेड आउटपुट पर एक समान तुलना करता है जो इस मामले को संभालता है:return $json !== false && $str != $json;

— j13k

@ j13k आइडेंटिकल तुलना isJson('hello')सत्य का मूल्यांकन करती है, जो मान्य जोंस नहीं है। ढीली तुलना यहाँ उद्देश्य पर चुनी जाती है। मेरे पास खाली सरणी / वस्तु स्थिति के लिए एक त्वरित समाधान नहीं है, सिवाय एक बदसूरतreturn $json == '[]' || ...

— सिरिल

Answer 6

मेरे द्वारा उपयोग किया जाने वाला सबसे सरल और तेज़ तरीका निम्नलिखित है;

$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

यह इसलिए है क्योंकि json_decode () NULL लौटाता है यदि दर्ज किया गया स्ट्रिंग json या अमान्य json नहीं है।

JSON को मान्य करने के लिए सरल कार्य

यदि आपको अपने JSON को कई स्थानों पर मान्य करना है, तो आप हमेशा निम्न फ़ंक्शन का उपयोग कर सकते हैं।

function is_valid_json( $raw_json ){
    return ( json_decode( $raw_json , true ) == NULL ) ? false : true ; // Yes! thats it.
}

उपरोक्त फ़ंक्शन में, आपको बदले में सच मिलेगा यदि यह वैध JSON है।

Comments

json_decode('null') == NULLऔर nullएक वैध JSON मान है।

— zzzzBov

मैंने परीक्षण किया है कि क्या 'null' json.parser.online पर वैध जसन है लेकिन ऐसा लगता है कि इसका वैध जौन नहीं है। और json_decode () jp को मान्य करने के लिए php कोर फ़ंक्शन है इसलिए मुझे हमारे आउटपुट में कुछ गलत परिणाम प्राप्त होने का संदेह है।

— मोहम्मद मुर्सलीन

कुछ असत्यापित वेबसाइट पर भरोसा करने के बजाय, कल्पना से परामर्श करने पर विचार करें , जो असहमत है (पृष्ठ 2) । वैकल्पिक रूप से, JSON.parse('null')अपने देव कंसोल में प्रयास करें।

— zzzzBov

Answer 7

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

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

Comments

यह अनुचित रूप से "अशक्त" के लिए अशक्त लौटेगा (जो मान्य JSON नहीं है, लेकिन अन्यथा json_decode को पूरी तरह "वैध" हो सकता है)। जाओ पता लगाओ।

मुझे लगता है कि यह बोना होगा: json_decode($str)!=null;या अन्यथा फ़ंक्शन को बुलाया जाना चाहिए is_not_json।

— योशी

उस फ़ंक्शन को बेहतर नाम दिया जाएगा "JSON के अलावा कुछ और है"!

— लोन्सोमेडे

@ user166390, json_decode('null')युक्ति के अनुसार वैध JSON है , और का मान वापस करना चाहिए null।

— zzzzBov

कृपया यह भी ध्यान दें कि इस विधि के साथ is_json('false')और is_json('[]')वापस आ जाएगा falseक्योंकि प्रकार की जाँच नहीं की गई है। मुझे लगता है कि इस विधि को बल्कि लौटना चाहिए $str === null || json_decode($str) !== null।

— एंटोनी पिंसार्ड

Answer 8

आपको यह सुनिश्चित करने के लिए अपने इनपुट को मान्य करना होगा कि आपके द्वारा पास किया गया स्ट्रिंग खाली नहीं है और वास्तव में, एक स्ट्रिंग है। खाली स्ट्रिंग 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;
}

Comments

वास्तविक दुनिया के संदर्भ में समस्या के बारे में सोचने के लिए +1।

— कार्टेफोरहॉर्स

लेकिन '0'वैध जसन नहीं है ... मैं क्यों सावधान होऊंगा? @Kzqai

— upful

Answer 9

यह यह करेगा:

function isJson($string) {
    $decoded = json_decode($string); // decode our JSON string
    if ( !is_object($decoded) && !is_array($decoded) ) {
        /*
        If our string doesn't produce an object or array
        it's invalid, so we should return false
        */
        return false;
    }
    /*
    If the following line resolves to true, then there was
    no error and our JSON is valid, so we return true.
    Otherwise it isn't, so we return false.
    */
    return (json_last_error() == JSON_ERROR_NONE);
}

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

जैसा कि अन्य उत्तरों में दिखाया गया है, json_last_error()हमारे पिछले json_decode () से कोई भी त्रुटि देता है। हालांकि कुछ किनारे उपयोग के मामले हैं जहां यह कार्य अकेले व्यापक नहीं है। उदाहरण के लिए, यदि आप json_decode()एक पूर्णांक (जैसे:) 123, या बिना रिक्त स्थान या अन्य वर्णों (जैसे:) के साथ संख्याओं की एक स्ट्रिंग है "123", तो json_last_error()फ़ंक्शन एक त्रुटि नहीं पकड़ेगा।

इससे निपटने के लिए, मैंने एक अतिरिक्त कदम जोड़ा है जो सुनिश्चित करता है कि हमारा परिणाम json_decode()एक वस्तु या एक सरणी है। यदि यह नहीं है, तो हम वापस लौटते हैं false।

इस क्रिया को देखने के लिए, इन दो उदाहरणों की जाँच करें:

• के साथ ही जाँच करें json_last_error()
• पहले वस्तु / सरणी के लिए जाँच की जा रही है

Comments

"hello"एक वैध JSON है, और यह कोई वस्तु नहीं है और न ही कोई सरणी, json_last_error()पर्याप्त है

— JoniJnm

json_last_error()स्ट्रिंग 4होने पर त्रुटि कोड देता है । यहाँ उदाहरण: 3v4l.org/lSsEojson_decode()"hello"

— लुईस डोनोवन

आपका कोड गलत है, helloएक मान्य JSON नहीं है, लेकिन "hello"है 3v4l.org/OEJrQ

— JoniJnm

Answer 10

आसान तरीका है json result को चेक करने का ।।

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

Answer 11

में 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;
}

Answer 12

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

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

Comments

अच्छा समाधान। टाइपिंग मुद्दे को बहुत अच्छी तरह से संभालता है!

— Chaoix

Answer 13

//Tested thoroughly, Should do the job:
public static function is_json(string $json):bool
{
    json_decode($json);
    if (json_last_error() === JSON_ERROR_NONE) {
        return true;
    }
    return false;
}

Answer 14

एक और सरल तरीका

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

Comments

यह सही नहीं है। किसी भी PHP प्रकार को JSON में एन्कोड किया जा सकता है जैसे ऑब्जेक्ट, स्ट्रिंग्स, आदि और json_decode फ़ंक्शन उन्हें वापस करने की अपेक्षा करता है। यह केवल तभी सच है जब आप हमेशा सरणियों को डिकोड कर रहे हैं और कोई अन्य चर प्रकार नहीं है।

— चाओिक्स

@ कैओइक्स का उपयोग json_decode($str,true)ऑब्जेक्ट को सरणियों में परिवर्तित करता है, इसलिए यह is_array चेक पास करेगा। आप तार, पूर्णांक, आदि के बारे में सही करते हैं।

— पॉल फिलिप्स

मुझे लगता है कि json_encode पर दूसरे पैरामीटर के बारे में आपका क्या मतलब है। मुझे अभी भी लगता है कि @ अहद अली का समाधान टाइपिंग के मामले में बहुत बेहतर है और केवल एक बार आपके एल्गोरिदम में एक json_decode कर रहा है।

— चाओइक

Answer 15

हमें यह जांचने की आवश्यकता है कि क्या पारित स्ट्रिंग संख्यात्मक नहीं है क्योंकि इस मामले में 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;
}

Answer 16

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

$isJson = json_decode($myJSON);

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

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

संपादित करें: यदि आप जानते हैं कि इनपुट क्या होगा, तो आप इस कोड को अपनी आवश्यकताओं के अनुसार अनुकूलित कर सकते हैं। मेरे मामले में मुझे पता है कि मेरे पास "{" द्वारा शुरू होने वाला एक Json है, इसलिए मुझे यह देखने की ज़रूरत नहीं है कि क्या यह एक सरणी है।

Comments

आपका JSON संभवतः केवल एक सरणी हो सकता है, जिस स्थिति में यह stdClass $ foo = "[1, 1, 2, 3]" के बजाय एक सरणी होगा; var_dump (json_decode ($ foo)); => सरणी (4) {[0] => int (1) [1] => int (1) [2] => int (2) [3] => int (3)}

— मिशा नसलेदोव

Answer 17

निम्न वर्ग के साथ PHPBench का उपयोग करते हुए, निम्न परिणाम प्राप्त हुए:

<?php

declare(strict_types=1);

/**
 * Benchmark doctrine persistent collection count method vs sizeof toArray
 * Revs is the number of times you want the benchmark to run
 * @Revs(1000)
 * @Iterations(100)
 */
class BenchmarkJson
{
    public function benchCatchValid(): bool
    {
        $validJson = '{"validJson":true}';
        try {
            json_decode($validJson, true, 512, JSON_THROW_ON_ERROR);
            return true;
        } catch(\JsonException $exception) {}
        return false;
    }

    public function benchCatchInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        try {
            json_decode($invalidJson, true, 512, JSON_THROW_ON_ERROR);
            return true;
        } catch(\JsonException $exception) {}
        return false;
    }

    public function benchLastErrorValid(): bool
    {
        $validJson = '{"validJson":true}';
        json_decode($validJson, true);
        return (json_last_error() === JSON_ERROR_NONE);
    }

    public function benchLastErrorInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        json_decode($invalidJson, true);
        return (json_last_error() === JSON_ERROR_NONE);
    }

    public function benchNullValid(): bool
    {
        $validJson = '{"validJson":true}';
        return (json_decode($validJson, true) !== null);
    }

    public function benchNullInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        return (json_decode($invalidJson, true) !== null);
    }
}

6 subjects, 600 iterations, 6,000 revs, 0 rejects, 0 failures, 0 warnings
(best [mean mode] worst) = 0.714 [1.203 1.175] 1.073 (μs)
⅀T: 721.504μs μSD/r 0.089μs μRSD/r: 7.270%
suite: 1343ab9a3590de6065bc0bc6eeb344c9f6eba642, date: 2020-01-21, stime: 12:50:14
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+
| benchmark     | subject               | set | revs | its | mem_peak   | best    | mean    | mode    | worst   | stdev   | rstdev | diff  |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+
| BenchmarkJson | benchCatchValid       | 0   | 1000 | 100 | 2,980,168b | 0.954μs | 1.032μs | 1.016μs | 1.428μs | 0.062μs | 6.04%  | 1.33x |
| BenchmarkJson | benchCatchInvalid     | 0   | 1000 | 100 | 2,980,184b | 2.033μs | 2.228μs | 2.166μs | 3.001μs | 0.168μs | 7.55%  | 2.88x |
| BenchmarkJson | benchLastErrorValid   | 0   | 1000 | 100 | 2,980,184b | 1.076μs | 1.195μs | 1.169μs | 1.616μs | 0.083μs | 6.97%  | 1.54x |
| BenchmarkJson | benchLastErrorInvalid | 0   | 1000 | 100 | 2,980,184b | 0.785μs | 0.861μs | 0.863μs | 1.132μs | 0.056μs | 6.54%  | 1.11x |
| BenchmarkJson | benchNullValid        | 0   | 1000 | 100 | 2,980,168b | 0.985μs | 1.124μs | 1.077μs | 1.731μs | 0.114μs | 10.15% | 1.45x |
| BenchmarkJson | benchNullInvalid      | 0   | 1000 | 100 | 2,980,184b | 0.714μs | 0.775μs | 0.759μs | 1.073μs | 0.049μs | 6.36%  | 1.00x |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+

निष्कर्ष: यह जांचने का सबसे तेज़ तरीका है कि क्या json वैध है या नहीं json_decode($json, true) !== null)।

Comments

बहुत अच्छा :) मैं आपकी प्रशंसा करता हूं

— महदी

Answer 18

मुझे यह सवाल कल अपने काम में कुछ इसी तरह आने के बाद मिला। अंत में मेरा समाधान ऊपर दिए गए कुछ दृष्टिकोणों का एक संकर था:

function is_JSON($string) {

  $String_Is_JSON = (is_null(json_decode($string, TRUE))) ? FALSE : TRUE;

  return $String_Is_JSON;
}

Answer 19

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

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

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

बस मेरे tuppence के लायक देने की कोशिश कर रहा है।

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

Answer 20

कुछ इस तरह होना चाहिए:

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

अध्याय परीक्षा

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

Comments

मुझे पसंद है कि आप जाँच कर रहे हैं कि क्या यह एक तार है। ErrorExceptionयदि स्ट्रिंग या ऑब्जेक्ट है, तो बचने के लिए पहले समाधान के साथ संयोजन में अच्छी तरह से चला जाता है ।

— सेकेज

Answer 21

निम्नलिखित के बारे में इस उत्तर पर विस्तार :

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

Comments

यदि उस चेक में त्रुटि पाई जाती है तो समय बचाने के लिए डिकोड निष्पादित करने से पहले सबरिंग चेक नहीं किया जाना चाहिए? मुझे लगता है कि 4 सबस्ट्रिंग चेक एक json_d timecode की तुलना में तेज़ होंगे, लेकिन अगर कोई मुझे इस धारणा के साथ वापस कर सकता है तो मैं इस पर किसी भी विचार की सराहना करूंगा।

— मार्क

यह एक तर्क है। मुझे इसमें शामिल प्रसंस्करण समय का पता नहीं है, लेकिन अगर यह तेज़ है तो हाँ।

— सेवनवार्ता

Answer 22

हाय यहाँ मेरी लाइब्रेरी से थोड़ा स्निपेट है, इस पहली शर्त में मैं बस जाँच कर रहा हूँ कि डेटा जौन है तो इसे वापस लौटाएँ अगर सही ढंग से डिकोड किया गया है, तो कृपया प्रदर्शन के लिए रूट उपयोग पर ध्यान दें (मैंने अभी तक कोई जसन फ़ाइल नहीं देखी है भीख नहीं {या [द्वारा

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

Comments

इस प्रश्न के लिए 34 उत्तर पोस्ट किए गए हैं, जिनमें से कई यह भी मानते हैं कि गलती से JSON को किसी सरणी या ऑब्जेक्ट का प्रतिनिधित्व करना है। क्या यह उत्तर अन्य 3 दर्जन उत्तरों से अलग है?

— miken32 15

Answer 23

मेरी ओर से एक और सुझाव :)

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

Answer 24

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

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

Answer 25

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)

Answer 26

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

Comments

@ डिबगिंग के लिए उपयोग (एक त्रुटि को छिपाते हुए) लेकिन इसकी बिल्कुल सिफारिश नहीं की गई

— aswzen

Answer 27

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

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

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;

}

Answer 28

सबसे तेज़ तरीका करने के लिए हो सकता है एक PHP वस्तु / सरणी के लिए एक संभव 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;
}

Answer 29

यहाँ एक प्रदर्शन और सरल कार्य है जो मैंने बनाया है (जो json_decodeबड़े स्ट्रिंग के लिए उपयोग करने से पहले बुनियादी स्ट्रिंग सत्यापन का उपयोग करता है ):

function isJson($string) {
    $response = false;

    if (
        is_string($string) &&
        ($string = trim($string)) &&
        ($stringLength = strlen($string)) &&
        (
            (
                stripos($string, '{') === 0 &&
                (stripos($string, '}', -1) + 1) === $stringLength
            ) ||
            (
                stripos($string, '[{') === 0 &&
                (stripos($string, '}]', -1) + 2) === $stringLength
            )
        ) &&
        ($decodedString = json_decode($string, true)) &&
        is_array($decodedString)
    ) {
        $response = true;
    }

    return $response;
}