PHP
JSON

परिचय

वाक्य - विन्यास

• स्ट्रिंग json_encode (मिश्रित $ मूल्य [, इंट $ विकल्प = 0 [, इंट $ गहराई = 512]])
• मिश्रित json_decode (स्ट्रिंग $ json [, बूल $ assoc = false [, int $ गहराई = 512 [, int $ विकल्प = 0]]]]

पैरामीटर

टिप्पणियों

JSON स्ट्रिंग को डिकोड करना

json_decode() फ़ंक्शन अपने पहले पैरामीटर के रूप में JSON-एन्कोडेड स्ट्रिंग लेता है और इसे PHP चर में पार्स करता है।

अगर JSON ऑब्जेक्ट एक सरणी है, json_decode() सामान्य रूप से json_decode() एक वस्तु को \ stdClass लौटाएगा यदि JSON ऑब्जेक्ट में शीर्ष स्तर आइटम एक शब्दकोश या अनुक्रमित सरणी है। यह स्केलर मान या NULL को कुछ स्केलर मानों के लिए भी लौटाएगा, जैसे कि साधारण तार, "true" , "false" और "null" । यह किसी भी त्रुटि पर NULL को लौटाता NULL ।

// Returns an object (The top level item in the JSON string is a JSON dictionary)
$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$object = json_decode($json_string);
printf('Hello %s, You are %s years old.', $object->name, $object->age);
#> Hello Jeff, You are 20 years old.

// Returns an array (The top level item in the JSON string is a JSON array)
$json_string = '["Jeff", 20, true, ["red", "blue"]]';
$array = json_decode($json_string);
printf('Hello %s, You are %s years old.', $array[0], $array[1]);

ऊपर दी गई वस्तु पर प्रत्येक संपत्ति के प्रकार और मूल्यों को देखने के लिए var_dump() का उपयोग करें।

// Dump our above $object to view how it was decoded
var_dump($object);

आउटपुट (चर प्रकार पर ध्यान दें):

class stdClass#2 (4) {
 ["name"] => string(4) "Jeff"
 ["age"] => int(20)
 ["active"] => bool(true)
 ["colors"] =>
   array(2) {
     [0] => string(3) "red"
     [1] => string(4) "blue"
   }
}

नोट: JSON में चर प्रकार उनके PHP समतुल्य में परिवर्तित किए गए थे।

किसी ऑब्जेक्ट को वापस करने के बजाय JSON ऑब्जेक्ट्स के लिए एक साहचर्य सरणी वापस करने के लिए, json_decode() के दूसरे पैरामीटर के रूप में true पास करें।

$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$array = json_decode($json_string, true); // Note the second parameter
var_dump($array);

आउटपुट (सरणी साहचर्य संरचना पर ध्यान दें):

array(4) {
  ["name"] => string(4) "Jeff"
  ["age"] => int(20)
  ["active"] => bool(true)
  ["colors"] =>
  array(2) {
    [0] => string(3) "red"
    [1] => string(4) "blue"
  }
}

दूसरे पैरामीटर ( $assoc ) का कोई प्रभाव नहीं पड़ता है यदि चर को लौटाया जाना एक वस्तु नहीं है।

नोट: यदि आप $assoc पैरामीटर का उपयोग करते हैं, तो आप एक खाली सरणी और एक खाली वस्तु के बीच का अंतर खो देंगे। इसका मतलब यह है कि आपके डिकोड किए गए आउटपुट पर फिर से json_encode() चलने से JSON संरचना अलग हो जाएगी।

यदि JSON स्ट्रिंग में 512 से अधिक तत्वों की एक "गहराई" है ( संस्करणों में 20 तत्व 5.2.3, या संस्करण 5.2.3 में 128 संस्करण में 128 ) पुनरावृत्ति में, फ़ंक्शन json_decode() NULL देता NULL । 5.3 या बाद के संस्करणों में, इस सीमा को तीसरे पैरामीटर ( $depth ) का उपयोग करके नियंत्रित किया जा सकता है, जैसा कि नीचे चर्चा की गई है।

मैनुअल के अनुसार:

PHP मूल »RFC 4627 में निर्दिष्ट JSON का सुपरसेट लागू करता है - यह स्केलर प्रकारों और NULL को भी एनकोड और डिकोड करेगा। RFC 4627 केवल इन मानों का समर्थन करता है जब वे किसी सरणी या ऑब्जेक्ट के अंदर नेस्टेड होते हैं। हालाँकि यह सुपरसेट नए »RFC 7159 (जो RFC 4627 को सुपरसेड करना है) और » ECMA-404 में "JSON टेक्स्ट" की विस्तारित परिभाषा के अनुरूप है, लेकिन इससे पुराने Jars पार्सर्स के साथ इंटरऑपरेबिलिटी समस्या हो सकती है जो RFC 4627 का सख्ती से पालन करते हैं। एकल स्केलर मान एन्कोडिंग।

इसका मतलब है, उदाहरण के लिए, PHP में एक साधारण स्ट्रिंग को एक वैध JSON ऑब्जेक्ट माना जाएगा:

$json = json_decode('"some string"', true);
var_dump($json, json_last_error_msg());

आउटपुट:

string(11) "some string"
string(8) "No error"

लेकिन सरल तार, किसी सरणी या ऑब्जेक्ट में नहीं, RFC 4627 मानक का हिस्सा नहीं हैं। परिणामस्वरूप, JSLint , JSON Formatter & Validator (RFC 4627 मोड में) जैसे ऑनलाइन चेकर्स आपको एक त्रुटि देंगे।

पुनरावृत्ति की गहराई के लिए एक तीसरा $depth पैरामीटर है (डिफ़ॉल्ट मान 512 ), जिसका अर्थ है मूल ऑब्जेक्ट के अंदर नेस्टेड ऑब्जेक्ट की मात्रा को डिकोड किया जाना है।

एक चौथा $options पैरामीटर है। यह वर्तमान में केवल एक मान, JSON_BIGINT_AS_STRING स्वीकार करता है। डिफ़ॉल्ट व्यवहार (जो इस विकल्प को छोड़ देता है) स्ट्रिंग्स के बजाय बड़े पूर्णांक को फ्लोट्स में डालना है।

सही, झूठे और अशक्त शाब्दिक के अमान्य गैर-निचलीकृत वेरिएंट अब मान्य इनपुट के रूप में स्वीकार नहीं किए जाते हैं।

तो यह उदाहरण:

var_dump(json_decode('tRue'), json_last_error_msg());
var_dump(json_decode('tRUe'), json_last_error_msg());
var_dump(json_decode('tRUE'), json_last_error_msg());
var_dump(json_decode('TRUe'), json_last_error_msg());
var_dump(json_decode('TRUE'), json_last_error_msg());
var_dump(json_decode('true'), json_last_error_msg());

PHP 5.6 से पहले:

bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"

और बाद में:

NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
bool(true)
string(8) "No error"

इसी तरह का व्यवहार false और null लिए होता है।

ध्यान दें कि स्ट्रिंग परिवर्तित नहीं किया जा सकता है, तो json_decode() NULL वापस आ जाएगा।

$json = "{'name': 'Jeff', 'age': 20 }" ;  // invalid json 

$person = json_decode($json);
echo $person->name;    //  Notice: Trying to get property of non-object: returns null
echo json_last_error();     
#  4 (JSON_ERROR_SYNTAX)
echo json_last_error_msg(); 
#  unexpected character 

त्रुटियों का पता लगाने के लिए केवल NULL होने वाले रिटर्न मान पर भरोसा करना सुरक्षित नहीं है। उदाहरण के लिए, यदि JSON स्ट्रिंग में "null" कुछ भी नहीं है, json_decode() null हो जाएगी, भले ही कोई त्रुटि हुई हो।

JSON स्ट्रिंग एन्कोडिंग

json_encode फ़ंक्शन एक PHP सरणी (या PHP 5.4 के बाद से, एक ऑब्जेक्ट जो JsonSerializable इंटरफ़ेस को लागू करता है) को JSON-एन्कोडेड स्ट्रिंग में बदल देगा। यह सफलता पर JSON- एन्कोडेड स्ट्रिंग या विफलता पर FALSE देता है।

$array = [
    'name' => 'Jeff',
    'age' => 20,
    'active' => true,
    'colors' => ['red', 'blue'],
    'values' => [0=>'foo', 3=>'bar'],
];

एन्कोडिंग के दौरान, PHP डेटा प्रकार स्ट्रिंग, पूर्णांक और बूलियन को उनके JSON समकक्ष में परिवर्तित किया जाता है। एसोसिएटेड सरणियों को JSON ऑब्जेक्ट्स के रूप में एन्कोड किया जाता है, और - जब डिफ़ॉल्ट तर्क के साथ बुलाया जाता है - अनुक्रमित सरणियों को JSON ऑब्जेक्ट्स के रूप में एन्कोड किया जाता है। (जब तक कि सरणी कुंजियां 0 से शुरू होने वाला एक निरंतर संख्यात्मक अनुक्रम नहीं होती हैं, उस स्थिति में सरणी को JSON ऑब्जेक्ट के रूप में एन्कोड किया जाएगा।)

