archived-doc-tr/language/operators/bitwise.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 8859c8b96cd9e80652813f7bcf561432a5e9f934 Maintainer: nilgun Status: ready -->
<sect1 xml:id="language.operators.bitwise">
 <title>Bitsel İşleçler</title>
 <titleabbrev>Bitsel</titleabbrev>
 <simpara>
  Bitsel işleçler, bir tamsayının içindeki belli bitleri 0 ya da 1
  yaparlar.
 </simpara>

 <table>
  <title>Bitsel İşleçler</title>
  <tgroup cols="3">
   <thead>
    <row>
     <entry>Örnek</entry>
     <entry>İsim</entry>
     <entry>Sonuç</entry>
    </row>
   </thead>
   <tbody>
    <row>
     <entry><userinput>$a &amp; $b</userinput></entry>
     <entry>Ve</entry>
     <entry>Hem <varname>$a</varname> hem de <varname>$b</varname>'de 1 olan
     bitler sonuçta 1 yapılır.</entry>
    </row>
    <row>
     <entry><userinput>$a | $b</userinput></entry>
     <entry>Veya</entry>
     <entry><varname>$a</varname> veya <varname>$b</varname>'de 1 olan
     bitler sonuçta 1 yapılır.</entry>
    </row>
    <row>
     <entry><userinput>$a ^ $b</userinput></entry>
     <entry>Ayrıcalıklı Veya</entry>
     <entry>
      Hem <varname>$a</varname> hem de <varname>$b</varname>'de 0 veya 1
      olan bitler sonuçta 0, diğerleri 1 yapılır.
     </entry>
    </row>
    <row>
     <entry><userinput>~ $a</userinput></entry>
     <entry>Değil</entry>
     <entry>
      <varname>$a</varname>'nın 0 olan bitleri 1, 1 olanları 0 yapılır.
     </entry>
    </row>
    <row>
     <entry><userinput>$a &lt;&lt; $b</userinput></entry>
     <entry>Sola kaydırma</entry>
     <entry>
      <varname>$a</varname>'nın bitleri <varname>$b</varname> adım sola
      kaydırılır (her adım ikiyle çarpma işlemine denktir).
     </entry>
    </row>
    <row>
     <entry><userinput>$a &gt;&gt; $b</userinput></entry>
     <entry>Sağa kaydırma</entry>
     <entry>
      <varname>$a</varname>'nın bitleri <varname>$b</varname> adım sağa
      kaydırılır (her adım ikiye bölme işlemine denktir).
     </entry>
    </row>
   </tbody>
  </tgroup>
 </table>
 <para>
  PHP'de bit kaydırma bir aritmetik işlemdir. Kaydırma sonucu her iki uçtan
  da taşan bitler silinir. Sola kaydırmada sağdan eksilen bitler sıfırlarla
  doldurulur, bu arada işaret biti soldan taşarak silinir, yani sola
  kaydırmada terimin işareti korunmaz. Sağa kaldırmada ise işaret biti
  yerinden oynatılmaz, yani sağa kaydırmada terimin işareti korunur.
 </para>
 <para>
  Bir işlemin <link linkend="language.operators.precedence">öncelik</link>
  alması gerekiyorsa yaylı ayraçlar kullanılmalıdır. Örneğin, <literal>$a
  &amp; $b == true</literal> işleminde önce eşitlik sonra bitsel VE
  uygulanırken <literal>($a &amp; $b) == true</literal> işleminde ise
  önce bitsel VE sonra eşitlik uygulanır.
 </para>
 <para>
  Eğer <literal>&amp;</literal>, <literal>|</literal> ve
  <literal>^</literal> için her iki terim de dize ise terimlerdeki
  karakterlerin ASCII değerleri üzerinde işlem yapılır ve sonuç bir dize
  olur. Tüm diğer durumlarda, her iki terim <link
  linkend="language.types.integer.casting">tamsayıya dönüştürülür</link>
  ve sonuç tamsayı olur.
 </para>
 <para>
  <literal>~</literal> işleci için terim bir dize ise, terimdeki
  karakterlerin ASCII değerleri üzerinde işlem yapılır ve sonuç bir dize
  olur. Aksi takdirde, terim ve sonuç tamsayı olarak ele alınır.
 </para>
 <para>
  <literal>&lt;&lt;</literal> ve <literal>&gt;&gt;</literal> işleçleri için
  her iki terim ve sonuç daima tamsayı olarak ele alınır.
 </para>
