json_decode

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

json_decode — Bir JSON dizgesini çözümler

Açıklama

json_decode(
    string $json,
    ?bool $ilişkisel = null,
    int $derinlik = 512,
    int $seçenekler = 0
): mixed

Kodlanmış bir JSON dizgesini çözümler ve PHP değerine çevirir.

Bağımsız Değişkenler

json

Deşifre edilmiş json dizgesi.

Bu işlev UTF-8 kodlu dizgelerle çalışır.

Bilginize:
PHP, özgün » RFC 7159'da belirtildiği gibi JSON'ın kapsayıcı kümesini gerçekler.

ilişkisel

true olduğu zaman JSON nesneleri bir ilişkisel dizilere dönüştürülür. false belirtilirse JSON nesneleri nesne olarak döndürülür. null olduğu zaman JSON nesneleri seçenekler bağımsız değişkeninde JSON_OBJECT_AS_ARRAY sabiti atanmışsa ilişkisel dizi atanmamışsa nesne olarak döner.

derinlik

Kodlu yapının azami iç içe derinliği. Değer 0'dan büyük, 2147483647'den küçük veya buna eşit olmalıdır.

seçenekler

JSON_BIGINT_AS_STRING, JSON_INVALID_UTF8_IGNORE, JSON_INVALID_UTF8_SUBSTITUTE, JSON_OBJECT_AS_ARRAY, JSON_THROW_ON_ERROR sabitlerinin bit maskesi. Bu sabitlerin davranışı JSON sabitleri sayfasında açıklanmıştır.

Dönen Değerler

json ile şifrelenmiş değerler PHP için uygun veri türlerinde döner. true, false ve null değerle sırasıyla true, false ve null olarak döner. json çözülemediğinde ya da şifreli verinin iç içelik derinliği belirtilenden fazla olduğunda da null döner.

Hatalar/İstisnalar

derinlik izin verilen aralığın dışındaysa, PHP 8.0.0 ve sonrasında bir ValueError yavrulanır. Evvelce, E_WARNING seviyesinde bir hata çıktılanırdı.

Sürüm Bilgisi

Sürüm:	Açıklama
7.3.0	`JSON_THROW_ON_ERROR` seçeneği eklendi.
7.2.0	`associative` is nullable now.
7.2.0	`JSON_INVALID_UTF8_IGNORE` ve `JSON_INVALID_UTF8_SUBSTITUTE` seçeneği eklendi.
7.1.0	`_empty_` değerli bir anahtar kullanmak yerine boş nesne özelliğine boş bir JSON anahtarı ("") kodlanabilir.

Örnekler

Örnek 1 - json_decode() örnekleri

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

var_dump(json_decode($json));
var_dump(json_decode($json, true));

?>

Yukarıdaki örneğin çıktısı:

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

Örnek 2 - Geçersiz nesne özelliklerine erişim

PHP'nin adlandırma kuralı (örneğin, kısa çizgi) kapsamında izin verilmeyen karakterleri içeren bir nesne içindeki öğelere erişim, öğe adının kaşlı ayraçlar ve tek tırnak imleri arasına alınmasıyla gerçekleştirilebilir.

<?php

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

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

?>

Örnek 3 - json_decode() kullanırken yapılan genel bir hata.

<?php

// Aşağıdaki dizgeler JavaScript de geçerli olmasına karşın JSON da geçerli değildir.

// isim ve değerler çift tırnak içine alınmalıdır.
// tek tırnak geçerli değildir.
$bad_json = "{ 'bar': 'baz' }";
json_decode($bad_json); // boş

// isim çift tırnak içine alınmalıdır.
$bad_json = '{ bar: "baz" }';
json_decode($bad_json); // boş

// sonda kalan virgüle izin verilmez
$bad_json = '{ bar: "baz", }';
json_decode($bad_json); // boş

?>

Örnek 4 - depth hataları

<?php
// Veriyi azami derinlik olarak 4 iç içelik ile kodla
// (array -> array -> array -> string).
$json = json_encode(
    array(
        1 => array(
            'English' => array(
                'One',
                'January'
            ),
            'French' => array(
                'Une',
                'Janvier'
            )
        )
    )
);

// Farklı derinlikteki hataları göster
var_dump(json_decode($json, true, 4));
echo 'Son hata: ', json_last_error_msg(), PHP_EOL, PHP_EOL;

var_dump(json_decode($json, true, 3));
echo 'Son hata: ', json_last_error_msg(), PHP_EOL, PHP_EOL;
?>

Yukarıdaki örneğin çıktısı:

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"
    }
  }
}
Son hata: No error

