SunshinePHP Developer Conference 2015

json_decode

(PHP 5 >= 5.2.0, PECL json >= 1.2.0)

json_decodeConvertește într-o variabilă un șir reprezentat JSON

Descrierea

mixed json_decode ( string $json [, bool $assoc = false [, int $depth = 512 [, int $options = 0 ]]] )

Preia un șir de caractere reprezentat JSON și îl convertește într-o variabilă PHP.

Parametri

json

Șirul (string) reprezentat json care trebuie convertit.

Această funcție operează doar cu șiruri codificate în UTF-8.

Notă:

PHP implementează in superset al JSON - el de asemenea va codifica și va decodifica tipuri scalare și NULL. Standardul JSON susține astfel de valori doar când ele sunt încorporate într-un tablou sau obiect.

assoc

Dacă specificați TRUE, obiectul va fi convertit într-un array asociativ.

depth

Limita adâncimii de imbricare specificată de utilizator.

options

Masca de biți a opțiunilor de decodificare JSON. în prezent este susținută doar JSON_BIGINT_AS_STRING (în mod implicit numerele întregi mari se transformă în numere cu virgulă flotantă)

Valorile întoarse

Întoarce valoarea codificată în json cu tipul PHP corespunzător. Valorile true, false și null sunt întoarse ca TRUE, FALSE și NULL respectiv. NULL este întors dacă parametrul json nu poate fi decodificat sau dacă datele pentru codificare sunt mai adânci decât limita de imbricare.

Exemple

Example #1 Exemple json_decode()

<?php
$json 
'{"a":1,"b":2,"c":3,"d":4,"e":5}';

var_dump(json_decode($json));
var_dump(json_decode($jsontrue));

?>

Exemplul de mai sus va afișa:

object(stdClass)#1 (5) {
    ["a"] => int(1)
    ["b"] => int(2)
    ["c"] => int(3)
    ["d"] => int(4)
    ["e"] => int(5)
}

array(5) {
    ["a"] => int(1)
    ["b"] => int(2)
    ["c"] => int(3)
    ["d"] => int(4)
    ["e"] => int(5)
}

Example #2 Accesarea proprietăților nevalide ale unui obiect

Accesarea elementelor dintr-un obiect, care conțin caractere nepermise conform convenției de denumiri PHP (de ex. liniuța), poate fi realizată prin încapsularea denumirii elementului între paranteze figurate și apostrofuri.

<?php

$json 
'{"foo-bar": 12345}';

$obj json_decode($json);
print 
$obj->{'foo-bar'}; // 12345

?>

Example #3 Greșeli tipice la utilizarea json_decode()

<?php

// următoarele șiruri sunt valide în JavaScript, dar nu sunt valide în JSON

// denumirea și valoarea trebuie să fie cuprinse între ghilimele duble
// ghilimelele singulare nu sunt valide
$bad_json "{ 'bar': 'baz' }";
json_decode($bad_json); // null

// denumirea trebuie să fie cuprinsă între ghilimele duble
$bad_json '{ bar: "baz" }';
json_decode($bad_json); // null

// virgule în plus la sfârșit nu sunt permise
$bad_json '{ bar: "baz", }';
json_decode($bad_json); // null

?>

Example #4 Erori la parametrul depth

<?php
// Codificarea datelor.
$json json_encode(
    array(
        
=> array(
            
'English' => array(
                
'One',
                
'January'
            
),
            
'French' => array(
                
'Une',
                
'Janvier'
            
)
        )
    )
);

// Definirea erorilor.
$constants get_defined_constants(true);
$json_errors = array();
foreach (
$constants["json"] as $name => $value) {
    if (!
strncmp($name"JSON_ERROR_"11)) {
        
$json_errors[$value] = $name;
    }
}

// Arată erorile pentru diferite adâncimi.
foreach (range(43, -1) as $depth) {
    
var_dump(json_decode($jsontrue$depth));
    echo 
'Last error: '$json_errors[json_last_error()], PHP_EOLPHP_EOL;
}
?>