echo json_encode($array);

आउटपुट:

{"name":"Jeff","age":20,"active":true,"colors":["red","blue"],"values":{"0":"foo","3":"bar"}}

तर्क

PHP 5.3 के बाद से, json_encode का दूसरा तर्क एक बिटमास्क है जो निम्नलिखित में से एक या अधिक हो सकता है।

किसी भी बिटमास्क के साथ, उन्हें बाइनरी या ऑपरेटर के साथ जोड़ा जा सकता है | ।

$array = ['Joel', 23, true, ['red', 'blue']];
echo json_encode($array);
echo json_encode($array, JSON_FORCE_OBJECT);

["Joel",23,true,["red","blue"]]
{"0":"Joel","1":23,"2":true,"3":{"0":"red","1":"blue"}}

$array = ["tag"=>"<>", "amp"=>"&", "apos"=>"'", "quot"=>"\""];
echo json_encode($array);
echo json_encode($array, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT);

{"tag":"<>","amp":"&","apos":"'","quot":"\""}
{"tag":"\u003C\u003E","amp":"\u0026","apos":"\u0027","quot":"\u0022"}

$array = ['23452', 23452];
echo json_encode($array);
echo json_encode($array, JSON_NUMERIC_CHECK);

["23452",23452]    
[23452,23452]

$array = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
echo json_encode($array);
echo json_encode($array, JSON_PRETTY_PRINT);

{"a":1,"b":2,"c":3,"d":4}
{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4
}

$array = ['filename' => 'example.txt', 'path' => '/full/path/to/file/'];
echo json_encode($array);
echo json_encode($array, JSON_UNESCAPED_SLASHES);

{"filename":"example.txt","path":"\/full\/path\/to\/file"}
{"filename":"example.txt","path":"/full/path/to/file"}

$blues = ["english"=>"blue", "norwegian"=>"blå", "german"=>"blau"];
echo json_encode($blues);
echo json_encode($blues, JSON_UNESCAPED_UNICODE);

{"english":"blue","norwegian":"bl\u00e5","german":"blau"}
{"english":"blue","norwegian":"blå","german":"blau"}

$fp = fopen("foo.txt", "r");
$array = ["file"=>$fp, "name"=>"foo.txt"];
echo json_encode($array); // no output
echo json_encode($array, JSON_PARTIAL_OUTPUT_ON_ERROR);

{"file":null,"name":"foo.txt"}

$array = [5.0, 5.5];
echo json_encode($array);
echo json_encode($array, JSON_PRESERVE_ZERO_FRACTION);

[5,5.5]
[5.0,5.5]

$array = ["line"=>"\xe2\x80\xa8", "paragraph"=>"\xe2\x80\xa9"];
echo json_encode($array, JSON_UNESCAPED_UNICODE);
echo json_encode($array, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_LINE_TERMINATORS);

