archived-doc-tr/language/types/array.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 8859c8b96cd9e80652813f7bcf561432a5e9f934 Maintainer: nilgun Status: ready -->
<sect1 xml:id="language.types.array">
 <title>array</title>

 <para>
  PHP'de bir dizi aslında sıralı bir eşlemdir. Bir eşlem, değerleri
  anahtarlarla ilişkilendiren bir veri türüdür. Bu veri türü farklı kullanım
  amaçları için en iyilenebilir; bir dizi, bir yöneysel liste, bir isim-değer
  çiftleri tablosu, bir sözlük, bir nesne listesi, yığıt, kuyruk ve daha bir
  sürü başka şey olarak ele alınabilir. Dizilerin değerleri, ağaçlar, diziler
  ve hatta çok boyutlu diziler bile olabilir.
 </para>

 <para>
  Tüm bu veri yapılarının açıklanması bu kılavuzun amacını aşar. Fakat, en
  azından her biri için birer örnek verilebilir. Bu konuda daha fazla bilgi
  edinmek için bu konuyla ilgili olarak yayımlanmış eserleri inceleyiniz.
 </para>

 <sect2 xml:id="language.types.array.syntax">
  <title>Sözdizimi</title>

  <sect3 xml:id="language.types.array.syntax.array-func">
   <title>Bir dizinin <function>array</function> ile belirtilmesi</title>

   <para>
    Bir dizi <function>array</function> işlevi kullanılarak belirtilebilir.
    Bağımsız değişken olarak, birbirlerinden virgüllerle ayrılmış çok sayıda
    <literal><replaceable>anahtar</replaceable> =&gt;
    <replaceable>değer</replaceable></literal> çifti alabilir.
   </para>

   <synopsis>
array(
    <optional><replaceable>anahtar</replaceable>  =&gt; </optional><replaceable>değer</replaceable>,
    <optional><replaceable>anahtar2</replaceable> =&gt; </optional><replaceable>değer2</replaceable>,
    <optional><replaceable>anahtar3</replaceable> =&gt; </optional><replaceable>değer3</replaceable>,
    ...
)</synopsis>
   <!-- Do not fix the whitespace for the synopsis end element. A limitation of PhD prevents proper trimming -->

   <para>
    Son dizi elemanından sonraki virgül seçimliktir ve konmayabilir.
    Bu genellikle tek satırlık dizilerde yapılır. Yani,
    <literal>array(1, 2, )</literal> yerine
    <literal>array(1, 2)</literal> yazmak tercih edilir. Diğer taraftan,
    çok satırlı dizilerde yeni elemanların sona eklenmesini
    kolaylaştırdığından sondaki virgülün konulması tercih edilir.
   </para>

   <note>
    <para>
     <literal>array()</literal> yerine <literal>[]</literal> kullanılan
     kısa bir dizi sözdizimi de vardır.
    </para>
   </note>

   <example>
    <title>- Basit bir dizi</title>
    <programlisting role="php">
<![CDATA[
<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
);

// Kısa dizi sözdizimi kullanımı
$array = [
    "foo" => "bar",
    "bar" => "foo",
];
?>
]]>
    </programlisting>
   </example>

   <para xml:id="language.types.array.key-casts">
    Bir <replaceable>anahtar</replaceable> ya <type>int</type>  ya da
    <type>string</type> türünde olabilir. Bir <replaceable>değer</replaceable>
    ise herhangi bir türde olabilir.
   </para>

   <para>
    Ek olarak <replaceable>anahtar</replaceable> için şu tür çarpıtmaları oluşur:
    <itemizedlist>
     <listitem>
      <simpara>
       Geçerli onluk tamsayı içeren bir <type>string</type> <literal>+</literal>
       imi ile başlamadıkça <type>int</type> türüne çarpıtılır. Yani,
       <literal>"8"</literal> anahtarı aslında <literal>8</literal> olarak
       saklanır. Diğer yandan, <literal>"08"</literal> geçerli bir onluk
       tamsayı olmadığından tür çarpıtmasına uğramaz.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       <type>Float</type> türler ondalık kısmı kırpılarak <type>int</type>
       türüne çarpıtılır. Yani, <literal>8.7</literal> anahtarı aslında
       <literal>8</literal> olarak saklanır.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       <type>Bool</type> türler <type>int</type> türüne çarpıtılır. Yani
       &true; anahtarı <literal>1</literal>,
       &false; anahtarı da <literal>0</literal> olarak saklanır.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       <type>Null</type> türler boş dizeye çarpıtılır.
       Yani <literal>null</literal> aslında <literal>""</literal> olarak saklanır.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       <type>Array</type> ve <type>object</type> türler anahtar olarak
       kullanıla<emphasis>MAZ</emphasis>. Bunu yapmak <literal>Illegal offset
       type</literal> uyarısına sebep olur.
      </simpara>
     </listitem>
    </itemizedlist>
   </para>

   <para>
    Dizi bildiriminde çok sayıda eleman aynı anahtarı kullanıyorsa, diğerleri
    birbirlerinin üzerine yazıyormuşçasına sadece son eleman kullanılır.
   </para>

   <example>
    <title>- Tür Çarpıtma ve Üzerine Yazma örneği</title>
    <programlisting role="php">