<para>
  <informalexample>
   <para>
    <literallayout>
PHP'nin error_reporting yönergesi gerçekte neler olup bittiğini göstermek
için bitsel değerler kullanır. Sadece bilgilendirmeleri değil hataların
tümünü görmek için php.ini dosyasında ilgili yere şu yazılabilir:
<userinput>E_ALL &amp; ~E_NOTICE</userinput>
    </literallayout>
   </para>
   <para>
    <literallayout>
Bu E_ALL için şöyle çalışır:
<userinput>00000000000000000111011111111111</userinput>
Keza E_NOTICE...
<userinput>00000000000000000000000000001000</userinput>
... ve <literal>~</literal> ile ters çevrilerek:
<userinput>11111111111111111111111111110111</userinput>
Son olarak, her iki değer üzerinde etkin bitleri bulmak için
VE (&amp;) işlecini kullanır:
<userinput>00000000000000000111011111110111</userinput>
    </literallayout>
   </para>
   <para>
    <literallayout>
Bunu sağlamanın bir başka yolu da sadece bir değerde veya diğerinde etkin
bitleri bulmak için XOR (<literal>^</literal>) kullanmaktır:
<userinput>E_ALL ^ E_NOTICE</userinput>
    </literallayout>
   </para>
  </informalexample>
 </para>
 <para>
  <informalexample>
   <para>
    <literallayout>
error_reporting yönergesi bitleri etkin kılmayı göstermek için de
kullanılabilir. Sadece hataları ve kurtarılabilir göstermenin yolu:
<userinput>E_ERROR | E_RECOVERABLE_ERROR</userinput>
    </literallayout>
   </para>
   <para>
    <literallayout>
Bu işlem etkin bitleri almak için
<userinput>00000000000000000000000000000001</userinput>
ve
<userinput>00000000000000000001000000000000</userinput>
E_ERROR'ları üzerinde VEYA (<literal>|</literal>) işlecini kullanır:
<userinput>00000000000000000001000000000001</userinput>
    </literallayout>
   </para>
  </informalexample>
 </para>
 <para>
  <example>
   <title>- Tamsayılar üzerinde bitsel işlemler</title>
   <programlisting role="php">
<![CDATA[
<?php
/*
 * Üstteki bölümü yoksay,
 * çıktıyı iyileştirmek için biçemlemekten başka birşey yapmıyor.
 */

$format = '(%1$2d = %1$04b) = (%2$2d = %2$04b)'
        . ' %3$s (%4$2d = %4$04b)' . "\n";

echo <<<EOH
 ---------     ---------  -- ---------
   sonuç         değer    işl   dnm
 ---------     ---------  -- ---------
EOH;


/*
 * Örnekler burada.
 */

$değerler = array(0, 1, 2, 4, 8);
$dnm = 1 + 4;

echo "\n Bitsel VE \n";
foreach ($değerler as $değer) {
    $sonuç = $değer & $dnm;
    printf($format, $sonuç, $değer, '&', $dnm);
}

echo "\n Bitsel Ayrıcalıklı VEYA \n";
foreach ($değerler as $değer) {
    $sonuç = $değer | $dnm;
    printf($format, $sonuç, $değer, '|', $dnm);
}

echo "\n Bitsel Ayrıcalıklı VEYA (XOR) \n";
foreach ($değerler as $değer) {
    $sonuç = $değer ^ $dnm;
    printf($format, $sonuç, $değer, '^', $dnm);
}
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
 ---------     ---------  -- ---------
   sonuç         değer    işl   dnm
 ---------     ---------  -- ---------
 Bitsel VE
( 0 = 0000) = ( 0 = 0000) & ( 5 = 0101)
( 1 = 0001) = ( 1 = 0001) & ( 5 = 0101)
( 0 = 0000) = ( 2 = 0010) & ( 5 = 0101)
( 4 = 0100) = ( 4 = 0100) & ( 5 = 0101)
( 0 = 0000) = ( 8 = 1000) & ( 5 = 0101)

 Bitsel Ayrıcalıklı VEYA
( 5 = 0101) = ( 0 = 0000) | ( 5 = 0101)
( 5 = 0101) = ( 1 = 0001) | ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) | ( 5 = 0101)
( 5 = 0101) = ( 4 = 0100) | ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) | ( 5 = 0101)

 Bitsel Ayrıcalıklı VEYA (XOR)