Exemplul de mai sus va afișa:

array(1) {
  [1]=>
  array(2) {
    ["English"]=>
    array(2) {
      [0]=>
      string(3) "One"
      [1]=>
      string(7) "January"
    }
    ["French"]=>
    array(2) {
      [0]=>
      string(3) "Une"
      [1]=>
      string(7) "Janvier"
    }
  }
}
Last error: JSON_ERROR_NONE

NULL
Last error: JSON_ERROR_DEPTH

Example #5 json_decode() cu numere întregi mari

<?php
$json 
'{"number": 12345678901234567890}';

var_dump(json_decode($json));
var_dump(json_decode($jsonfalse512JSON_BIGINT_AS_STRING));

?>

Exemplul de mai sus va afișa:

object(stdClass)#1 (1) {
  ["number"]=>
  float(1.2345678901235E+19)
}
object(stdClass)#1 (1) {
  ["number"]=>
  string(20) "12345678901234567890"
}

Note

Notă:

Specificația JSON nu este JavaScript, ci un subset al JavaScript.

Notă:

În cazul decodificării cu eșec funcția json_last_error() poate fi utilizată pentru a determina natura exactă a erorii.

Istoria schimbărilor

Versiunea Descriere
5.6.0 Variantele cuvintelor-cheie true, false și null care nu sunt scrise în întregime cu litere minuscule nu mai sunt acceptate ca date de intrare valide și vor genera avertismente.
5.4.0 A fost adăugat parametrul options.
5.3.0 A fost adăugat parametrul opțional depth. Limita de imbricare implicită a fost mărită de la 128 la 512.
5.2.3 Limita de imbricare a fost mărită de la 20 la 128.
5.2.1 A fost adăugată susținerea decodificării JSON a tipurilor de bază.

Vedeți de asemenea

add a note add a note

User Contributed Notes 24 notes

up
68
jrevillini
6 years ago
When decoding strings from the database, make sure the input was encoded with the correct charset when it was input to the database.

I was using a form to create records in the DB which had a content field that was valid JSON, but it included curly apostrophes.  If the page with the form did not have

<meta http-equiv="Content-Type" content="text/html;charset=utf-8">

in the head, then the data was sent to the database with the wrong encoding.  Then, when json_decode tried to convert the string to an object, it failed every time.
up
59
Aaron Kardell
5 years ago
Make sure you pass in utf8 content, or json_decode may error out and just return a null value.  For a particular web service I was using, I had to do the following:

<?php
$contents
= file_get_contents($url);
$contents = utf8_encode($contents);
$results = json_decode($contents);
?>

Hope this helps!
up
2
gabriel dot bondaz at gmail dot com
7 months ago
Get a mistery case:

if I try to json_decode this string: "[0-9]{5}", i get this results:

<?php
var_dump
(json_decode("[0-9],{5}",));
?>

array(1) { [0] => int(0) }

But I expected to get an error, cause this is not a valid JSON !
up
22
Matt Browne
1 year ago
The function by 1franck to allow comments works except if there is a comment at the very beginning of the file. Here's a modified version (only the regex was changed) that accounts for that.