{"line":"\u2028","paragraph":"\u2029"}
{"line":"
","paragraph":"
"}

JSON त्रुटियों को डीबग करना

जब json_encode या json_decode प्रदान की गई स्ट्रिंग को पार्स करने में विफल रहता है, तो यह false हो जाएगा। PHP स्वयं कोई त्रुटि या चेतावनी नहीं देगा जब ऐसा होता है, तो ओनस उपयोगकर्ता पर json_last_error () और json_last_error_msg () फ़ंक्शन का उपयोग करता है यह जांचने के लिए कि क्या कोई त्रुटि हुई और आपके आवेदन के अनुसार कार्य करें (इसे डीबग करें, एक त्रुटि संदेश दिखाएं , आदि।)।

JSON के साथ काम करते समय निम्न उदाहरण एक सामान्य त्रुटि दिखाता है, JSON स्ट्रिंग को डीकोड / एनकोड करने में विफलता (उदाहरण के लिए खराब UTF-8 एन्कोडेड स्ट्रिंग के गुजरने के कारण) ।

// An incorrectly formed JSON string
$jsonString = json_encode("{'Bad JSON':\xB1\x31}");

if (json_last_error() != JSON_ERROR_NONE) {
    printf("JSON Error: %s", json_last_error_msg());
}

#> JSON Error: Malformed UTF-8 characters, possibly incorrectly encoded

json_last_error_msg

json_last_error_msg() एक स्ट्रिंग को एनकोड / डीकोड करने की कोशिश करते समय हुई अंतिम त्रुटि का एक मानव पठनीय संदेश देता है।

• यह फ़ंक्शन हमेशा एक स्ट्रिंग लौटाएगा , भले ही कोई त्रुटि न हुई हो।
  डिफ़ॉल्ट गैर-त्रुटि स्ट्रिंग No Error
• यदि कुछ अन्य (अज्ञात) त्रुटि हुई तो यह false हो जाएगी
• लूप में इसका उपयोग करते समय सावधानी बरतें , क्योंकि प्रत्येक पुनरावृत्ति पर json_last_error_msg को ओवरराइड किया जाएगा।

आपको इस फ़ंक्शन का उपयोग प्रदर्शन के लिए संदेश प्राप्त करने के लिए करना चाहिए, न कि नियंत्रण कथनों में परीक्षण करने के लिए।

// Don't do this:
if (json_last_error_msg()){} // always true (it's a string)
if (json_last_error_msg() != "No Error"){} // Bad practice

// Do this: (test the integer against one of the pre-defined constants)
if (json_last_error() != JSON_ERROR_NONE) {
    // Use json_last_error_msg to display the message only, (not test against it)
    printf("JSON Error: %s", json_last_error_msg());
}

यह फ़ंक्शन PHP 5.5 से पहले मौजूद नहीं है। यहाँ एक पॉलीफ़िल कार्यान्वयन है:

if (!function_exists('json_last_error_msg')) {
    function json_last_error_msg() {
        static $ERRORS = array(
            JSON_ERROR_NONE => 'No error',
            JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
            JSON_ERROR_STATE_MISMATCH => 'State mismatch (invalid or malformed JSON)',
            JSON_ERROR_CTRL_CHAR => 'Control character error, possibly incorrectly encoded',
            JSON_ERROR_SYNTAX => 'Syntax error',
            JSON_ERROR_UTF8 => 'Malformed UTF-8 characters, possibly incorrectly encoded'
        );

        $error = json_last_error();
        return isset($ERRORS[$error]) ? $ERRORS[$error] : 'Unknown error';
    }
}

json_last_error

json_last_error() PHP द्वारा प्रदान किए गए पूर्व-परिभाषित स्थिरांक में से एक में मैप किए गए पूर्णांक देता है।

किसी ऑब्जेक्ट में JsonSerializable का उपयोग करना

class User extends Model implements JsonSerializable {
    public $id;
    public $name;
    public $surname;
    public $username;
    public $password;
    public $email;
    public $date_created;
    public $date_edit;
    public $role;
    public $status;

    public function jsonSerialize() {
        return [
            'name' => $this->name,
            'surname' => $this->surname,
            'username' => $this->username
        ];
    }
}

public function jsonSerialize()

json_encode($User);

{"name":"John", "surname":"Doe", "username" : "TestJson"}

<?php

class User {
    // private properties only within this class
    private $id;
    private $date_created;
    private $date_edit;

    // properties used in extended classes
    protected $password;
    protected $email;
    protected $role;
    protected $status;

    // share these properties with the end user        
    public $name;
    public $surname;
    public $username;

    // jsonSerialize() not needed here
}        

$theUser = new User();

var_dump(json_encode($theUser));

string(44) "{"name":null,"surname":null,"username":null}"

हेडर जसन और लौटी प्रतिक्रिया

JSON के रूप में सामग्री प्रकार के साथ एक हेडर जोड़कर:

<?php
 $result = array('menu1' => 'home', 'menu2' => 'code php', 'menu3' => 'about');

//return the json response :
header('Content-Type: application/json');  // <-- header declaration
echo json_encode($result, true);    // <--- encode
exit();

हेडर वहाँ है तो आपका ऐप यह पता लगा सकता है कि क्या डेटा वापस किया गया था और इसे कैसे संभालना चाहिए।
ध्यान दें: सामग्री शीर्ष लेख केवल लौटाए गए डेटा के प्रकार के बारे में जानकारी है।

यदि आप UTF-8 का उपयोग कर रहे हैं, तो आप उपयोग कर सकते हैं:

header("Content-Type: application/json;charset=utf-8");

उदाहरण jQuery:

$.ajax({
        url:'url_your_page_php_that_return_json'        
    }).done(function(data){
        console.table('json ',data);
        console.log('Menu1 : ', data.menu1);
    });