( 5 = 0101) = ( 0 = 0000) ^ ( 5 = 0101)
( 4 = 0100) = ( 1 = 0001) ^ ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) ^ ( 5 = 0101)
( 1 = 0001) = ( 4 = 0100) ^ ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) ^ ( 5 = 0101)
]]>
   </screen>
  </example>
 </para>
 <para>
  <example>
   <title>- Dizgeler üzerinde bitsel işlemler</title>
   <programlisting role="php">
<![CDATA[
<?php
echo 12 ^ 9; // '5' çıktılar

echo "12" ^ "9"; // Gerisilme karakterini çıktılar (ASCII 8)
                 // ('1' (ascii 49)) ^ ('9' (ascii 57)) =  ASCII 8

echo "hallo" ^ "hello"; // Çıktılanan ASCII değerler #0 #4 #0 #0 #0
                        // 'a' ^ 'e' = #4

echo 2 ^ "3"; // 1 çıktılar
              // 2 ^ ((int) "3") == 1

echo "2" ^ 3; // 1 çıktılar
              // ((int) "2") ^ 3 == 1
?>
]]>
   </programlisting>
  </example>
 </para>
 <para>
  <example>
   <title>- Tamsayılarda bit kaydırma</title>
   <programlisting role="php">
<![CDATA[
<?php
/*
 * Bunlar örnektir.
 */

echo "\n--- POZİTİF TAMSAYILARDA SAĞA BİT KAYDIRMA ---\n";

$dgr = 4;
$hane = 1;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane, 'işaret bitinin kopyası sola kaydırıldı');

$dgr = 4;
$hane = 2;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane);

$dgr = 4;
$hane = 3;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane, 'bitler sağa kaydırıldı');

$dgr = 4;
$hane = 4;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane, 'yukarıdakiyle aynı; 0\'dan sonrası kaydırılamaz');


echo "\n--- NEGATİF TAMSAYILARDA SAĞA BİT KAYDIRMA ---\n";

$dgr = -4;
$hane = 1;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane, 'işaret bitinin kopyası sola kaydırıldı');

$dgr = -4;
$hane = 2;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane, 'bitler sağa kaydırıldı');

$dgr = -4;
$hane = 3;
$snç = $dgr >> $hane;
p($snç, $dgr, '>>', $hane, 'yukarıdakiyle aynı; -1\'dan sonrası kaydırılamaz');


echo "\n--- POZİTİF TAMSAYILARDA SOLA BİT KAYDIRMA ---\n";

$dgr = 4;
$hane = 1;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane, 'sağ taraf sıfırlarla doldurulur');

$dgr = 4;
$hane = (PHP_INT_SIZE * 8) - 4;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane);

$dgr = 4;
$hane = (PHP_INT_SIZE * 8) - 3;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane, 'işaret bitleri dışa kaydırılır');

$dgr = 4;
$hane = (PHP_INT_SIZE * 8) - 2;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane, 'bitler sola kaydırıldı');


echo "\n--- NEGATİF TAMSAYILARDA SOLA BİT KAYDIRMA ---\n";

$dgr = -4;
$hane = 1;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane, 'sağ taraf sıfırlarla doldurulur');

$dgr = -4;
$hane = (PHP_INT_SIZE * 8) - 3;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane);

$dgr = -4;
$hane = (PHP_INT_SIZE * 8) - 2;
$snç = $dgr << $hane;
p($snç, $dgr, '<<', $hane, 'işaret biti dahil, bitler soldan dışa kaydırıldı');


/*
 * Bundan sonrasını yoksayın; çıktıyı biçemlemekten başka bir şey yapmıyor.
 */

function p($snç, $dgr, $op, $hane, $ilt = '') {
    $format = '%0' . (PHP_INT_SIZE * 8) . "b\n";

    printf("İfade: %d = %d %s %d\n", $snç, $dgr, $op, $hane);

    echo " Onluk:\n";
    printf("  değer=%d\n", $dgr);
    printf("  sonuç=%d\n", $snç);

    echo " İkilik:\n";
    printf('  değer=' . $format, $dgr);
    printf('  sonuç=' . $format, $snç);

    if ($ilt) {
        echo " DİKKAT: $ilt\n";
    }

    echo "\n";
}
?>
]]>
   </programlisting>
   &example.outputs.32bit;
   <screen>