<?php
function json_clean_decode($json, $assoc = false, $depth = 512, $options = 0) {
   
// search and remove comments like /* */ and //
   
$json = preg_replace("#(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|([\s\t]//.*)|(^//.*)#", '', $json);
   
    if(
version_compare(phpversion(), '5.4.0', '>=')) {
       
$json = json_decode($json, $assoc, $depth, $options);
    }
    elseif(
version_compare(phpversion(), '5.3.0', '>=')) {
       
$json = json_decode($json, $assoc, $depth);
    }
    else {
       
$json = json_decode($json, $assoc);
    }

    return
$json;
}
?>
up
17
christian dot knoop at gmx dot net
1 year ago
If you store your json-string in an utf8-file and read it with file_get_contents, please make sure to strip leading BOM (byte order mark) before decoding it with json_decode. Otherwise json_decode will fail creating an associative array. Instead it will return your data as a string.
up
25
1franck
1 year ago
Sometime, i need to allow comments in json file. So i wrote a small func to clean comments in a json string before decoding it:
<?php
/**
* Clean comments of json content and decode it with json_decode().
* Work like the original php json_decode() function with the same params
*
* @param   string  $json    The json string being decoded
* @param   bool    $assoc   When TRUE, returned objects will be converted into associative arrays.
* @param   integer $depth   User specified recursion depth. (>=5.3)
* @param   integer $options Bitmask of JSON decode options. (>=5.4)
* @return  string
*/
function json_clean_decode($json, $assoc = false, $depth = 512, $options = 0) {

   
// search and remove comments like /* */ and //
   
$json = preg_replace("#(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|([\s\t](//).*)#", '', $json);

    if(
version_compare(phpversion(), '5.4.0', '>=')) {
       
$json = json_decode($json, $assoc, $depth, $options);
    }
    elseif(
version_compare(phpversion(), '5.3.0', '>=')) {
       
$json = json_decode($json, $assoc, $depth);
    }
    else {
       
$json = json_decode($json, $assoc);
    }

    return
$json;
}
?>
up
29
T erkif
4 years ago
it seems, that some of the people are not aware, that if you are using json_decode to decode a string it HAS to be a propper json string:

<?php
var_dump
(json_encode('Hello'));

var_dump(json_decode('Hello'));  // wrong
var_dump(json_decode("Hello")); // wrong
var_dump(json_decode('"Hello"')); // correct
var_dump(json_decode("'Hello'")); // wrong

result:

string(7) ""Hello""
NULL
NULL
string
(5) "Hello"
NULL
up
28
php at hm2k.org
4 years ago
If var_dump produces NULL, you may be experiencing JSONP aka JSON with padding, here's a quick fix...

<?php

//remove padding
$body=preg_replace('/.+?({.+}).+/','$1',$body);

// now, process the JSON string
$result = json_decode($body);

var_dump($result);
?>
up
22
premiersullivan at gmail dot com
5 years ago
This function will remove trailing commas and encode in utf8, which might solve many people's problems. Someone might want to expand it to also change single quotes to double quotes, and fix other kinds of json breakage.

<?php
   
function mjson_decode($json)
    {
        return
json_decode(removeTrailingCommas(utf8_encode($json)));
    }
   
    function
removeTrailingCommas($json)
    {
       
$json=preg_replace('/,\s*([\]}])/m', '$1', $json);
        return
$json;
    }
?>
up
21
colin.mollenhour.com
4 years ago
For those of you wanting json_decode to be a little more lenient (more like Javascript), here is a wrapper:

<?php
function json_decode_nice($json, $assoc = FALSE){
   
$json = str_replace(array("\n","\r"),"",$json);
   
$json = preg_replace('/([{,]+)(\s*)([^"]+?)\s*:/','$1"$3":',$json);
    return
json_decode($json,$assoc);
}
?>

Some examples of accepted syntax:

<?php
$json
= '{a:{b:"c",d:["e","f",0]}}';
$json =
'{
   a : {
      b : "c",
      "d.e.f": "g"
   }
}'
;
?>

If your content needs to have newlines, do this:

<?php
$string
= "This
Text
Has
Newlines"
;
$json = '{withnewlines:'.json_encode($string).'}';
?>

Note: This does not fix trailing commas or single quotes.

[EDIT BY danbrown AT php DOT net: Contains a bugfix provided by (sskaje AT gmail DOT com) on 05-DEC-2012 with the following note.]

Old regexp failed when json like
{aaa:[{a:1},{a:2}]}
up
13
php_net_01_weber at nachvorne de
1 year ago
json_decode_nice + keep linebreaks:

function json_decode_nice($json, $assoc = TRUE){
    $json = str_replace(array("\n","\r"),"\\n",$json);
    $json = preg_replace('/([{,]+)(\s*)([^"]+?)\s*:/','$1"$3":',$json);
    $json = preg_replace('/(,)\s*}$/','}',$json);
    return json_decode($json,$assoc);
}

by phpdoc at badassawesome dot com, I just changed line 2.
If you want to keep the linebreaks just escape the slash.
up
1
nsardo
6 months ago
Just a quick note, as I got caught with this:

The json that is input into json_decode MUST be well formed, such that key's are QUOTED.  I wasted time debugging, a$$suming that the following would be fine:

[{id:2, name:"Bob",phone:"555-123-4567"}]

It returned null, basically.  I had to QUOTE the keys:

[{"id":2, "name":"Bob", "phone":"555-123-4567"}]

THEN, everything worked as it should.
up
13
phpdoc at badassawesome dot com
1 year ago
I added a 3rd regex to the json_decode_nice function by "colin.mollenhour.com" to handle a trailing comma in json definition.

<?php
// http://www.php.net/manual/en/function.json-decode.php#95782
function json_decode_nice($json, $assoc = FALSE){
   
$json = str_replace(array("\n","\r"),"",$json);
   
$json = preg_replace('/([{,]+)(\s*)([^"]+?)\s*:/','$1"$3":',$json);
   
$json = preg_replace('/(,)\s*}$/','}',$json);
    return
json_decode($json,$assoc);
}
?>

Example:

<?php
$dat_json
= <<<EOF
{
    "foo"    : "bam",
    "bar"    : "baz",
}
EOF;
$dat_array = json_decode_nice( $dat_json );
var_dump ( $dat_json, $dat_array );

/* RESULTS:

string(35) "{
    "foo"    : "bam",
    "bar"    : "baz",
}"
array(2) {
  ["foo"]=>
  string(3) "bam"
  ["bar"]=>
  string(3) "baz"
}
*/
?>
up
17
skypppher at gmail dot com
1 year ago
First of all, since JSON is not native PHP format or even native JavaScript format, everyone who wants to use JSON wisely should carefuly read official documentation. There is a link to it here, in "Introduction" section. Many questions like "it doesn't recognize my strings" and those like previous one (about zip codes) will drop if you will be attentive!

And second. I've found that there is no good, real working example of how to validate string if it is a JSON or not.
There are two ways to make this: parse input string for yourself using regular expressions or anything else, use json_decode to do it for you.
Parsing for yourself is like writing your own compiler, too difficult.
Just testing result of json_decode is not enough because you should test it with NULL, but valid JSON could be like this 'null' and it will evaluate to NULL. So you should use another function - json_last_error. It will return error code of the last encode/decode operation. If no error occured it will be JSON_ERROR_NONE. So here is the function you should use for testing:
<?php
function isValidJson($strJson) {
   
json_decode($strJson);
    return (
json_last_error() === JSON_ERROR_NONE);
}
?>
It's so simple, that there is no need to use it and slow down your script with extra delay for function call. Just do it manualy in you code while working with input data:
<?php
//here is my initial string
$sJson = $_POST['json'];
//try to decode it
$json = json_decode($sJson);
if (
json_last_error() === JSON_ERROR_NONE) {
   
//do something with $json. It's ready to use
} else {
   
//yep, it's not JSON. Log error or alert someone or do nothing
}
?>
up
17
Gravis
5 years ago
with two lines you can convert your string from JavaScript toSource() (see http://www.w3schools.com/jsref/jsref_toSource.asp) output format to JSON accepted format.  this works with subobjects too!
note: toSource() is part of JavaScript 1.3 but only implemented in Mozilla based javascript engines (not Opera/IE/Safari/Chrome).

<?php
  $str
= '({strvar:"string", number:40, boolvar:true, subobject:{substrvar:"sub string", subsubobj:{deep:"deeply nested"}, strnum:"56"}, false_val:false, false_str:"false"})'; // example javascript object toSource() output

 
$str = substr($str, 1, strlen($str) - 2); // remove outer ( and )
 
$str = preg_replace("/([a-zA-Z0-9_]+?):/" , "\"$1\":", $str); // fix variable names

 
$output = json_decode($str, true);
 
var_dump($output);
?>

var_dump output:
array(6) {
  ["strvar"]=>
  string(6) "string"
  ["number"]=>
  int(40)
  ["boolvar"]=>
  bool(true)
  ["subobject"]=>
  array(3) {
    ["substrvar"]=>
    string(10) "sub string"
    ["subsubobj"]=>
    array(1) {
      ["deep"]=>
      string(13) "deeply nested"
    }
    ["strnum"]=>
    string(2) "56"
  }
  ["false_val"]=>
  bool(false)
  ["false_str"]=>
  string(5) "false"
}

hope this saves someone some time.
up
16
majca J
4 years ago
Noted in a comment below is that this function will return NULL when given a simple string.

This is new behavior - see the result in PHP 5.2.4 :
php > var_dump(json_decode('this is a simple string'));
string(23) "this is a simple string"

in PHP 5.3.2 :
php > var_dump(json_decode('this is a simple string'));
NULL

I had several functions that relied on checking the value of a purported JSON string if it didn't decode into an object/array. If you do too, be sure to be aware of this when upgrading to PHP 5.3.
up
14
nix
4 years ago
Be aware, when decoding JSON strings, where an empty string is a key, this library replaces the empty string with "_empty_".

So the following code gives an unexpected result:
<?php
var_dump
(json_decode('{"":"arbitrary"}'));
?>

The result is as follows:
object(stdClass)#1 (1) {
  ["_empty_"]=>
  string(6) "arbitrary"
}