NULL
Son hata: Maximum stack depth exceeded

Örnek 5 - Büyük tamsayılarla json_decode()

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

var_dump(json_decode($json));
var_dump(json_decode($json, false, 512, JSON_BIGINT_AS_STRING));

?>

Yukarıdaki örneğin çıktısı:

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

Notlar

Bilginize:
JSON sınıfı JavaScript değildir, ancak JavaScript'in alt kümesidir.

Bilginize:
Bir hatayı çözmek ve hatanın tam niteliği belirlemek için json_last_error() kullanılabilir.

Ayrıca Bakınız

json_encode() - Değerin JSON karşılığını verir.
json_last_error() - Oluşan son hatayı döndürür.
json_last_error_msg() - Son json_encode() veya json_decode() çağrısının hata dizgesini döndürür

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 4 notes

down

Lennart Hengstmengel ¶

2 years ago

JSON can be decoded to PHP arrays by using the $associative = true option. Be wary that associative arrays in PHP can be a "list" or "object" when converted to/from JSON, depending on the keys (of absence of them). 

You would expect that recoding and re-encoding will always yield the same JSON string, but take this example:

    $json = '{"0": "No", "1": "Yes"}';
    $array = json_decode($json, true);  // decode as associative hash
    print json_encode($array) . PHP_EOL;

This will output a different JSON string than the original:

    ["No","Yes"]

The object has turned into an array!

Similarly, a array that doesn't have consecutive zero based numerical indexes, will be encoded to a JSON object instead of a list.

    $array = [
        'first',
        'second',
        'third',
    ];
    print json_encode($array) . PHP_EOL;
    // remove the second element
    unset($array[1]);
    print json_encode($array) . PHP_EOL;

The output will be:

    ["first","second","third"]
    {"0":"first","2":"third"}

The array has turned into an object! 

In other words, decoding/encoding to/from PHP arrays is not always symmetrical, or might not always return what you expect!

On the other hand, decoding/encoding from/to stdClass objects (the default) is always symmetrical. 

Arrays may be somewhat easier to work with/transform than objects. But especially if you need to decode, and re-encode json, it might be prudent to decode to objects and not arrays. 

If you want to enforce an array to encode to a JSON list (all array keys will be discarded), use:

    json_encode(array_values($array));

If you want to enforce an array to encode to a JSON object, use:

    json_encode((object)$array);

See also: https://www.php.net/manual/en/function.array-is-list.php

down

greaties at ghvernuft dot nl ¶

1 year ago

To load an object with data in json format:
(bugfixed my previous comment)

<?php
function loadJSON($Obj, $json)
{
    $dcod = json_decode($json);
    $prop = get_object_vars ( $dcod );
    foreach($prop as $key => $lock)
    {
        if(property_exists ( $Obj ,  $key ))
        {
            if(is_object($dcod->$key))
            {
                loadJSON($Obj->$key, json_encode($dcod->$key));
            }
            else
            {
                $Obj->$key = $dcod->$key;
            }
        }
    }
    return $Obj;
}
?>

Tested with: 

<?php
class Name
{
  public $first;
  public $last;
  public function fullname()
  {
    return $this->first . " " . $this->last;
  }
}
$json = '{"first":"John","last":"Smith"}';

$infull = loadJSON((new Name), $json);
echo $infull->fullname();

down

cubefox at web dot NOSPAMPLEASE dot de ¶

3 years ago

Warning: As the section "return values" mentions, the return value NULL is ambiguos. To repeat, it can mean three things:

* The input string had the value "null"
* There was an error while parsing the input data
* The encoded data was deeper than the recursion limit

To distinguish these cases, json_last_error() can be used.

down

Alien426 ¶

3 years ago

Browsers don't choke on integers _starting_ with BigInt (64 bits), but before that (53 bits). The introduction of BigInt to modern browsers doesn't help much, when JSON handling functions do not support it. So I am trying to remedy that. My approach is to handle the decoded array before re-encoding it to a string:
<?php
function fix_large_int(&$value)
 {
  if (is_int($value) && $value > 9007199254740991)
    $value = strval($value);
 }
$json_str = '{"id":[1234567890123456789,12345678901234567890]}';
$json_arr = json_decode($json_str, flags: JSON_BIGINT_AS_STRING | JSON_OBJECT_AS_ARRAY);
echo(json_encode($json_arr)); // {"id":[1234567890123456789,"12345678901234567890"]} (BigInt is already converted to a string here)
array_walk_recursive($json_arr, 'fix_large_int');
echo(json_encode($json_arr)); // {"id":["1234567890123456789","12345678901234567890"]}
?>

＋add a note