archived-doc-tr/language/variables.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 5700871f9d037a59d137be318f89deb7e146bbf6 Maintainer: yasar Status: ready -->
 <chapter xml:id="language.variables" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
  <title>Değişkenler</title>

  <sect1 xml:id="language.variables.basics">
   <title>Temeller</title>

   <simpara>
    PHP'de değişkenler dolar işaretini takip eden bir değişken adı ile
    gösterilir. Değişken adı büyük-küçük harf duyarlıdır.
   </simpara>

   <para>
    Değişken isimleri PHP'deki diğer yaftalarla aynı kurallara tabidir.
    Geçerli bir değişken ismi bir harf veya alt çizgi imi ile başlar,
    herhangi sayıda harf, sayı veya alt çizgi iminden oluşur. Düzenli ifade
    olarak, şu şekilde ifade edilebilir:
    <code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>
   </para>

   <note>
    <simpara>
      Burada kastedilen harf a-z veya A-Z arasındaki ASCII harfler ve 128 ile
      255 (<literal>0x80-0xff</literal>) arasındaki baytlardır.
    </simpara>
   </note>

   <note>
    <simpara>
      <literal>$this</literal> atama yapılamayan özel bir değişkendir.
      PHP 7.1.0'dan önce dolaylı atama (örn. <link
      linkend="language.variables.variable">değişken değişkenler</link>
      kullanılarak) mümkündü.
    </simpara>
   </note>

   &tip.userlandnaming;

   <para>
    Değişkenlerle ilgili işlevler hakkında bilgi için,
    <link linkend="ref.var">Değişkenlerle ilgili işlevler</link> belgesine
    bakınız.
   </para>

   <para>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$var = 'Kemal';
$Var = 'gel';
echo "$var, $Var";      // "Kemal, gel" yazdırır

$4site = 'dene bakalım';     // geçersiz; sayı ile başlar
$_4site = 'dene bakalım';    // geçerli; alt çizgi ile başlar
$diğer = 'gerekirse diye';   // geçerli; ISO-8859-9'da 'ğ' harfi 127-255
                             // arasında, UTF-8'de ise iki baytı 127-255
                             // arasındadır.
?>
]]>
     </programlisting>
    </informalexample>
   </para>

   <para>
    Öntanımlı olarak, değişkenler her zaman değerleriyle atanır. Başka bir
    deyişle, bir değişkene bir ifade atandığında özgün ifade bütün değeriyle
    hedef değişkene kopyalanır. Bu demektir ki, örneğin, bir değişkenin
    değerini başka bir değişkene atadıktan sonra, değişkenlerden birisinin
    değerini değiştirmenin diğeri üzerinde etkisi olmayacaktır. Bu çeşit
    atama hakkında daha fazla bilgi için,
    <link linkend="language.expressions">İfadeler</link> bölümüne bakınız.
   </para>
   <para>
    PHP değişkenlere değer atamak için başka bir yol daha sunar: <link
    linkend="language.references">Gönderimli atama</link>. Yani, yeni
    değişken sadece asıl değişkene gönderim yapar  (diğer bir deyişle, "onun
    takma adı olur" veya "onu gösterir") Gönderim yapılan değişkendeki
    değişiklikler aslını da etkiler, tersi de geçerlidir.
   </para>
   <para>
    Gönderimli atama için, gönderim yapılacak (daha önce değer atanmış)
    değişkenin başına ve imi (&amp;) ekleyin. Örneğin, aşağıdaki kod parçası
    iki kez '<literal>Benim adım Mustafa</literal>' yazar:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = 'Mustafa';          // 'Mustafa' değerini $foo değişkenine ata
$bar = &$foo;              // $foo değişkenini $bar değişkenine gönderimli ata
$bar = "Benim adım $bar";  // $bar değişkenini değiştir ...
echo $bar;
echo $foo;                 // $foo değişkeninin değeri de değişti.
?>
]]>
     </programlisting>
    </informalexample>
   </para>

   <para>
    Dikkat edilmesi gereken önemli bir şey de sadece isimli değişkenlerin
    gönderimle atanabileceğidir.
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = 25;
$bar = &$foo;      // Bu geçerli bir atamadır.
$bar = &(24 * 7);  // Geçersiz; isimlendirilmemiş bir ifadeye gönderim yapıyor

function test()
{
   return 25;
}