<![CDATA[
<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);
var_dump($array);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
array(1) {
  [1]=>
  string(1) "d"
}
]]>
    </screen>
     <para>
      Yukarıdaki örnekte tüm anahtarlar <literal>1</literal>'e çarpıtıldığından
      her yeni eleman değeri bir öncekinin üzerie yazılır ve dizide sadece son
      atanan değer kalır.
     </para>
   </example>

   <para>
    PHP indisli ve ilişkisel diziler arasında bir ayrım yapmadığından
    <type>int</type> ve <type>string</type> türündeki anahtarlar aynı anda
    bulunabilir.
   </para>

   <example>
    <title>- Karışık <type>int</type> ve <type>string</type> anahtarlar</title>
    <programlisting role="php">
<![CDATA[
<?php
dizi = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var_dump($dizi);
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}
]]>
    </screen>
   </example>

   <para>
    <replaceable>anahtar</replaceable> belirtmek isteğe bağlıdır. Bir anahtar
    belirtmeksizin bir değer atanıyorsa bu değer, mevcut <type>int</type>
    anahtarların en büyüğüne bir eklenerek elde edilen <type>int</type>
    anahtarlı elemana atanır.
   </para>

   <example>
    <title>- Anahtarsız indisli diziler</title>
    <programlisting role="php">
<![CDATA[
<?php
$dizi = array("foo", "bar", "hello", "world");
var_dump($dizi);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}
]]>
    </screen>
   </example>

   <para>
    Bazı değerlere anahtar belirtirken bazılarına belirtmemek mümkündür.
   </para>

   <example>
    <title>- Tüm elemanlar için birer anahtar belirtilmeyebilir</title>
    <programlisting role="php">
<![CDATA[
<?php
$dizi = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($dizi);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}
]]>
    </screen>
    <para>
     Gördüğünüz gibi son değer <literal>"d"</literal>, <literal>7</literal>
     anahtarına atanmıştı. Bunun sebebi önceki en büyük tamsayılı indisin
     <literal>6</literal> olmasıdır.
    </para>
   </example>

   <example>
    <title>- Karmaşık Tür Çarpıtma ve Geçersizleştirme örneği</title>
    <para>
     Bu örnekte anahtarlar üzerinde tür çarpıtmanın ve öğelerin üzerine
     yazılmasının tüm çeşitleri gösterilmiştir.
    </para>
    <programlisting role="php">
<![CDATA[
<?php
$array = array(
    1    => 'a',
    '1'  => 'b', // "a" değeri "b" ile geçersiz olur
    1.5  => 'c', // "b" değeri "c" ile geçersiz olur
    -1 => 'd',
    '01'  => 'e', // tamsayı dizesi olmadığından korunur
    '1.5' => 'f', // tamsayı dizesi olmadığından korunur
    true => 'g',  // "c" değeri "g" ile geçersiz olur
    false => 'h',
    '' => 'i',
    null => 'j',  // "i" değeri "j" ile geçersiz olur
    'k',   // 2 anahtarına "k" değeri atanır, çünkü önceki en büyük tamsayı: 1
    2 => 'l',     // "k" değeri "l" ile geçersiz olur
);

var_dump($array);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}
]]>
    </screen>
   </example>
  </sect3>

  <sect3 xml:id="language.types.array.syntax.accessing">
   <title>Köşeli ayraç sözdizimi ile belirtilen dizilere erişim</title>

   <para>
    Dizi elemanlarına  <literal>array[anahtar]</literal> sözdizimi
    kullanılarak erişilir.
   </para>

   <example>
    <title>- Dizi elemenlarına erişim</title>
    <programlisting role="php">
<![CDATA[
<?php
$dizi = array(
    "foo" => "bar",
    42    => 24,
    "çok" => array(
         "boyutlu" => array(
             "dizi" => "foo"
         )
    )
);

var_dump($dizi["foo"]);
var_dump($dizi[42]);
var_dump($dizi["çok"]["boyutlu"]["dizi"]);
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
string(3) "bar"
int(24)
string(3) "foo"
]]>
    </screen>
   </example>

   <note>
    <para>
     PHP 8.0.0 öncesinde, dizilere erişmek için köşeli ayraçların yerine kaşlı
     ayraçlar da kullanılabilirdi (yani, yukarıdaki örnekte
     <literal>$dizi[42]</literal>  ve <literal>$dizi{42}</literal> aynı şeyi
     yapar). Dizilere erişirken köşeli ayraçların yerine kaşlı ayraç kullanımı
     PHP 7.4.0 itibariyle önerilmemekte olup PHP 8.0.0 ve sonrasında
     desteklenmemektedir.
    </para>
   </note>

   <example>
    <title>- Dizi başvurusu</title>
    <programlisting role="php">