Any subsequent key named "_empty_" (or "" [the empty string] again) will overwrite the value.
up
1
kuroi dot neko at wanadoo dot fr
10 months ago
My initial problem was to have PHP check a form in case JavaScript was disabled on the client.
I fiddled with json_decode for a while before realizing what I really wanted: to be able to initialize the same object in PHP and JavaScript from a common source file.

I ended up writing a tiny parser for a JavaScript object initializer, which is close to - but not the same thing as - a piece of JSON.
Among other things, it
- recognizes regexes (turning them into PHP strings),
- handles C/C++ comments
- accepts non-quoted field names.

This parser will accept a superset of real JS object initializer syntax (for instance non-quoted string litterals or improperly formed regexes). Error report and sanity checks are close to non-existent.
The whole idea is to share the code among JavaScript and PHP, so the syntactical checks are left to the JS interpreter.

Here is the code for those who are interrested :

-----------------------------
class JSvarDecoderCtx {
    public function __construct ($type)
    {
        $this->fields = ($type == '[') ? array() : new stdClass();
    }
   
    public function add_name (&$text)
    {
        $this->name = $text;
        $text = '';
    }
    public function add_value (&$text)
    {
        // weird input like a mix of fields and array elements will cause warnings here
        if (!isset ($this->name)) $this->fields[             ] = $text;
        else                      $this->fields->{$this->name} = $text;
        $text = '';
    }
}

define ('JSVAL_TEXT'  , 12001);
define ('JSVAL_STRING', 12002);
define ('JSVAL_REGEXP', 12003);
define ('JSVAL_COMMT1', 12004);
define ('JSVAL_COMMT2', 12005);