$bar = &test();    // Geçersiz.
?>
]]>
     </programlisting>
    </informalexample>
   </para>

   <para>
    PHP'de değişkenleri ilklendirmek gerekmez ancak baştan bir değer atamak
    oldukça iyi bir alışkanlıktır. İlklendirilmeyen değişkenlerin
    kullanıldıkları bağlamda türlerine bağlı olarak öntanımlı değerleri
    vardır; öntanımlı değer <type>boolean</type> için &false;,
    <type>integer</type> ve <type>float</type> için sıfır,
    <type>string</type> için boş metin (örnekte <function>echo</function> da
    kullanıldı), <type>array</type> için ise boş bir dizidir.
   </para>
   <para>
    <example>
     <title>- İlklendirilmemiş değişkenlerin öntanımlı değerleri</title>
     <programlisting role="php">
<![CDATA[
<?php
// Herhangi bir bağlamda tanımlanmamış veya
// gönderim yapılmamış değişken;  NULL sonuç verir.
var_dump($tanımsız_değişken);

// Mantıksal değer kullanımı;  'false' çıktısı verir
// (Bu sözdizimi için üç terimli işlecine bakınız)
echo $tanımsız_mantıksallık ? "true\n" : "false\n";

// Dizge kullanımı;  çıktısı: 'string(3) "abc"'
$tanımsız_metin .= 'abc';
var_dump($tanımsız_metin);

// Tamsayı kullanımı;  'int(25)' çıktılar.
$tanımsız_tamsayı += 25;    // 0 + 25 => 25
var_dump($tanımsız_tamsayı);

// Gerçek sayı kullanımı;  'float(1.25)' çıktılar.
$tanımsız_sayı += 1.25;
var_dump($tanımsız_sayı);

// Dizi kullanımı; çıktısı: array(1) {  [3]=>  string(3) "def" }
$tanımsız_dizi[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
var_dump($tanımsız_dizi);

// Nesne kullanımı; yeni stdClass nesnesi oluşturur
// (Öntanımlı sınıflar belgesine bakınız:
// http://www.php.net/manual/tr/reserved.classes.php)
// Çıktısı: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }
$tanımsız_nesne->foo = 'bar';
var_dump($tanımsız_nesne);
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    İlklendirilmemiş bir değişkenin öntanımlı değerine güvenmek, içinde aynı
    değişken isminin kullanıldığı bir dosyayı betiğe dahil ettiğinizde sorun
    çıkarır. İlklendirilmemiş değişken kullanımı
    <constant>E_WARNING</constant> (PHP 8.0.0 öncesinde,
    <constant>E_NOTICE</constant>) seviyesinde hata oluşturur, ancak
    ilklendirilmemiş bir diziye eleman eklenmesi halinde hata oluşmaz.
    <function>isset</function> dil oluşumu bir değişkenin ilklendirilip
    ilklendirilmediğini öğrenmek için
    kullanılabilir.
   </para>
  </sect1>

  <sect1 xml:id="language.variables.predefined">
   <title>Öntanımlı Değişkenler</title>

   <para>
    PHP çalıştırdığı herhangi bir betiğe çok sayıda önceden tanımlı değişken
    sağlar. Ancak, bu değişkenlerin çoğu hangi sunucunun çalıştığına,
    sunucunun sürümüne ve kurulumuna ve başka bir çok şeye bağlı olduğu için
    tam olarak belgelendirilememektedir. Bu değişkenlerden bazıları PHP <link
    linkend="features.commandline">komut satırı</link>ndan çalıştığında
    mevcut olmayacaktır. Ayrıntılar için, <link
    linkend="reserved.variables">öntanımlı değişkenler listesine</link>
    bakınız.
   </para>

   <para>
    PHP, ayrıca, ortam değişkenleri ve kullanıcı girdi
    değişkenleri ile <acronym>HTTP</acronym> sunucusundaki değişkenleri (eğer
    uygulanabiliyorsa) içeren bir takım önceden tanımlı diziler sağlamaktadır.
    Bu diziler özel olmaktan ziyade otomatik olarak küreseldir, yani,
    otomatik olarak her etki alanında bulunurlar. Bu nedenle, "Süper
    küreseller" olarak bilinirler. (PHP'de kullanıcı-tanımlı süper küreseller
    için bir mekanizma yoktur.) Ayrıntılar için bkz, <link
    linkend="language.variables.superglobals">list of süper küresellerin listesi</link>.
   </para>

   <note>
    <title>Değişken değişkenler</title>
    <para>
      İşlevler veya sınıf yöntemleri içinde süper küreseller <link
      linkend="language.variables.variable">değişken değişkenler</link>i
      olarak kullanılamazlar.
    </para>
   </note>

   <para>
    Eğer <link linkend="ini.variables-order">variables_order</link>
    yönergesine uygun değişkenler atanmamışsa, ilgili oldukları PHP önceden
    tanımlı dizileri de boş bırakılır.
   </para>
  </sect1>


  <sect1 xml:id="language.variables.scope">
   <title>Değişken etki alanı</title>

   <simpara>
    Bir değişkenin etki alanı içinde tanımlandığı bağlamdır. Hemen her PHP
    değişkeninin sadece tek bir etki alanı vardır. Bu tek etki alanı betiğe
    <function>include</function> ve <function>require</function> ile dahil
    edilen dosyalara da uzanır. Örneğin:
   </simpara>
   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = 1;
include 'b.inc';
?>
]]>
    </programlisting>
   </informalexample>
   <simpara>
    Burada <varname>$a</varname> değişkeni içerilen
    <filename>b.inc</filename> betiğinin içinde mevcut olacaktır. Fakat,
    kullanıcı tanımlı işlevlerin etki alanı işleve özeldir. Yani, bir işlev
    içinde kullanılan herhangi bir değişkenin etki alanı öntanımlı olarak
    işlevin yerel etki alanı ile sınırlıdır. Örneğin:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = 1; /* küresel etki alanı */