<![CDATA[
<?php
function getArray() {
    return array(1, 2, 3);
}

$ikinciEleman = getArray()[1];
?>
]]>
    </programlisting>
   </example>
   <note>
    <para>
     Atanmamış bir dizi elemanına erişme çabası, atanmamış bir değişkene erişme
     çabasıyla aynı sonucu verir:
     <constant>E_WARNING</constant> seviyesinde
     (PHP 8.0.0 öncesinde <constant>E_NOTICE</constant> seviyesinde) bir
     hata çıktılanır ve sonuç &null; olur.
    </para>
   </note>
   <note>
    <para>
     <type>string</type> türünde olmayan bir sayıl değeri başka bir diziye atama
     işlemi sessiz bir &null; atamasıyla sonuçlanır.
     PHP 7.4.0 öncesinde, bir hata iletisi çıktılanmazdı.
     PHP 7.4.0 ve sonrasında, bir <constant>E_NOTICE</constant> çıktılanırken,
     PHP 8.0.0 ve sonrasında, bir <constant>E_WARNING</constant> çıktılanır.
    </para>
   </note>

  </sect3>

  <sect3 xml:id="language.types.array.syntax.modifying">
   <title>Köşeli ayraçlarla atama ve değişiklik yapmak</title>

   <para>
    Mevcut bir dizi, doğrudan değer atamak suretiyle değiştirilebilir.
   </para>

   <para>
    Bu işlem, diziye köşeli ayraçlar arasında belirtilen bir anahtar
    kullanılarak değer atamak biçeminde yapılır. Diziye yeni bir değer atamak
    için köşeli ayraçlar boş olarak (<literal>[]</literal>) belirtilebilir.
   </para>

   <synopsis>
$dizi[<replaceable>anahtar</replaceable>] = <replaceable>değer</replaceable>;
$dizi[] = <replaceable>değer</replaceable>;

// <replaceable>anahtar</replaceable> sadece <type>int</type> veya <type>string</type> türünde olabilir.
// <replaceable>değer</replaceable> herhangi bir türde olabilir.</synopsis>

   <para>
    <varname>$dizi</varname> mevcut değilse, değer olarak &null; veya &false;
    atanmışsa dizi oluşturulur. Yani bu işlem yeni bir dizi oluşturmak için
    kullanılabilir. Ancak bunun yapılması önerilmez. Çünkü
    <varname>$dizi</varname> bir dize değer içeriyor olabileceğinden bu
    değer yerinde kalır ve <literal>[]</literal> aslında bir
    <link linkend="language.types.string.substr">dize erişim işleci</link>
    haline gelir. Bir değişkeni doğrudan atamayla ilkendirmek daha iyidir.
   </para>
   <note>
    <simpara>
     PHP 7.1.0 ve sonrasında, boş indis işlecini bir dizeye uygulamak ölümcül
     hataya sebep olur. Evvelce, dize sessizce bir diziye dönüştürülürdü.
    </simpara>
   </note>

   <note>
    <simpara>
     PHP 8.1.0 itibariyle, &false; değerden yeni bir dizi oluşturulması
     önerilmemektedir. &null; ve tanımsız değerlerden yeni bir dizi
     oluşturulması ise hala mümkündür.
    </simpara>
   </note>

   <para>
    Anahtar kullanarak bir elemana yeni bir değer atamak bu elemanın değerinin
    değiştirilmesi demektir. Belli bir anahtar/değer çiftini silmek için
    <function>unset</function> işlevini kullanın.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$dizi = array(5 => 1, 12 => 2);

$dizi[] = 56;    // Betiğin bu noktasında bu atama
                 // $dizi[13] = 56; ile aynıdır

$dizi["x"] = 42; // "x" anahtarlı yeni bir eleman atar

unset($dizi[5]); // Elemanı diziden siler

unset($dizi);    // Dizinin tamamını siler
?>
]]>
    </programlisting>
   </informalexample>

   <note>
    <para>
     Yukarıda değinildiği gibi, bir diziye yeni değeri bir anahtar
     belirtmeden atamak, mevcut en büyük <type>int</type> indisine bir
     eklenerek elde edilen anahtar (en azından <literal>0</literal> değil)
     kullanılarak gerçekleşir. Dizide henüz bir <type>int</type> indis
     yoksa anahtar olarak <literal>0</literal> (sıfır) kullanılır.
    </para>

    <para>
     Dikkat ederseniz, dizinin mevcut olması halinde, yeni bir değer atamak
     için en büyük tamsayı indisli anahtar kullanmaya gerek yoktur. Buna
     sadece dizi yeniden indislenmişse gerek olabilir. Aşağıdaki örnek
     anlatımı pekiştirecektir:
    </para>

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
// Basit bir dizi oluşturalım.
$dizi = array(1, 2, 3, 4, 5);
print_r($dizi);

// Şimdi bütün elemanları silelim ama dizi kalsın:
foreach ($dizi as $i => $value) {
    unset($dizi[$i]);
}
print_r($dizi);

// Bir eleman ekleyelim (dikkat: yeni anahtar 0 değil 5 olacak!)
$dizi[] = 6;
print_r($dizi);