<![CDATA[

--- POZİTİF TAMSAYILARDA SAĞA BİT KAYDIRMA ---
İfade: 2 = 4 >> 1
 Onluk:
  değer=4
  sonuç=2
 İkilik:
  değer=000000000000000000000000000100
  sonuç=000000000000000000000000000010
 DİKKAT: işaret bitinin kopyası sola kaydırıldı

İfade: 1 = 4 >> 2
 Onluk:
  değer=4
  sonuç=1
 İkilik:
  değer=000000000000000000000000000100
  sonuç=000000000000000000000000000001

İfade: 0 = 4 >> 3
 Onluk:
  değer=4
  sonuç=0
 İkilik:
  değer=000000000000000000000000000100
  sonuç=000000000000000000000000000000
 DİKKAT: bitler sağa kaydırıldı

İfade: 0 = 4 >> 4
 Onluk:
  değer=4
  sonuç=0
 İkilik:
  değer=000000000000000000000000000100
  sonuç=000000000000000000000000000000
 DİKKAT: yukarıdakiyle aynı; 0'dan sonrası kaydırılamaz


--- NEGATİF TAMSAYILARDA SAĞA BİT KAYDIRMA ---
İfade: -2 = -4 >> 1
 Onluk:
  değer=-4
  sonuç=-2
 İkilik:
  değer=111111111111111111111111111100
  sonuç=111111111111111111111111111110
 DİKKAT: işaret bitinin kopyası sola kaydırıldı

İfade: -1 = -4 >> 2
 Onluk:
  değer=-4
  sonuç=-1
 İkilik:
  değer=111111111111111111111111111100
  sonuç=111111111111111111111111111111
 DİKKAT: bitler sağa kaydırıldı

İfade: -1 = -4 >> 3
 Onluk:
  değer=-4
  sonuç=-1
 İkilik:
  değer=111111111111111111111111111100
  sonuç=111111111111111111111111111111
 DİKKAT: yukarıdakiyle aynı; -1'dan sonrası kaydırılamaz


--- POZİTİF TAMSAYILARDA SOLA BİT KAYDIRMA ---
İfade: 8 = 4 << 1
 Onluk:
  değer=4
  sonuç=8
 İkilik:
  değer=000000000000000000000000000100
  sonuç=000000000000000000000000001000
 DİKKAT: sağ taraf sıfırlarla doldurulur

İfade: 4611686018427387904 = 4 << 60
 Onluk:
  değer=4
  sonuç=4611686018427387904
 İkilik:
  değer=000000000000000000000000000100
  sonuç=010000000000000000000000000000

İfade: -9223372036854775808 = 4 << 61
 Onluk:
  değer=4
  sonuç=-9223372036854775808
 İkilik:
  değer=000000000000000000000000000100
  sonuç=100000000000000000000000000000
 DİKKAT: işaret bitleri dışa kaydırılır

İfade: 0 = 4 << 62
 Onluk:
  değer=4
  sonuç=0
 İkilik:
  değer=000000000000000000000000000100
  sonuç=000000000000000000000000000000
 DİKKAT: bitler sola kaydırıldı


--- NEGATİF TAMSAYILARDA SOLA BİT KAYDIRMA ---
İfade: -8 = -4 << 1
 Onluk:
  değer=-4
  sonuç=-8
 İkilik:
  değer=111111111111111111111111111100
  sonuç=111111111111111111111111111000
 DİKKAT: sağ taraf sıfırlarla doldurulur

İfade: -9223372036854775808 = -4 << 61
 Onluk:
  değer=-4
  sonuç=-9223372036854775808
 İkilik:
  değer=111111111111111111111111111100
  sonuç=100000000000000000000000000000

İfade: 0 = -4 << 62
 Onluk:
  değer=-4
  sonuç=0
 İkilik:
  değer=111111111111111111111111111100
  sonuç=000000000000000000000000000000
 DİKKAT: işaret biti dahil, bitler soldan dışa kaydırıldı
]]>
   </screen>
   &example.outputs.64bit;
   <screen>