function deneme()
{
    echo $a; /* işlevin etki alanı */
}

deneme();
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Bu betik tanı iletisi olarak <constant>E_WARNING</constant>
    (PHP 8.0.0 öncesinde <constant>E_NOTICE</constant>) üretir.
    <link linkend="ini.display-errors">display_errors</link> INI yönergesi
    tanı iletilerini gizlemek üzere atanırsa bu betik herhangi bir çıktı
    üretmeyecektir, çünkü echo ifadesi <varname>$a</varname> değişkeninin
    yerel sürümüne atıf yapmakta olup bu etki alanı içinde değişkene bir
    değer atanmamıştır. Bunun C dilinden bir miktar farklı olduğuna dikkat
    edilmelidir, C dilinde küresel değişkenler, özellikle yerel bir tanımla
    geçersiz kılınmadıkları sürece, işlevler tarafından otomatik olarak
    erişilebilir olacaktır. Bu bazı sorunlara yol açabilir, öyle ki
    birileri dikkatsizlikle küresel değişkeni değiştirebilir.
    PHP'de küresel değişkenler eğer bir işlev içinde kullanılacaksa,
    o işlev içinde <literal>global</literal> sözcüğü ile
    bildirilmeleri gerekir.
   </simpara>

   <sect2 xml:id="language.variables.scope.global">
    <title><literal>global</literal> anahtar sözcüğü</title>
    <simpara>
      İlk olarak, <literal>global</literal> kullanımına bir örnek verelim:
    </simpara>
    <para>
     <example>
      <title>- <literal>global</literal> kullanımı</title>
      <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

function topla()
{
    global $a, $b;

    $b = $a + $b;
}

topla();
echo $b;
?>
]]>
      </programlisting>
     </example>
    </para>

   <simpara>
    Yukarıdaki betik <literal>3</literal> çıktısı verecektir.
    <varname>$a</varname> ve <varname>$b</varname> işlev içinde küresel
    tanımlanarak, her iki değişkene yapılan bütün atıflar küresel sürüme
    yapılmış olacaktır. Bir işlev tarafından işlenebilecek küresel değişken
    sayısında bir sınır yoktur.
   </simpara>

   <simpara>
    Küresel etki alanındaki değişkenlere erişimin ikinci yolu PHP tarafından
    tanımlanmış özel <varname>$GLOBALS</varname> dizisini kullanmaktır. Önceki
    örnek şu şekilde yazılabilir:
   </simpara>
   <para>
    <example>
     <title>- <literal>global</literal> yerine <varname>$GLOBALS</varname> kullanımı
     </title>
     <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

function topla()
{
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

topla();
echo $b;
?>
]]>
     </programlisting>
    </example>
   </para>

   <simpara>
      <varname>$GLOBALS</varname> dizisi, anahtarı küresel değişkenin ismi,
      elemanının değeri değişkenin içeriği olan bir ilişkisel dizidir.
      <varname>$GLOBALS</varname> dizisinin her etki alanında mevcut oluşuna
      dikkat edin, bunun sebebi<varname>$GLOBALS</varname> dizisinin bir <link
      linkend="language.variables.superglobals">süper küresel</link>
      olmasıdır. Süper küresellerin gücünü gösteren bir örnek aşağıda
      verilmiştir:
   </simpara>
   <para>
    <example>
     <title>- Süper küreselleri ve etki alanlarını gösteren örnek</title>
     <programlisting role="php">