// Yeniden indisleyelim:
$dizi = array_values($dizi);
$dizi[] = 7;
print_r($dizi);
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)
]]>
     </screen>
    </informalexample>
   </note>
  </sect3>

  <sect3 xml:id="language.types.array.syntax.destructuring">
   <title>Dizilerin Yeniden Yapılandırılması</title>

   <para>
    Diziler, <literal>[]</literal> (PHP 7.1.0 ve sonrası) veya
    <function>list</function> dil yapıları kullanılarak yeniden
    yapılandırılabilir. Bu dil yapıları bir dizinin içindeki farklı
    değişkenleri yeniden yapılandırmakta da kullanılabilir.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$source_array = ['foo', 'bar', 'baz'];

[$foo, $bar, $baz] = $source_array;

echo $foo;    // "foo" basar
echo $bar;    // "bar" basar
echo $baz;    // "baz" basar
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Dizilerin yeniden yapılandırmasında çok boyutlu bir dizi,  &foreach;
    kullanılarak yinelemeli olarak yeniden yapılandırılabilir.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$source_array = [
    [1, 'John'],
    [2, 'Jane'],
];

foreach ($source_array as [$id, $name]) {
    // $id ve $name ile ilgili yinelemeler
}
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Bir değişken sağlanmamış dizi elemanları yok sayılır. Yeniden
    yapılandırma daima <literal>0</literal>. indisten başlar.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$source_array = ['foo', 'bar', 'baz'];

// 2. indisteki elemana $baz ile atama
[, , $baz] = $source_array;

echo $baz;    // "baz" basar
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    PHP 7.1.0 ve sonrasında, ilişkisel diziler de yeniden
    yapılandırılabilmektedir. Ayrıca, sayısal indisli dizilerde indisler
    doğrudan belirtilebildiğinden doğru elemanın daha kolay belirlenebilmesini
    de sağlar.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];

// 'baz' indisli elemana $üç değişkenini atamak
['baz' => $üç] = $source_array;

echo $üç;    // 3 basar

$source_array = ['foo', 'bar', 'baz'];

// 2. indisteki elemana $baz değişkenini atamak
[2 => $baz] = $source_array;

echo $baz;    // "baz" basar
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Dizi yeniden yapılandırması iki değişkeni kolayca takaslamak için de
    kullanılabilir.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

[$b, $a] = [$a, $b];

echo $a;    // 2 basar
echo $b;    // 1 basar
?>
]]>
    </programlisting>
   </informalexample>

   <note>
    <para>
      Atamalarda çoğaltma işleci (<literal>...</literal>) desteklenmemektedir.
    </para>
   </note>

   <note>
    <para>
      Tanımlanmamış bir dizi anahtarına erişmeye çalışmak, diğer tanımsız
      değişkenlere erişmekle aynıdır:
      <constant>E_WARNING</constant> seviyesinde
      (PHP 8.0.0 öncesinde <constant>E_NOTICE</constant> seviyesinde) bir
      hata çıktılanır ve sonuç &null; olur.
    </para>
   </note>
  </sect3>
 </sect2><!-- end syntax -->

 <sect2 xml:id="language.types.array.useful-funcs">
  <title>Kullanışlı işlevler</title>

  <para>
   Dizilerle çalışmak için kullanılabilecek işlevlerin tamamını <link
   linkend="ref.array">Dizi İşlevleri</link> bölümünde bulabilirsiniz.
  </para>

  <note>
   <para>
    <function>unset</function> işlevi bir diziden anahtar silmeyi mümkün
    kılar. Ama bu silme işlemi dizinin yeniden indislenmesiyle sonuçlanmaz.
    Eğer silme işleminin gerçekten "sil ve kaydır" yapmasını istiyorsanız,
    anahtarı sildikten sonra <function>array_values</function> işlevini
    kullanarak diziyi yeniden indislemelisiniz.
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = array(1 => 'bir', 2 => 'iki', 3 => 'üç');
unset($a[2]);
/* Bu silme işlemi dizi şöyle tanımlanmış gibi sonuçlanacaktır:
   $a = array(1 => 'bir', 3 => 'üç');
   böyle DEĞİL:
   $a = array(1 => 'bir', 2 =>'üç');
*/

$b = array_values($a);
// $b artık array(0 => 'bir', 1 =>'üç') olmuştur
?>
]]>
    </programlisting>
   </informalexample>
  </note>

  <para>
   &foreach; denetim yapısı özellikle diziler için tasarlanmıştır. Diziler
   üzerinde hareket edilmesini kolaylaştırır.
  </para>
 </sect2>

 <sect2 xml:id="language.types.array.donts">
  <title>Diziler ne yapar, ne yapmaz?</title>

  <sect3 xml:id="language.types.array.foo-bar">
   <title><literal>$foo[bar]</literal> niye yanlıştır?</title>

   <para>
    Bir dize sayıllı indis daima tırnak içinde kullanılır. Örneğin,
    <literal>$foo[bar]</literal> yanlışken <literal>$foo['bar']</literal>
    doğrudur. Ama, neden? Eski betiklerde şu sözdizimine sıkça rastlanır:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$foo[bar] = 'düşman';