function jsinit_decode ($json)
{
    // parse a JS initializer
    $stack = array ();
    $text = "";
    $state = JSVAL_TEXT;
    $len = strlen($json);
    for ($i = 0 ; $i != $len; $i++)
    {
        $c = $json[$i];
        switch ($state)
        {
        case JSVAL_TEXT:
            switch ($c)
            {
            case '{' :
            case '[' : array_unshift ($stack, new JSvarDecoderCtx ($c)); break;
            case '}' :
            case ']' : $stack[0]->add_value ($text); $text = array_shift ($stack)->fields; break;
            case ':' : $stack[0]->add_name  ($text); break;
            case ',' : $stack[0]->add_value ($text); break;
            case '"' :
            case "'" : $closer = $c; $state = JSVAL_STRING; break;
            case '/' :
                assert($i != ($len-1));
                switch ($json[$i+1])
                {
                case '/': $state = JSVAL_COMMT1; break;
                case '*': $state = JSVAL_COMMT2; break;
                default : $state = JSVAL_REGEXP; $text .= $c;
                }
                break;
            case "\r":
            case "\n":
            case "\t":
            case ' ' : break;
            default  : $text .= $c;
            }
            break;
        case JSVAL_STRING: if  ($c != $closer)               $text .= $c; else $state = JSVAL_TEXT; break;
        case JSVAL_REGEXP: if (($c !=  ',') && ($c !=  '}')) $text .= $c; else { $i--; $state = JSVAL_TEXT; } break;
        case JSVAL_COMMT1: if (($c == "\r") || ($c == "\n")) $state = JSVAL_TEXT; break;
        case JSVAL_COMMT2:
            if ($c != '*') break;
            assert($i != ($len-1));
            if ($json[$i+1] == '/') { $i++; $state = JSVAL_TEXT; }
        }
    }
    assert ($state == JSVAL_TEXT);
    return $text;
}
-----------------------------
Test pattern :
{
     errors: "form-errors",   // CSS class for validation errors tooltip    
    i: /* integer   */ /^[0-9]+$/,
    err: {
      '*': "mandatory field",
      i: "must be an integer",
    },
    a:['ga','bu','zo','meuh'] // http://www.archimedes-lab.org/shadoks/shadoiku.html
}
-----------------------------
result :

stdClass Object
(
     [errors] => form-errors
     [i] => /^[0-9]+$/
     [err] => stdClass Object
        (
            [*] => mandatory field
            [i] => must be an integer
        )
    [a] => Array
        (
            [0] => ga
            [1] => bu
            [2] => zo
            [3] => meuh
        )
)
up
8
alexvonweiss at googlemail dot com
3 years ago
Consider that JSON can differ between int and string. So

<?php
var_dump
(json_decode('{"foo": 12}'));
// array(1) { ["foo"]=> int(12) }

var_dump(json_decode('{"foo": "12"}'));
// array(1) { ["foo"]=> string(12) }
?>

Numbers that cannot be handled by integer seems to become float casted. This can be a problem if you transfer big numbers like facebook ids over JSON. Either you avoid numbers by cast everything to string before JSON.stringify or you have to use number_format if the value bacome a float value.

<?php
// test
$x = json_decode('{"foo": 123456789012345}');
echo
sprintf('%1$f', $x->foo).PHP_EOL;
echo
sprintf('%1$u', $x->foo).PHP_EOL;
echo
sprintf('%1$s', $x->foo).PHP_EOL;
echo
strval($x->foo).PHP_EOL;
echo (string)
$x->foo.PHP_EOL;
echo
number_format($x->foo, 0, '', '').PHP_EOL;

// output
123456789012345.000000  // printf %f
2249056121              // printf %u
1.2345678901234E+14     // printf %s
1.2345678901234E+14     // strval()
1.2345678901234E+14     // cast (string)
2249056121              // cast (int)
123456789012345         // number_format()
?>
up
6
steven at acko dot net
6 years ago
json_decode()'s handling of invalid JSON is very flaky, and it is very hard to reliably determine if the decoding succeeded or not. Observe the following examples, none of which contain valid JSON:

The following each returns NULL, as you might expect:

<?php
var_dump
(json_decode('['));             // unmatched bracket
var_dump(json_decode('{'));             // unmatched brace
var_dump(json_decode('{}}'));           // unmatched brace
var_dump(json_decode('{error error}')); // invalid object key/value
notation
var_dump
(json_decode('["\"]'));         // unclosed string
var_dump(json_decode('[" \x "]'));      // invalid escape code

Yet the following each returns the literal string you passed to it:

var_dump(json_decode(' [')); // unmatched bracket
var_dump(json_decode(' {')); // unmatched brace
var_dump(json_decode(' {}}')); // unmatched brace
var_dump(json_decode(' {error error}')); // invalid object key/value notation
var_dump(json_decode('"\"')); // unclosed string
var_dump(json_decode('" \x "')); // invalid escape code
?>

(this is on PHP 5.2.6)

Reported as a bug, but oddly enough, it was closed as not a bug.

[NOTE BY danbrown AT php DOT net: This was later re-evaluated and it was determined that an issue did in fact exist, and was patched by members of the Development Team.  See http://bugs.php.net/bug.php?id=45989 for details.]
up
-6
nospam (AT) hjcms (DOT) de
7 years ago
You can't transport Objects or serialize Classes, json_* replace it bei stdClass!
<?php

$dom
= new DomDocument( '1.0', 'utf-8' );
$body = $dom->appendChild( $dom->createElement( "body" ) );
$body->appendChild( $dom->createElement( "forward", "Hallo" ) );

$JSON_STRING = json_encode(
   array(
     
"aArray" => range( "a", "z" ),
     
"bArray" => range( 1, 50 ),
     
"cArray" => range( 1, 50, 5 ),
     
"String" => "Value",
     
"stdClass" => $dom,
     
"XML" => $dom->saveXML()
   )
);

unset(
$dom );

$Search = "XML";
$MyStdClass = json_decode( $JSON_STRING );
// var_dump( "<pre>" , $MyStdClass , "</pre>" );

try {

   throw new
Exception( "$Search isn't a Instance of 'stdClass' Class by json_decode()." );

   if (
$MyStdClass->$Search instanceof $MyStdClass )
     
var_dump( "<pre>instanceof:" , $MyStdClass->$Search , "</pre>" );

} catch(
Exception $ErrorHandle ) {

   echo
$ErrorHandle->getMessage();

   if (
property_exists( $MyStdClass, $Search ) ) {
     
$dom = new DomDocument( "1.0", "utf-8" );
     
$dom->loadXML( $MyStdClass->$Search );
     
$body = $dom->getElementsByTagName( "body" )->item(0);
     
$body->appendChild( $dom->createElement( "rewind", "Nice" ) );
     
var_dump( htmlentities( $dom->saveXML(), ENT_QUOTES, 'utf-8' ) );
   }
}

?>
up
-10
hellolwq at gmail dot com
1 year ago
json_decode can not handle string like:\u0014,it will return null,and with the error
<?php json_last_error()=JSON_ERROR_CTRL_CHAR ?>
according ascii_class from json module, use the next codes to fix the bug:
<?php
$str
= preg_replace_callback('/([\x{0000}-\x{0008}]|[\x{000b}-\x{000c}]|[\x{000E}-\x{001F}])/u', function($sub_match){return '\u00' . dechex(ord($sub_match[1]));},$str);
var_dump(json_decode($str));
?>
up
-11
hellolwq at gmail dot com
1 year ago
json_decode can not handle string like:\u0014,it will return null,and with the error
<?php json_last_error()=JSON_ERROR_CTRL_CHAR ?>
according ascii_class from json module, use the next codes to fix the bug:
<?php
$str
= preg_replace_callback('/([\x{0000}-\x{0008}]|[\x{000b}-\x{000c}]|[\x{000E}-\x{001F}])/u', function($sub_match){return '\u00' . dechex(ord($sub_match[1]));},$str);
var_dump(json_decode($str));
?>
up
-34
evengard at trioptimum dot com
3 years ago
There is a problem when passing to json_decode a string with the "\" symbol. It seems to identify it as an escape character and trying to follow it. So sometimes it leads to failed parsing.

It seems that just replacing it with "\\" helps.
<?php
print_r
(json_decode(str_replace('\\', '\\\\', '{"name":"/\"}')));
?>
where /\ is the string which doesn't worked.
To Top