<![CDATA[
<?php
function test_superglobal()
{
    echo $_POST['isim'];
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     Eğer içerildiği dosya bir işlevin içinde içerilmişse
     <literal>global</literal> anahtar sözcüğünün işlevlerin dışında kullanımı
     bir hataya yol açmaz.
    </para>
   </note>
  </sect2>

  <sect2 xml:id="language.variables.scope.static">
   <title>Statik değişkenlerin kullanımı</title>
   <simpara>
    Değişken etki alanı ile ilgili önemli özelliklerden biri statik
    değişkenlerdir. Bir statik bir değişken sadece işlevin etki alanında
    geçerli olup, programın çalışması bu etki alanını terkettiği zaman
    değerini kaybetmez. Aşağıdaki örneğı ele alalım:
   </simpara>
   <para>
    <example>
     <title>- Statik değişkenlere ihtiyacı gösteren örnek</title>
     <programlisting role="php">
<![CDATA[
<?php
function dene()
{
    $a = 0;
    echo $a;
    $a++;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
   Bu işlev her çağrıldığında <varname>$a</varname>'yı <literal>0</literal>
   yapar ve <literal>0</literal> yazdırır, bu nedenle oldukça kullanışsızdır.
   Değişkeni artıran <literal>$a++</literal> bir işe yaramaz çünkü işlev
   çıktığı gibi <varname>$a</varname> değişkeni kaybolur. Kaldığı değeri
   kaybetmeyecek kullanışlı bir sayaç işlevi yapması için
   <varname>$a</varname> değişkeni aşağıda <literal>static</literal> olarak
   bildirilmiştir.
   </simpara>
   <para>
    <example>
     <title>- Statik değişkenlerin kullanım örneği</title>
     <programlisting role="php">
<![CDATA[
<?php
function dene()
{
    static $a = 0;
    echo $a;
    $a++;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    Artık, <varname>$a</varname> değişkeni sadece <literal>dene()</literal> işlevinin ilk çağrılışında ilklendirilecek ve işlevin her çağrılışında
    <varname>$a</varname> değişkeninin değerini bastıktan sonra değerini bir
    artıracaktır.
   </simpara>

   <simpara>
    Statik değişkenler aynı zamanda kendini çağıran işlevlerle çalışmak için
    de bir yol sunar. Kendini çağıran (recursive) işlev kendi kendini
    çağırır. Böyle bir işlev dikkatli yazılmazsa sonsuza kadar kendi kendini
    çağırır. Kendini çağırmayı bir noktada sonlandıracak uygun bir
    yönteminiz olmalıdır. Aşağıdaki basit işlev, kendini çağırmayı nerede
    durduracağını bilerek 10'a kadar sayar:
   </simpara>
   <para>
    <example>
     <title>- Kendini çağıran işlevlerle statik değişkenler</title>
     <programlisting role="php">
<![CDATA[
<?php
function say()
{
    static $sayaç = 0;

    $sayaç++;
    echo "$sayaç\n";
    if ($sayaç < 10) {
        say();
    }
    $sayaç--;
}
say();
?>
]]>
     </programlisting>
    </example>
   </para>

   <para>
    Statik değişkenlere sabit ifadelerin sonucu olan değerler atanabilir, ancak
    işlev çağrıları gibi dinamik ifadeler bir ayrıştırma hatasına sebep olur.
   </para>
   <para>
    <example>
     <title>- Statik değişkenlerin bildirimi</title>
     <programlisting role="php">
<![CDATA[
<?php
function foo(){
    static $int = 0;          // doğru
    static $int = 1+2;        // doğru
    static $int = sqrt(121);  // yanlış (bir işlevle atandığı için)

    $int++;
    echo $int;
}
?>
]]>
     </programlisting>
    </example>
   </para>

   <para>
    PHP 8.1.0 ve sonrasında, statik değişken kullanan bir yöntem miras
    alındığında (geçersiz kılınmamak şartıyla), statik değişkenlerini ebeveyn
    yöntemle paylaşmaktadır. Yani, yöntemlerdeki statik değişkenler artık
    birer statik özellik gibi davranmaktadır.
   </para>

   <example>
    <title>- Miras alınan yöntemlerde statik değişken kullanımı</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo {
    public static function counter() {
        static $counter = 0;
        $counter++;
        return $counter;
    }
}
class Bar extends Foo {}
var_dump(Foo::counter()); // int(1)
var_dump(Foo::counter()); // int(2)
var_dump(Bar::counter()); // int(3), PHP 8.1.0 öncesi int(1)
var_dump(Bar::counter()); // int(4), PHP 8.1.0 öncesi int(2)
?>
]]>
    </programlisting>
   </example>

   <note>
    <para>
     Statik bildirimler derleme sırasında çözümlenir.
    </para>
   </note>
  </sect2>

  <sect2 xml:id="language.variables.scope.references">
   <title><literal>global</literal> ve <literal>static</literal> değişkenlere
   gönderim</title>
   <simpara>
    <link
    linkend="language.variables.scope.static"><literal>static</literal></link> ve
    <link linkend="language.variables.scope.global"><literal>global</literal></link>
    değişken niteleyicileri <link linkend="language.references">gönderim</link>
    olarak gerçeklenmiştir.
    Örneğin, <literal>global</literal> deyimi ile bir işlevin etki alanında
    geçerli kılınan bir küresel değişken aslında kendine bir gönderim
    oluşturur. Bu durum aşağıdaki örnekte de görüldüğü gibi beklenmedik
    davranışlara yol açabilir:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
function gönderimli_küresel_dene() {
    global $nesne;
    $yeni = new stdClass;
    $nesne = &$yeni;
}

function gönderimsiz_küresel_dene() {
    global $nesne;
    $yeni = new stdClass;
    $nesne = $yeni;
}

gönderimli_küresel_dene();
var_dump($nesne);
gönderimsiz_küresel_dene();
var_dump($nesne);
?>
]]>
    </programlisting>
   </informalexample>
   &example.outputs;
   <screen>
<![CDATA[
NULL
object(stdClass)#1 (0) {
}
]]>
   </screen>

   <simpara>
    Aynı davranış <literal>static</literal> deyimine de uyar.
    Gönderimler statik olarak saklanmazlar:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
function &gönderimli_örnek() {
    static $obj;

    echo 'Statik nesne: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Statik değişkene gönderim atayalım
        $obj = &$new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

function &gönderimsiz_örnek() {
    static $obj;

    echo 'Statik nesne: ';
    var_dump($obj);
    if (!isset($obj)) {
        // Statik değişkene nesne atayalım
        $obj = new stdClass;
    }
    $obj->property++;
    return $obj;
}

$nesne1 = gönderimli_örnek();
$bu_da_nesne1 = gönderimli_örnek();
echo "\n";
$nesne2 = gönderimsiz_örnek();
$bu_da_nesne2 = gönderimsiz_örnek();
?>
]]>
    </programlisting>
   </informalexample>
   &example.outputs;
   <screen>
<![CDATA[
Statik nesne: NULL
Statik nesne: NULL

Statik nesne: NULL
Statik nesne: object(stdClass)#3 (1) {
  ["property"]=>
  int(1)
}
]]>
   </screen>

   <simpara>
    Bu örnek, bir statik değişkene gönderimli atama yapılması halinde,
    <literal>&amp;gönderimli_örnek()</literal> işlevi ikinci kez
    çağrıldığında değişkene atanan değerin
    <emphasis>saklanmadığını</emphasis> gösterir.

   </simpara>
   </sect2>
  </sect1>

  <sect1 xml:id="language.variables.variable">
   <title>Değişken değişkenler</title>

   <simpara>
    Bazen değişken değişken isimlerine sahip olabilmek kullanışlı olur.
    Bu, dinamik olarak belirtilebilen ve kullanılabilen bir değişken
    ismidir. Normal bir değişken şöyle bir deyimle atanır:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = 'merhaba';
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Bir değişken değişken bir değişkenin değerini alır ve bir değişkenin
    ismi gibi davranır.  Yukarıdaki örnekteki, <emphasis>merhaba</emphasis>,
    iki tane dolar imi ile bir değişken ismi olarak kullanlabilir
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$$a = 'dünya';
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Bu noktada PHP sembol ağacında iki değişken tanımlanmış ve saklanmış
    olur: <varname>$a</varname> "merhaba" içerirken
    <varname>$merhaba</varname> ise "dünya" içerir. Bu nedenle, aşağıdaki
    iki örnek aynı sonucu üretir:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
echo "$a {$$a}";
?>
]]>
    </programlisting>
   </informalexample>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