echo $foo[bar];
// ve saire
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Bu yanlıştır, ama çalışır. Bunun sebebi, bu kodun bir dizeden ziyade
    tanımsız bir sabit (<literal>bar</literal>) belirtiyor olmasıdır. PHP
    ilerde şans eseri ismi aynı zamanda değeri olan bir sabit tanımlayabilir.
    PHP otomatik olarak bir <emphasis>çıplak dize</emphasis>yi (tırnak
    içine alınmamış bir dizeyi), bu çıplak dizeyi içeren bir dizeye
    dönüştüreceğinden bu çalışır. Örneğin, <literal>bar</literal> isminde
    tanımlanmış bir sabit yoksa, PHP <literal>bar</literal> sabitine
    <literal>'bar'</literal> dizesini yerleştirecek ve bunu kullanacaktır.
   </para>
   <warning>
    <simpara>
     Son çare olarak, tanımlanmamış bir sabitin çıplak bir dize olarak işleme
     sokulması <constant>E_NOTICE</constant> seviyesinde bir hata
     çıktılanmasına sebep olur. Bu, PHP 7.2.0'dan itibaren kullanımdan
     kaldırılmış olup <constant>E_WARNING</constant> seviyesinde bir hataya
     sebep olur.  PHP 8.0.0 ve sonrasında, bu durumda, bir
     <classname>Error</classname> istisnası yavrulanmaktadır.
    </simpara>
   </warning>

   <note>
    <simpara>
     Bu, "anahtarlar daima tırnak içine alınır" demek değildir. <link
     linkend="language.constants">sabitleri</link> ve <link
     linkend="language.variables">değişkenleri</link> tek tırnak içine
     almayın, çünkü o zaman yorumlanmazlar.
    </simpara>

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Basit bir dizi:
$dizi = array(1, 2);
$sayaç = count($dizi);
for ($i = 0; $i < $sayaç; $i++) {
    echo "\n$i indisi inceleniyor: \n";
    echo "Kötü: " . $dizi['$i'] . "\n";
    echo "İyi: " . $dizi[$i] . "\n";
    echo "Kötü: {$dizi['$i']}\n";
    echo "İyi: {$dizi[$i]}\n";
}
?>
]]>
     </programlisting>
    </informalexample>
    &example.outputs;
    <screen>
<![CDATA[
0 indisi inceleniyor:

Notice: Undefined index: $i in /dosya/yolu/betik.php on line 10
Kötü:
İyi: 1

Notice: Undefined index: $i in /dosya/yolu/betik.php on line 12
Kötü:
İyi: 1

1 indisi inceleniyor:

Notice: Undefined index: $i in /dosya/yolu/betik.php on line 10
Kötü:
İyi: 2

Notice: Undefined index: $i in /dosya/yolu/betik.php on line 12
Kötü:
İyi: 2
]]>
    </screen>
   </note>

   <para>
    Bu davranışla ilgili diğer örnekler:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
// Tüm hataları görelim
error_reporting(E_ALL);

$dizi = array('meyve' => 'elma', 'sebze' => 'havuç');

// Doğru
print $dizi['meyve'];  // elma
print $dizi['sebze'];  // havuç

// Yanlış. Bu çalışır, fakat meyve tanımlanmamış bir sabit
// olmadığından E_NOTICE seviyesinde bir PHP hatası oluşur
//
// Notice: Use of undefined constant meyve - assumed 'meyve'...
print $dizi[meyve];    // elma

// Bu, neler olup bittiğini gösteren bir sabit tanımlar;
// 'sebze' değeri meyve sabitine atanır.
define('meyve', 'sebze');

// Şimdi farkı görelim
print $dizi['meyve'];  // elma
print $dizi[meyve];    // havuç

// Bir dize içinde olduğundan bu da doğrudur.
// Dizge içinde kalan sabitler, sabit olarak ele alınmazlar;
// dolayısıyla burada bir E_NOTICE oluşmaz.
print "Turfanda $dizi[meyve]";      // Turfanda elma

// Bir istisna: Dizge içinde kaşlı ayraç içine alınmış
// sabitler, sabit olarak ele alınırlar.
print "Turfanda {$dizi[meyve]}";     // Turfanda havuç
print "Turfanda {$dizi['meyve']}";   // Turfanda elma

// Bu çalışmaz ve şöyle bir çözümleme hatasıyla sonuçlanır:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Bu, dizeler içindeki süper küresellere de uygulanır.
print "Turfanda $dizi['meyve']";
print "Turfanda $_GET['foo']";