<![CDATA[

--- POZİTİF TAMSAYILARDA SAĞA BİT KAYDIRMA ---
İfade: 2 = 4 >> 1
 Onluk:
  değer=4
  sonuç=2
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0000000000000000000000000000000000000000000000000000000000000010
 DİKKAT: işaret bitinin kopyası sola kaydırıldı

İfade: 1 = 4 >> 2
 Onluk:
  değer=4
  sonuç=1
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0000000000000000000000000000000000000000000000000000000000000001

İfade: 0 = 4 >> 3
 Onluk:
  değer=4
  sonuç=0
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0000000000000000000000000000000000000000000000000000000000000000
 DİKKAT: bitler sağa kaydırıldı

İfade: 0 = 4 >> 4
 Onluk:
  değer=4
  sonuç=0
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0000000000000000000000000000000000000000000000000000000000000000
 DİKKAT: yukarıdakiyle aynı; 0'dan sonrası kaydırılamaz


--- NEGATİF TAMSAYILARDA SAĞA BİT KAYDIRMA ---
İfade: -2 = -4 >> 1
 Onluk:
  değer=-4
  sonuç=-2
 İkilik:
  değer=1111111111111111111111111111111111111111111111111111111111111100
  sonuç=1111111111111111111111111111111111111111111111111111111111111110
 DİKKAT: işaret bitinin kopyası sola kaydırıldı

İfade: -1 = -4 >> 2
 Onluk:
  değer=-4
  sonuç=-1
 İkilik:
  değer=1111111111111111111111111111111111111111111111111111111111111100
  sonuç=1111111111111111111111111111111111111111111111111111111111111111
 DİKKAT: bitler sağa kaydırıldı

İfade: -1 = -4 >> 3
 Onluk:
  değer=-4
  sonuç=-1
 İkilik:
  değer=1111111111111111111111111111111111111111111111111111111111111100
  sonuç=1111111111111111111111111111111111111111111111111111111111111111
 DİKKAT: yukarıdakiyle aynı; -1'dan sonrası kaydırılamaz


--- POZİTİF TAMSAYILARDA SOLA BİT KAYDIRMA ---
İfade: 8 = 4 << 1
 Onluk:
  değer=4
  sonuç=8
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0000000000000000000000000000000000000000000000000000000000001000
 DİKKAT: sağ taraf sıfırlarla doldurulur

İfade: 4611686018427387904 = 4 << 60
 Onluk:
  değer=4
  sonuç=4611686018427387904
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0100000000000000000000000000000000000000000000000000000000000000

İfade: -9223372036854775808 = 4 << 61
 Onluk:
  değer=4
  sonuç=-9223372036854775808
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=1000000000000000000000000000000000000000000000000000000000000000
 DİKKAT: işaret bitleri dışa kaydırılır

İfade: 0 = 4 << 62
 Onluk:
  değer=4
  sonuç=0
 İkilik:
  değer=0000000000000000000000000000000000000000000000000000000000000100
  sonuç=0000000000000000000000000000000000000000000000000000000000000000
 DİKKAT: bitler sola kaydırıldı


--- NEGATİF TAMSAYILARDA SOLA BİT KAYDIRMA ---
İfade: -8 = -4 << 1
 Onluk:
  değer=-4
  sonuç=-8
 İkilik:
  değer=1111111111111111111111111111111111111111111111111111111111111100
  sonuç=1111111111111111111111111111111111111111111111111111111111111000
 DİKKAT: sağ taraf sıfırlarla doldurulur

İfade: -9223372036854775808 = -4 << 61
 Onluk:
  değer=-4
  sonuç=-9223372036854775808
 İkilik:
  değer=1111111111111111111111111111111111111111111111111111111111111100
  sonuç=1000000000000000000000000000000000000000000000000000000000000000

İfade: 0 = -4 << 62
 Onluk:
  değer=-4
  sonuç=0
 İkilik:
  değer=1111111111111111111111111111111111111111111111111111111111111100
  sonuç=0000000000000000000000000000000000000000000000000000000000000000
 DİKKAT: işaret biti dahil, bitler soldan dışa kaydırıldı
]]>
   </screen>
  </example>
</para>
 <warning>
  <para>
   <constant>PHP_INT_MAX</constant>'ın ötesindeki sayılar üzerinde bitsel
   işlemler için <link linkend="book.gmp">gmp</link> eklentisindeki
   işlevler kullanılmalıdır.
  </para>
 </warning>

 <sect2 role="seealso">
  &reftitle.seealso;
  <para>
   <simplelist>
<!-- <link linkend="language.oop5.basic.class.class">::class</link> -->
    <member><function>pack</function></member>
    <member><function>unpack</function></member>
    <member><function>gmp_and</function></member>
    <member><function>gmp_or</function></member>
    <member><function>gmp_xor</function></member>
    <member><function>gmp_testbit</function></member>
    <member><function>gmp_clrbit</function></member>
   </simplelist>
  </para>
 </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
-->