echo "$a $merhaba";
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Her ikisi de 'merhaba dünya' üretir.
   </simpara>

   <simpara>
    Değişken değişkenleri dizilerle kullanmak için, bir anlam karmaşası
    sorununu çözümlemeniz gerekir. <varname>$$a[1]</varname> yazdığınızda
    değişken olarak <varname>$a[1]</varname>'i mi kastettiğiniz, yoksa
    <varname>$$a</varname>'nın değişken olmasını isteyip [1] ile o
    değişkenin indisini mi kastettiğinizi çözümleyicinin bilmesi gerekir. Bu
    anlam karmaşasını çözümleyen söz dizimi, birinci durum için
    <varname>${$a[1]}</varname> ve ikinci için
    <varname>${$a}[1]</varname>'dir.
   </simpara>

   <simpara>
    Sınıf özelliklerine değişken  özellik isimlerinden de erişilebilir.
    Değişken özellik ismi çağrının yapıldığı etki alanı içinde çözümlenir.
    Örneğin, <varname>$foo->$zam</varname> gibi bir değişkeniniz olsun; burada
    <varname>$zam</varname>'ın etki alanı incelenir ve <varname>$foo</varname>
    özelliğinin ismi olarak kullanılır. <varname>$zam</varname>, bir diziye
    erişim için kullanılıyorsa yine aynı durum geçerlidir.
   </simpara>

   <simpara>
    Kaşlı ayraçlar, özellik ismini açıkça sınırlamak için de kullanılabilir.
    Bir dizi içinde bulunan bir özelliğin değerlerine erişmek için ya da
    özellik ismi başka türlü geçerli olmayan karakterler (örn,
    <function>json_decode</function> veya <link
    linkend="book.simplexml">SimpleXML</link> ile üretilmiş) içeriyorsa çok
    kullanışlıdır.
   </simpara>

   <para>
    <example>
     <title>- Değişken özellik örneği</title>
      <programlisting role="php">