// Ard arda eklemek de bir seçenektir
print "Turfanda " . $dizi['meyve']; // Turfanda elma
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    <link linkend="ini.error-reporting">error_reporting</link> yönergesine
    <constant>E_NOTICE</constant> seviyesinden hataları gösterecek bir atama
    yapılırsa (örneğin, <constant>E_ALL</constant> atanarak), böyle
    kullanımlar hemen görünür duruma gelir. <link
    linkend="ini.error-reporting">error_reporting</link> yönergesinin
    öntanımlı değeriyle <constant>E_NOTICE</constant> seviyesinden hatalar
    gösterilmez.
   </para>

   <para>
    <link linkend="language.types.array.syntax">Sözdizimi</link> bölümünde
    değinildiği gibi, köşeli ayraçlar ('<literal>[</literal>' ve
    '<literal>]</literal>') içinde belirtilenlerin birer ifade olması
    gerekir. Yani, aşağıdaki gibi bir kod çalışacaktır:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
echo $dizi[birişlev($bar)];
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Bu, bir işlevin dönüş değerinin dizi indisi olarak kullanımına bir
    örnektir. PHP kendi sabitlerini de tanır:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$error_descriptions[E_ERROR]   = "Ölümcül bir hata oluştu";
$error_descriptions[E_WARNING] = "PHP bir uyarı verdi";
$error_descriptions[E_NOTICE]  = "Bu sadece bilgilendirici bir uyarı";
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    <constant>E_ERROR</constant> sabitinin de ilk örnekteki
    <literal>bar</literal> kadar geçerli bir betimleyici oluşuna dikkat
    ediniz. Fakat, <constant>E_ERROR</constant> eşittir <literal>1</literal>,
    vb. olduğundan aşağıdaki örnek de aynı işi yapar:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$error_descriptions[1] = "Ölümcül bir hata oluştu";
$error_descriptions[2] = "PHP bir uyarı verdi";
$error_descriptions[8] = "Bu sadece bilgilendirici bir uyarı";
?>
]]>
    </programlisting>
   </informalexample>

    <!-- do not delete (fixed tag inconsistency!) -->
       <para></para>

   <sect4 xml:id="language.types.array.foo-bar.why">
    <title>O halde bunun nesi kötü?</title>

    <para>
     Bilinmeyen bir gelecekte PHP ekibi başkalarının kodlarıyla çelişen bir
     sabit, bir anahtar sözcük veya bir değişken eklemek isteyebilir.
     Örneğin, <code>empty</code> ve <code>default</code> birer <link
     linkend="reserved">anahtar sözcük</link> olduklarından bu amaçla
     kullanılmaları yanlıştır.
    </para>

    <note>
     <simpara>
      Yinelemek gerekirse, çift tırnak imleri arasına alınmış bir dize, dizi
      indisini tırnak içine almadığından geçerlidir; yani,
      <literal>"$foo[bar]"</literal> geçeridir. Yukarıdaki örnekleri bu gözle
      tekrar inceleyin ve ayrıca  <link
      linkend="language.types.string.parsing">dizelerin içinde değişken
      çözümleme</link> bölümüne de bakın.
     </simpara>
    </note>

   </sect4>
  </sect3>
 </sect2>

 <sect2 xml:id="language.types.array.casting">
  <title>Diziye dönüşüm</title>

  <para>
   <type>int</type>, <type>float</type>, <type>string</type>,
   <type>bool</type> veya <type>resource</type> türünde bir değeri
   <type>array</type> türünde bir değere dönüştürme işlemi, sıfır indisli bir
   elemana bu değerin atanması ile sonuçlanır. Başka bir deyişle,
   <literal>(array) $sayılDeğer</literal> ile
   <literal>array($sayılDeğer)</literal> arasında bir fark yoktur.
  </para>

  <para>
   Bir <type>object</type> türü <type>array</type> türüne dönüştürme işlemi,
   elemanları nesnenin üyeleri olan bir dizi ile sonuçlanır. Anahtarlar, bir
   kaç istisnai durum dışında üyelerin isimleridir: Tamsayı özellikler
   erişilebilir değildir; <literal>private</literal> değişkenlerin önüne sınıf
   isimleri getirilir; <literal>public</literal> değişkenlerin önünde bir
   '*' olur. Diğer taraftan, başlarına birşeyler eklenmiş böyle değişkenlerin
   değerleri &null; olur.
   <link linkend="language.oop5.properties.typed-properties">Veri türüne sahip
   özellikler</link> ilklendirilmemişse sessizce yok sayılır.
  </para>

  <informalexample>
   <programlisting role="php">
    <![CDATA[
<?php

class A {
    private $B;
    protected $C;
    public $D;
    function __construct()
    {
        $this->{1} = null;
    }
}

var_export((array) new A());
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
    <![CDATA[
array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)
]]>
   </screen>
  </informalexample>

  <para>
   Bu durum beklenmedik davranışlara yol açabilir:
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

class A {
    private $A; // Bu '\0A\0A' haline gelir.
}

class B extends A {
    private $A; // Bu '\0B\0A' haline gelir.
    public $AA; // Bu 'AA' haline gelir.
}

var_dump((array) new B());
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
    <![CDATA[
array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}
]]>
   </screen>
  </informalexample>

  <para>
   Bu örneğin çıktısı 'AA' isimli iki anahtar görüntülerse de onlardan
   birinin ismi aslında '\0A\0A''dır.
  </para>

  <para>
   &null;, bir diziye dönüştürülmek istenirse sonuç boş bir dizi olur.
  </para>
 </sect2>

 <sect2 xml:id="language.types.array.comparing">
  <title>Karşılaştırma</title>

  <para>
   Dizileri <function>array_diff</function> işleviyle veya <link
   linkend="language.operators.array">dizi işleçleri</link> kullanılarak
   karşılaştırmak mümkündür.
  </para>
 </sect2>

 <sect2 xml:id="language.types.array.unpacking">
  <title>Dizi genişletme</title>

  <para>
   <code>...</code> ile öncelenmiş bir dizi dizinin tanımlanması sırasında
   bulunduğu yerde genişletilir. Yalnızca
   <interfacename>Traversable</interfacename> arayüzünü gerçekleyen diziler
   genişletilebilir. <code>...</code> ile genişletme PHP 7.4.0 ve sonrasında
   kullanılabilmektedir.
  </para>

  <para>
   Defalarca genişletme yapmak ve <code>...</code> işlecinin önüne ve ardına
   normal elemanları eklemek mümkündür:

   <example>
    <title>- Basit dizi genişletmesi</title>
    <programlisting role="php">