<![CDATA[
<?php
class foo {
    var $bar = 'I am bar.';
    var $arr = array('I am A.', 'I am B.', 'I am C.');
    var $r   = 'I am r.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo $foo->$bar . "\n";
echo $foo->{$baz[1]} . "\n";

$start = 'b';
$end   = 'ar';
echo $foo->{$start . $end} . "\n";

$arr = 'arr';
echo $foo->{$arr[1]} . "\n";

?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
I am bar.
I am bar.
I am bar.
I am r.
     </screen>
    </example>
   </para>

   <warning>
    <simpara>
      Değişken değişkenlerin işlev ve sınıf yöntemleri içinde PHP'nin
      <link linkend="language.variables.superglobals">Süper küresel
      dizileri</link> ile kullanılamayacağını unutmayınız.
      <literal>$this</literal> değişkeni de dinamik olarak gönderimli
      olamayan özel bir değişkendir.
    </simpara>
   </warning>

  </sect1>

  <sect1 xml:id="language.variables.external">
   <title>Dış Kaynaklı Değişkenler</title>

   <sect2 xml:id="language.variables.external.form">
    <title>HTML Formları (GET ve POST)</title>

    <simpara>
      Bir PHP betiğine bir form gönderildiğinde o formdaki bilgi betik
      tarafından otomatik olarak kullanılır. Bu bilgiye erişmek için
      birçok yol vardır, örneğin:
    </simpara>

    <para>
     <example>
      <title>- Basit bir HTML formu</title>
      <programlisting role="php">
<![CDATA[
<form action="foo.php" method="post">
    Name:  <input type="text" name="kullanici_adi" /><br />
    Email: <input type="text" name="eposta" /><br />
    <input type="submit" name="submit" value="Beni gönder!" />
</form>
]]>
      </programlisting>
     </example>
    </para>

    <para>
     HTML  formlarınızdaki bilgiye erişimin iki yolu
     vardır. Şu an için kullanılabilen yöntemler aşağıda sıralanmıştır:
    </para>

    <para>
     <example>
      <title>- Basit bir POST HTML formundan bilgiye erişim</title>
      <programlisting role="html">
<![CDATA[
<?php

echo $_POST['kullanici_adi'];
echo $_REQUEST['kullanici_adi'];
?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
      Bunun yerine önceden tanımlı uygun bir GET değişkeni kullanmak
      dışında, GET formunun kullanımı aynıdır. GET ayrıca
      <literal>QUERY_STRING</literal> (Bir URL'de '?' iminden sonraki bilgi)
      sorgu dizgesine de uygulanır. Bu bakımdan örneğin,
      <literal>http://mesela.dom/dnm.php?id=3</literal>
      <varname>$_GET['id']</varname> ile erişilebilen GET verisini içerir.
      Ayrıca, <varname>$_REQUEST</varname> değişkenine de bakınız.
    </para>

    <note>
     <para>
      Değişken isimlerindeki noktalar ve boşluklar altçizgi karakterine
      dönüştürülür. Örneğin, <literal>&lt;input name="a.b" /&gt;</literal>
      ifadesi <literal>$_REQUEST["a_b"]</literal> haline gelir.
     </para>
     </note>

    <simpara>
     PHP form değişkenleri bağlamında dizileri de anlar (<link
     linkend="faq.html">ilgili SSS</link>'ye bakınız). Örneğin, ilgili
     değişkenleri birlikte gruplayabilir veya bu özelliği çoklu seçim
     girdisinden değerleri almak için kullanabilirsiniz. Örneğin, bir formu
     kendine gönderelim ve gönderilen veriyi gösterelim:
    </simpara>

    <para>
     <example>
      <title>- Daha karmaşık form değişkenleri</title>
      <programlisting role="php">
<![CDATA[
<?php
if ($_POST) {
    echo '<pre>';
    echo htmlspecialchars(print_r($_POST, true));
    echo '</pre>';
}
?>
<form action="" method="post">
    Adı:  <input type="text" name="personal[isim]" /><br />
    Eposta: <input type="text" name="personal[eposta]" /><br />
    Bira: <br />
    <select multiple name="bira[]">
        <option value="efes">Efes</option>
        <option value="tuborg">Tuborg</option>
        <option value="venus">Venüs</option>
    </select><br />
    <input type="submit" value="Gönder!" />
</form>
]]>
      </programlisting>
     </example>
    </para>

    <note>
     <simpara>
      Harici değişken ismi geçerli bir dizi sözdizimi ile başlıyorsa sondaki
      karakterler sessizce yoksayılır. Örneğin, <literal>&lt;input
      name="foo[bar]baz"&gt;</literal> girdisi <literal>$_REQUEST['foo']
      ['bar']</literal> haline gelir.
     </simpara>
    </note>

    <sect3 xml:id="language.variables.external.form.submit">
     <title>Gönder düğmesi değişken isimleri</title>

     <simpara>
      Bir formu gönderirken, şöyle bir etiketle standart gönder düğmesi
      yerine görüntü kullanılabilir:
     </simpara>

     <informalexample>
      <programlisting role="html">
<![CDATA[
<input type="image" src="image.gif" name="sub" />
]]>
      </programlisting>
     </informalexample>

     <simpara>
      Kullanıcı görüntü üzerinde bir yere tıkladığında, eşlik eden form iki ek
      değişkenle sunucuya iletilmiş olur: <varname>sub_x</varname> ve
      <varname>sub_y</varname>. Bunlar kullanıcın
      görüntü üzerinde tıkladığı noktanın koordinatlarını içerir. Deneyimliler
      tarayıcı tarafından gönderilen asıl değişken isimlerinin alt çizgi
      yerine nokta içerdiğine dikkat etmiş olabilirler, fakat PHP noktaları
      otomatik olarak alt çizgiye çevirir.
     </simpara>
    </sect3>

   </sect2>

   <sect2 xml:id="language.variables.external.cookies">
    <title>HTTP Çerezleri</title>

    <simpara>
      PHP, <link  xlink:href="&url.rfc;6265">RFC 6265</link>'de
      tanımlandığı gibi HTTP çerezlerini şeffaf olarak destekler. Çerezler
      kullanıcıları izleyip tanımlamak amacıyla kullanıcının tarayıcısında
      veri saklamak için kullanılan bir yöntemdir. Çerezleri
      <function>setcookie</function> işlevini kullanarak belirtebilirsiniz.
      Çerezler  HTTP başlığının bir parçasıdır, bu nedenle
      <function>setcookie</function> işlevi tarayıcıya herhangi bir çıktı
      gönderilmeden önce çağrılmak zorundadır. Bu kısıtlama
      <function>header</function> işlevi için de geçerlidir. Çerez verisi
      <varname>$_COOKIE</varname> veya <varname>$_REQUEST</varname> gibi
      uygun çerez veri dizisinde bulunur. Ayrıntılar ve örnekler için
      <function>setcookie</function> kılavuz sayfasına bakınız.
    </simpara>

    <note>
     <simpara>
      Sırasıyla PHP 7.2.34, 7.3.23 ve 7.4.11'den itibaren,  gelen çerezlerin
      <emphasis>isimleri</emphasis> güvenlik kaygıları nedeniyle artık
      url-kodlu değildir.
     </simpara>
    </note>

    <simpara>
      Eğer tek bir çerez değişkenine birden fazla değer atamak isterseniz,
      değişkeni bir dizi olarak atayabilirsiniz. Örneğin:
    </simpara>

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
  setcookie("Cerezim[foo]", 'Deneme 1', time()+3600);
  setcookie("Cerezim[bar]", 'Deneme 2', time()+3600);
?>
]]>
     </programlisting>
    </informalexample>

    <simpara>
      Her ne kadar betiğinizde <literal>Cerezim</literal> tek bir dizi olsa da
      bu iki ayrı çerez oluşturacaktır. Eğer birden fazla değere sahip tek bir
      çerez atamak isterseniz, önce değer üzerinde
      <function>serialize</function> veya <function>explode</function>
      kullanmayı düşünün.
    </simpara>

    <simpara>
      Yolu veya alan adı farklı olmadığı sürece aynı isimdeki bir çerez
      önceki çerezin üzerine yazılır. Böylece, isterseniz örneğin bir
      alışveriş sepeti uygulaması için bir sayaç tutabilir ve bunu karşıya
      aktarabilirsiniz.
    </simpara>

    <example>
     <title>- <function>setcookie</function> örneği</title>
     <programlisting role="php">
<![CDATA[
<?php
if (isset($_COOKIE['sayac'])) {
    $sayac = $_COOKIE['sayac'] + 1;
} else {
    $sayac = 1;
}
setcookie('sayac', $sayac, time()+3600);
setcookie("Sepet[$sayac]", $mal, time()+3600);
?>
]]>
     </programlisting>
    </example>

   </sect2>

   <sect2 xml:id="language.variables.external.dot-in-names">
    <title>Gelen değişken isimleri içindeki noktalar</title>

    <para>
      Genellikle, PHP bir betiğe aktarılan değişken isimlerini değiştirmez.
      Fakat, nokta iminin PHP'de değişken isimlerinde geçerli bir karakter
      olmadığına dikkat edilmelidir. Örnek:
  <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$varname.ext;  /* geçersiz değişken ismi */
?>
]]>
    </programlisting>
  </informalexample>

      Burada, yazım denetleyicinin gördüğü <varname>$varname</varname>
      isimli bir değişkeni takip eden bir dizge birleştirme işlemi ve çıplak
      bir (tırnaklarla çevrilmemiş, herhangi bir anahtar veya anahtar sözcük
      ile eşleşmeyen dizge) 'ext' metnidir. Açıkça görülüyor ki, bu istenen
      sonucu vermemektedir.
    </para>

    <para>
      Bu nedenle, PHP'nin gelen değişken isimlerindeki nokta imlerini alt
      çizgi imi ile değiştirdiğini bilmekte yarar vardır.
    </para>

   </sect2>

   <sect2 xml:id="language.variables.determining-type-of">
    <title>Değişken türlerini belirlemek</title>

    <para>
      Değişken türlerini PHP belirlediği ve (genellikle) gerektiği gibi
      değiştirdiği için, verilen bir değişkenin herhangi bir anda hangi
      türde olduğu sorgulanmadan bilinemez. PHP'de bir değişkenin hangi
      türde olduğunu bulan birçok işlev vardır. Örnek:
      <function>gettype</function>, <function>is_array</function>,
      <function>is_float</function>, <function>is_int</function>,
      <function>is_object</function> ve <function>is_string</function>.
      Ayrıca <link linkend="language.types">Türler</link> bölümüne de
      bakınız.
    </para>
    <para>
     Bir metin protokolü olarak HTTP'de, çoğunlukla, tamamen olmasa da,
     <link linkend="language.variables.superglobals">Süper küresel
     diziler</link> içinde gelen içerik dizge olarak kalır. PHP değerleri
     belli bir türe dönüştürmeyi denemez. Aşağıdaki örnekte,
     <varname>$_GET["var1"]</varname> değişkeni "null" ve
     <varname>$_GET["var2"]</varname>ise "123" dizgesini içerecektir.
     <programlisting>
<![CDATA[
/index.php?var1=null&var2=123
]]>
      </programlisting>
    </para>
   </sect2>

   <sect2 xml:id="language.variables.external.changelog">
    &reftitle.changelog;

    <para>
     <informaltable>
      <tgroup cols="2">
       <thead>
        <row>
         <entry>&Version;</entry>
         <entry>&Description;</entry>
        </row>
       </thead>
       <tbody>
        <row>
         <entry>7.2.34, 7.3.23, 7.4.11</entry>
         <entry>
          Gelen çerezlerin <emphasis>isimleri</emphasis> güvenlik kaygıları
          nedeniyle artık url-kodlu değildir.
         </entry>
        </row>
       </tbody>
      </tgroup>
     </informaltable>
    </para>
   </sect2>

  </sect1>

 </chapter>

<!-- 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
-->