<![CDATA[
<?php
// Kısa dizi sözdizimi kullanarak.
// Ayrıca, array() sözdizimi da çalışır.
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; //[1, 2, 3]
$arr3 = [0, ...$arr1]; //[0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; //[1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; //[1, 2, 3, 1, 2, 3]

function getArr() {
  return ['a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; //['a', 'b', 'c' => 'd']
?>
]]>
    </programlisting>
   </example>
  </para>

  <para>
   <code>...</code> işleci ile bir diziyi genişletme işlemi
   <function>array_merge</function> işlevindeki gibi yapılır. Yani, sonraki
   dizge anahtarlar öncekileri geçersiz kılarken tamsayı anahtarlar yeniden
   sıralanır:

   <example>
    <title>- Yinelenen anahtarlarla dizi genişletme</title>
    <programlisting role="php">
<![CDATA[
<?php
// dizge anahtar
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]

// integer key
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// Burada özgün tamsayı anahtarlar korunmamıştır.
?>
]]>
    </programlisting>
   </example>
  </para>

  <note>
   <para>
    Dizge ya da tamsayı olmayan anahtarlar <classname>TypeError</classname>
    istisnasına yol açar. Böyle anahtarlar sadece
    <interfacename>Traversable</interfacename> nesnesi tarafından
    üretilebilir.
   </para>
  </note>
  <note>
   <para>
    PHP 8.1 öncesinde, dizge anahtarlı bir dizi genişletilmiyordu:
   </para>
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php

$arr1 = [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Ölümcül hata: Dizge anahtarlı diziler genişletilemez: example.php:5

$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5]
?>
]]>
    </programlisting>
   </informalexample>
  </note>

 </sect2>

 <sect2 xml:id="language.types.array.examples">
  <title>Örnekler</title>

  <para>
   PHP'nin <type>array</type> türü çok yeteneklidir. Bazı örnekler:
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Bu:
$a = array( 'renk'   => 'kırmızı',
            'lezzet' => 'tatlı',
            'şekil'  => 'yuvarlak',
            'isim'   => 'elma',
            4        // anahtarı 0 olacaktır
          );

$b = array('a', 'b', 'c');

// . . . buna tamamen eşdeğerdir:
$a = array();
$a['renk']   = 'kırmızı';
$a['lezzet'] = 'tatlı';
$a['şekil']  = 'yuvarlak';
$a['isim']   = 'elma';
$a[]         = 4;        // anahtarı 0 olacaktır

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// Yukarıdaki kod çalıştırıldığında $a, array('renk' => 'kırmızı',
// 'lezzet' => 'tatlı', 'şekil' => 'yuvarlak', 'isim' => 'elma', 0 => 4)
// dizisiyle, $b ise array(0 => 'a', 1 => 'b', 2 => 'c') veya basitçe
// array('a', 'b', 'c') dizisiyle sonuçlanacaktır.
?>
]]>
   </programlisting>
  </informalexample>

  <example>
   <title>- <function>array</function> kullanımı</title>
   <programlisting role="php">
<![CDATA[
<?php
// Özellik eşlemeli dizi
$map = array( 'sürüm'    => 4,
              'sistem'   => 'Linux',
              'dil'      => 'english',
              'kısaltma' => true
            );

// tamamen sayısal anahtarlar
$dizi = array(  7,
                8,
                0,
              156,
              -10
              );
// Bu, array(0 => 7, 1 => 8, ...) ile aynıdır

$geçişli = array(        10, // key = 0
                 5    =>  6,
                 3    =>  7,
                 'a'  =>  4,
                         11, // anahtar = 6 (en büyük tamsayı indis 5 idi)
                 '8'  =>  2, // anahtar = 8 (tamsayı!)
                 '02' => 77, // anahtar = '02'
                 0    => 12  // 10 değerinin üzerine 12 yazılacak
                  );

// boş dizi
$boş = array();
?>
]]>
<!-- TODO example of
- overwriting keys
- using vars/functions as key/values
- warning about references
-->
   </programlisting>
  </example>

  <example xml:id="language.types.array.examples.loop">
   <title>- Döngü içinde elemen değiştirme</title>
   <programlisting role="php">
<![CDATA[
<?php
$renkler = array('Turuncu', 'Pembe', 'Mor', 'Turkuaz');

foreach ($renkler as $renk) {
    echo "$renk rengi sever misiniz?\n";
}

?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Turuncu rengi sever misiniz?
Pembe rengi sever misiniz?
Mor rengi sever misiniz?
Turkuaz rengi sever misiniz?
]]>
   </screen>
  </example>

  <para>
   Dizi değerleri gönderimli aktarıldıklarından dizi
   değerlerini doğrudan değiştirmek mümkündür. Fakat arada bazı şeyler yapmak
   gerekir:
  </para>

  <example xml:id="language.types.array.examples.changeloop">
   <title>- Derlem</title>
   <programlisting role="php">
<![CDATA[
<?php
<?php
$renkler = array('Turuncu', 'Pembe', 'Mor', 'Turkuaz');

foreach ($renkler as &$renk) {
    $renk = mb_strtoupper($renk);
}

unset($renk); /* Aşağıdaki atamalarda $renk son
                 dizi elemanını değiştirmesin */

print_r($renkler);
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Array
(
    [0] => TURUNCU
    [1] => PEMBE
    [2] => MOR
    [3] => TURKUAZ
)

]]>
   </screen>
  </example>

  <para>
   Bu örnekte dizi indisleri 1'den başlatılmaktadır.
  </para>

  <example>
   <title>- İndisi 1'den başlatmak</title>
   <programlisting role="php">
<![CDATA[
<?php
$ilkçeyrek  = array(1 => 'Ocak', 'Şubat', 'Mart');
print_r($ilkçeyrek);
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Array
(
    [1] => Ocak
    [2] => Şubat
    [3] => Mart
)
]]>
   </screen>
  </example>

  <example>
   <title>- Diziyi doldurmak</title>
   <programlisting role="php">
<![CDATA[
<?php
// bir diziyi bir dizin'in içeriği ile dolduralım
$tutamak = opendir('.');
while (false !== ($dosya = readdir($tutamak))) {
    $dosyalar[] = $dosya;
}
closedir($tutamak);
?>
]]>
   </programlisting>
  </example>

  <para>
   Diziler sıralıdır. Sıralama çeşitli sıralama işlevleri ile
   değiştirilebilir. Daha fazla bilgi için <link linkend="ref.array">Dizi
   İşlevleri</link> bölümüne bakınız. Bir dizinin eleman sayısını öğrenmek
   için <function>count</function>işlevi kullanılabilir.
  </para>

  <example>
   <title>- Dizi elemanlarının sıraya sokulması</title>
   <programlisting role="php">
<![CDATA[
<?php
sort($dosyalar);
print_r($dosyalar);
?>
]]>
   </programlisting>
  </example>

  <para>
   Bir dizinin elemanlarına her türlü değer atanabileceğinden başka bir dizi
   de atanabilir. Böylece iç içe ve çok boyutlu dizilerin oluşturulması
   mümkün olur.
  </para>

  <example>
   <title>- İç içe ve çok boyutlu diziler</title>
   <programlisting role="php">
<![CDATA[
<?php
$yemişler = array ( "yemişler"  => array ( "a" => "iğde",
                                           "b" => "badem",
                                           "c" => "ceviz"
                                         ),
                    "sayılar"   => array ( 1,
                                           2,
                                           3,
                                           4,
                                           5,
                                           6
                                         ),
                    "yuvalar"   => array (        "birinci",
                                            5  => "ikinci",
                                                  "üçüncü"
                                          )
                );

// Yukarıdaki dizinin değerlerinin kullanıldığı bazı örnekler
echo $yemişler["yuvalar"][5];    // "ikinci" basar
echo $yemişler["meyveler"]["a"]; // "iğde" basar
unset($yemişler["yuvalar"][0]);  // "birinci" silinir

// Yeni bir çok boyutlu dizi oluşturalım
$meyveler["elma"]["yeşil"] = "ekşi";
?>
]]>
   </programlisting>
  </example>

  <para>
   Dizi atamaları daima değerleri kopyalamak şeklinde gerçekleşir. Bir diziyi
   gönderimli olarak kopyalamak için <link
   linkend="language.operators">gönderim işleci</link> kullanılır.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$dizi1 = array(2, 3);
$dizi2 = $dizi1;
$dizi2[] = 4; // $dizi2 değişti,
              // $dizi1 hala array(2, 3)

$dizi3 = &$dizi1;
$dizi3[] = 4; // şimdi $dizi1 ve $dizi3 aynı
?>
]]>
   </programlisting>
  </informalexample>

 </sect2>
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->