PHP/Diziler
Diziler değiştir
Diziler, farklı sayıl türlerin birarada tutulabileceği bileşik bir türdür. Dizilerin temelinde anahtar - değer ilişkisi vardır. Yani her anahtar, bir değeri işaret eder. Anahtarlar integer veya string olabilirken değerler integer, string, float, boolean veya bir array (dizi) olabilir.
<?php
$dizi = array("a", "b", "c");
?>
Yukarıda "a", "b" ve "c" değerlerini tutan bir dizi tanımlanmıştır. Anahtar belirtilmemiştir. var_dump() kullanarak, bu diziyle ilgili bilgilere bakalım:
<?php
$dizi = array("a", "b", "c");
var_dump($dizi);
?>
Çıktısı:
array(3) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" }
Bu çıktıya göre "a" değerinin anahtarı 0, "b" değerinin anahtarı 1 ve "c" değerinin anahtarı 2′dir. Eğer burada olduğu gibi dizi tanımlanırken sadece değerler belirtilirse, dizi anahtarları 0'dan (sıfır) başlar. Yani yukarıdaki örnek şununla eşdeğerdir:
<?php
$dizi = array(0 => "a", 1 => "b", 2 => "c");
?>
Görüldüğü gibi anahtar ve değer eşlemesinde => işareti kullanılıyor. Değerleri birbirinden ayırırken de virgül kullanılıyor. Bu diziyi echo ile ekrana yazdırmayı deneyelim:
<?php
$dizi = array("a", "b", "c");
echo $dizi;
?>
Çıktısı:
Notice: Array to string conversion in dosya.php on line 3 Array
Beklenildiği gibi olmadı. Bunun nedeni dizilerin, indis belirtilmeden echo ile çıktılanamamasıdır. Ama şu çalışır:
<?php
$dizi = array("a", "b", "c");
echo $dizi[0];
?>
a değeri çıktılanacaktır. Burada echo deyimine "$dizi'nin 0. indisindeki değeri çıktıla emri verilmiştir. Bu şekilde anahtarlar belirtilerek, o anahtarların işaret ettiği değerler çıktılanabilir.
<?php
$dizi = array("a", "b", "c");
echo $dizi[0]; // a çıktılar
echo $dizi[1]; // b çıktılar
echo $dizi[2]; // c çıktılar
?>
Bir örnek:
<?php
$dizi = array(6 => "Ankara", 34 => "İstanbul", 35 => "İzmir");
echo $dizi[6] . " Türkiye'nin başkentidir.";
?>
Çıktısı:
Ankara Türkiye'nin başkentidir.
Başka bir örnek:
<?php
$dizi = array("Meyve" => "Portakal", "Sebze" => "Pırasa");
echo $dizi["Meyve"] . " en sevdiğim meyvedir.";
echo "<br>";
echo $dizi["Sebze"] . " sevmem";
?>
Çıktısı:
Portakal en sevdiğim meyvedir. Pırasa sevmem.
Bir anahtarın değeri şu biçimde değiştirilebilir:
<?php
$dizi = array("Meyve" => "Portakal", "Sebze" => "Pırasa");
$dizi["Meyve"] = "Elma";
echo $dizi["Meyve"]; // Elma çıktılar
?>
<?php
$dizi = array(true => "doğru"); // hatalı. boolean değerler anahtar olamaz
?>
Dizi tanımında anahtar belirtilmediği zaman anahtarların 0'dan (sıfır) başlayacağını biliyoruz. Ancak yalnızca ilk değere anahtar vererek bu değiştirilebilir.
<?php
$dizi = array(1 => "a", "b", 12, false);
var_dump($dizi);
?>
Çıktısı:
array(4) { [1]=> string(1) "a" [2]=> string(1) "b" [3]=> int(12) [4]=> bool(false) }
Görüldüğü gibi anahtarlar 1'den başladı.
<?php
$dizi = array("string" => "PHP", "integer" => 12, "float" => 4.6, "boolean" => true);
echo $dizi["string"]; // PHP çıktılar
var_dump($dizi["boolean"]); // bool(true) çıktılar
$a = $dizi["integer"] + $dizi["float"]; // $a = 16.6
?>
Başka bir dizi tanımlama yöntemi daha vardır.
<?php
$dizi["string"] = "PHP";
$dizi["integer"] = 12;
$dizi["float"] = 4.6;
$dizi["boolean"] = true;
?>
Bu tanımlanan dizi, bir önceki örnektekiyle aynıdır.
Dizi tanımlarının uzayıp gitmemesi için girintileme yapılabilir.
<?php
$dizi = ("mekan" => "Vikikitap",
"dil" => "PHP",
"konu" => "Diziler");
?>
Şimdiye dek verilen örnekler tek boyutlu dizi örnekleriydi. Çok boyutlu diziler -yani iç içe diziler- de tanımlanabilir.
<?php
$dizi = array("İl" => array("Ankara", "İstanbul", "İzmir"),
"Plaka" => array(6, 34, 35));
var_dump($dizi);
?>
Çıktısı:
array(2) { ["İl"]=> array(3) { [0]=> string(6) "Ankara" [1]=> string(8) "İstanbul" [2]=> string(5) "İzmir" } ["Plaka"]=> array(3) { [0]=> int(6) [1]=> int(34) [2]=> int(35) } }
$dizi dizisinin İl ve Plaka olmak üzere 2 anahtarı vardır ve bu anahtarlar birer dizi barındırır. İçteki dizilerin değerlerine anahtar değer verilmedi. Yani yukarıdaki tanımlama, PHP yorumlayıcısı tarafından, şöyle yapılmış varsayılır:
<?php
$dizi = array("İl" => array(0 => "Ankara", 1 => "İstanbul", 2 => "İzmir"),
"Plaka" => array(0 => 6, 1 => 34, 2 => 35));
?>
Dizinin elemanlarına erişip çıktılayalım:
<?php
$dizi = array("il" => array("Ankara", "İstanbul", "İzmir"),
"plaka" => array(6, 34, 35));
echo "{$dizi["il"][0]} ilinin plaka kodu: {$dizi["plaka"][0]}<br>";
echo "{$dizi["il"][1]} ilinin plaka kodu: {$dizi["plaka"][1]}<br>";
echo "{$dizi["il"][2]} ilinin plaka kodu: {$dizi["plaka"][2]}<br>";
?>
Çıktısı:
Ankara ilinin plaka kodu: 6 İstanbul ilinin plaka kodu: 34 İzmir ilinin plaka kodu: 35
echo deyiminde süslü parantez kullanılması sizi şaşırttıysa bkz: echo deyimi
İç içe diziler şöyle de tanımlanabilir:
<?php
$dizi["il"][0] = "Ankara";
$dizi["il"][1] = "İstanbul";
$dizi["il"][2] = "İzmir";
$dizi["plaka"][0] = 6;
$dizi["plaka"][1] = 34;
$dizi["plaka"][2] = 35;
?>
Anahtar belirtilmeden atanan değerlerin anahtarları, mevcut en büyük tamsayı anahtarın bir fazlası olur. Tamsayı anahtar yoksa 0 (sıfır) olur.
<?php
$dizi = array(76 => "a", 8 => "b", "c", "d", 12 => "e");
// şuna eşittir
$dizi = array(76 => "a", 8 => "b", 77 => "c", 78 => "d", 12 => "e");
?>
Boş köşeli parantezler kullanılarak -yani anahtar belirtmeden- diziye yeni değerler eklenebilir.
<?php
$dizi = array(76 => "a", 8 => "b", 77 => "c", 78 => "d", 12 => "e");
$dizi[] = "f"; // 79 => "f"
$dizi[] = "g"; // 80 => "g"
$dizi[64] = "h"; // 64 => "h" burada anahtar da belirtildi
?>
Boş köşeli parantezler kullanılarak yeni bir dizi de oluşturulabilir.
<?php
$dizi[] = "a"; // dizi oluştu
var_dump($dizi); // array(1) { [0]=> string(1) "a" }
// bu şuna eşittir
$dizi = array("a");
?>
Dizi indisi olarak değişken belirtilebilir.
<?php
$dizi = array("a", "b", "c");
$a = 2;
echo $dizi[$a]; // c çıktılar
?>
İndis olarak sabitler de kullanılabilir.
<?php
define("renk", "kırmızı");
$dizi = array("kırmızı" => "elma", "turuncu" => "portakal");
echo $dizi[renk];
?>
Çıktısı:
elma
Burada olduğu gibi indis olarak bir sabit verilirse PHP yorumlayıcısı o isimde bir sabit arar. Bulduğu sabitin değerinin, dizi içinde işaret ettiği değeri bulur. Örnekte renk isminde ve kırmızı değerli bir sabit tanımlandı. Alt satırda ise kırmızı anahtarının elma, turuncu anahtarının portakal değerini işaret ettiği bir dizi tanımı var. Son satırda ise echo deyimine sabitin ismi -yani renk- indis olarak veriliyor. Yani aslında echo $dizi["kırmızı"] denmiş oluyor. İlgili olarak bkz: Sabitler
$dizi[renk] ile $dizi["renk"] aynı şey değildir. $dizi["renk"] belirtiminde herhangi bir sabit aranmaz. $dizinin içinde "renk" anahtarlı bir değer aranır.
Stringlerin karakterlerine de dizilerde olduğu gibi erişilebilir.
<?php
$mekan = "Vikikitap";
echo $mekan[0]; // V çıktılar
echo $mekan[3]; // i çıktılar
$mekan[0] = "W"; // 0. indisteki karakter "W" yapıldı
echo $mekan; // Wikikitap çıktılar
?>
Stringler ile dizilerin benzeşen tek yanı budur.
Gönderimli atama değiştir
Dizilerde gönderimli atama yapılabilir.
<?php
$dizi1 = array("a", "b", "c");
$dizi2 =& $dizi1; // gönderimli atama
$dizi1[] = "d"; // $dizi1'ye yeni değer eklendi. bundan $dizi2 de etkilenir.
var_dump($dizi1, $dizi2);
?>
Çıktısı:
array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" [3]=> string(1) "d" } array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [2]=> string(1) "c" [3]=> string(1) "d" }
İlgili olarak bkz: Değişkenlerde gönderimli atama
Dizi işlevleri değiştir
is_array() değiştir
Değişkenin dizi olup olmadığına bakar ve mantıksal değer döndürür.
<?php
$dizi = array("a", "b", "c");
var_dump(is_array($dizi)); // bool(true) çıktılar
$a = 23;
var_dump(is_array($a)); // bool(false) çıktılar
?>
unset() değiştir
unset() işlevi, değişkenlerle olduğu gibi dizilerle de kullanılabilir.
<?php
$dizi = array("a", "b", "c");
unset($dizi[1]); // 1. indisteki eleman silindi
var_dump($dizi);
?>
Çıktısı:
array(2) { [0]=> string(1) "a" [2]=> string(1) "c" }
<?php
$dizi = array("a", "b", "c");
unset($dizi); // $dizi komple silindi
var_dump($dizi); // NULL çıktılar. aynı zamanda bir de "tanımsız değişken" uyarısı çıktılanır
?>
count() değiştir
Bir dizinin eleman sayısını döndürür.
<?php
$dizi = array("a", "b", "c");
echo count($dizi); // 3 çıktılar
?>
Çok boyutlu dizilerde count() kullanımı:
<?php
$dizi = array(7 => array("a", "b", "c"));
echo count($dizi); // 1 çıktılar
echo count($dizi[7]); // 3 çıktılar
?>
range() değiştir
Belli bir aralıkta tamsayı değerlerden oluşan dizi meydana getirir.
<?php
$dizi = range(0, 10);
var_dump($dizi);
?>
Çıktısı:
array(11) { [0]=> int(0) [1]=> int(1) [2]=> int(2) [3]=> int(3) [4]=> int(4) [5]=> int(5) [6]=> int(6) [7]=> int(7) [8]=> int(8) [9]=> int(9) [10]=> int(10) }
Üçüncü parametre olarak artış miktarı belirtilebilir.
<?php
$dizi = range(0, 30, 5); // otuza kadar beşer beşer
var_dump($dizi);
?>
Çıktısı:
array(7) { [0]=> int(0) [1]=> int(5) [2]=> int(10) [3]=> int(15) [4]=> int(20) [5]=> int(25) [6]=> int(30) }
list() değiştir
Dizi değerlerini, değişkenlere atar.
<?php
$dizi = array("a", "b", "c");
list($char1, $char2, $char3) = $dizi;
echo $char1; // a çıktılar
echo $char2; // b çıktılar
echo $char3; // c çıktılar
?>
Başka bir örnek:
<?php
$dizi = array("a", "b", "c");
list($char1, $char2) = $dizi;
echo $char1; // a çıktılar
echo $char2; // b çıktılar
// "c" alınmadı
?>
list() işlevi, çok boyutlu dizilerle de çalışır.
<?php
$dizi = array("a", "b", array("c", "d"));
list($char1, $char2, list($char3, $char4)) = $dizi;
echo $char1; // a çıktılar
echo $char2; // b çıktılar
echo $char3; // c çıktılar
echo $char4; // d çıktılar
?>
Bu işlev yalnızca integer anahtarlı dizilerle çalışır.
<?php
$dizi = array("char" => "a", "sayı" => 1);
list($a, $b) = $dizi; // hatalı. $dizi'nin indisleri integer değil
?>
array_key_exists() değiştir
Bir anahtar dizide var mı diye bakar ve mantıksal bir değer döndürür.
<?php
$dizi = array("gün" => "pazartesi", "saat" => "17.00");
var_dump(array_key_exists("gün", $dizi)); // bool(true) çıktılar
var_dump(array_key_exists("mekan", $dizi)); // bool(false) çıktılar
?>
array_keys() değiştir
Bir dizideki anahtarları döndürür.
<?php
$dizi = array("gün" => "pazartesi", "saat" => "17.00");
var_dump(array_keys($dizi));
?>
Çıktısı:
array(2) { [0]=> string(3) "gün" [1]=> string(4) "saat" }
array_keys() işlevine dizinin ismi dışında parametre olarak bir değer de verilebilir. Bu verilen değer dizide varsa, ilgili anahtarlar döner.
<?php
$dizi = array("a", "b", "c", "a", "a");
var_dump(array_keys($dizi, "a"));
?>
Çıktısı:
array(3) { [0]=> int(0) [1]=> int(3) [2]=> int(4) }
array_values() değiştir
Dizideki değerleri döndürür.
<?php
$sehirler = array(6 => "Ankara", 34 => "İstanbul", 35 => "İzmir");
$degerler = array_values($sehirler);
var_dump($degerler);
?>
Çıktısı:
array(3) { [0]=> string(6) "Ankara" [1]=> string(8) "İstanbul" [2]=> string(5) "İzmir" }
array_pop() değiştir
Dizinin sonundan bir eleman siler.
<?php
$dizi = array("a", "b", "c");
array_pop($dizi);
var_dump($dizi);
?>
Çıktısı:
array(2) { [0]=> string(1) "a" [1]=> string(1) "b" }
array_rand() değiştir
Diziden rastgele seçilen değerlerin anahtarlarını döndürür.
<?php
$dizi = array("a", "b", "c", "d", "e");
$sec = array_rand($dizi, 2); // $dizi'den rastgele 2 değerin anahtarı alınıyor ve $sec dizisi oluşuyor
var_dump($sec);
?>
Çıktısı şöyle olabilir:
array(2) { [0]=> int(0) [1]=> int(2) }
Görüldüğü gibi $dizi dizisinde 0 ve 2 anahtarlarında tutulan değerler seçilmiş.
array_count_values() değiştir
Dizideki her bir değerin sayısını döndürür. Değerler, oluşan yeni dizide anahtar durumuna gelir.
<?php
$dizi = array("a", "a", 23, "b", 46, "a", 46);
var_dump(array_count_values($dizi));
?>
Çıktısı:
array(4) { ["a"]=> int(3) [23]=> int(1) ["b"]=> int(1) [46]=> int(2) }
array_shift() değiştir
Dizinin başından bir elemanı siler ve o elemanın değerini döndürür.
<?php
$dizi = array("a", "b", "c", "d", "e");
$sec = array_shift($dizi); // $sec = "a"
var_dump($dizi);
?>
Dizinin son hali:
array(4) { [0]=> string(1) "b" [1]=> string(1) "c" [2]=> string(1) "d" [3]=> string(1) "e" }
array_shift() ile eleman silindiği zaman, dizi yeniden indislenir. Yeniden indisleme esnasında string anahtarlar aynen bırakılır, integer anahtarlar 0′dan başlanarak yeniden indislenir.
<?php
$dizi = array(3 => "a", 14 => "b", 5 => "c", 8 => "d", 16 => "e");
// dizinin bilgilerini çıktılayalım
var_dump($dizi);
?>
Çıktısı:
array(5) { [3]=> string(1) "a" [14]=> string(1) "b" [5]=> string(1) "c" [8]=> string(1) "d" [16]=> string(1) "e" }
Şimdi array_shift() kullanalım ve dizi bilgilerine tekrar bakalım:
<?php
$dizi = array(3 => "a", 14 => "b", 5 => "c", 8 => "d", 16 => "e");
$sec = array_shift($dizi); // $sec = "a"
var_dump($dizi); // $dizi bilgilerini çıktılayalım
?>
Çıktısı:
array(4) { [0]=> string(1) "b" [1]=> string(1) "c" [2]=> string(1) "d" [3]=> string(1) "e" }
Görüldüğü gibi dizi yeninden indislendi. Bir önceki çıktıyla karşılaştırınız.
array_unshift() değiştir
Dizinin ön kısmına değer ekler.
<?php
$wikimedia = array("Wikibooks", "Wikisource");
array_unshift($wikimedia, "Wikipedia", "Wikiquote");
var_dump($wikimedia);
?>
Çıktısı:
array(4) { [0]=> string(9) "Wikipedia" [1]=> string(9) "Wikiquote" [2]=> string(9) "Wikibooks" [3]=> string(10) "Wikisource" }
array_search() değiştir
Bir değeri bir dizi içinde arar, bulursa değerin anahtarını; aksi durumda false döndürür.
<?php
$dizi = array("a", "b", "d");
var_dump(array_search("b", $dizi)); // int(1) çıktılar
var_dump(array_search("c", $dizi)); // bool(false) çıktılar
?>
array_search() işlevi, üçüncü parametre olarak boolean bir değer de alır. Bu değer, karşılaştırma esnasında türlerin de dikkate alınmasını sağlar. Örneğin:
<?php
$dizi = array("a", "b", "10");
var_dump(array_search(10, $dizi)); // int(2) çıktılar
// şimdi türleri de karşılaştıralım
var_dump(array_search(10, $dizi, true)); // bool(false) çıktılar
?>
İlgili olarak bkz: Veri türleri ve Tür dönüşümü
array_sum() değiştir
Bir dizideki değerlerin toplamını hesaplar.
<?php
$dizi = array(3, 64, 646, 7565);
echo array_sum($dizi); // 8278 çıktılar
?>
array_product() değiştir
Bir dizideki değerlerin çarpımını hesaplar.
<?php
$dizi = array(3, 64, 646);
echo array_product($dizi); // 124032 çıktılar
?>
shuffle() değiştir
Dizinin elemanlarını karıştırır.
<?php
$dizi = array(1, "a", 2, 4, "f");
shuffle($dizi);
var_dump($dizi);
?>
Örnek çıktı:
array(5) { [0]=> string(1) "f" [1]=> string(1) "a" [2]=> int(2) [3]=> int(1) [4]=> int(4) }
array_chunk() değiştir
Diziyi parçalara böler.
<?php
$dizi = array("a", "b", "c", "d", "e");
$bol = array_chunk($dizi, 2); // ikişer bölünüyor
var_dump($bol); // çıktılanıyor
?>
Çıktısı:
array(3) { [0]=> array(2) { [0]=> string(1) "a" [1]=> string(1) "b" } [1]=> array(2) { [0]=> string(1) "c" [1]=> string(1) "d" } [2]=> array(1) { [0]=> string(1) "e" } }
Üçüncü parametre olarak true verilirse değerlerin anahtarları korunur.
<?php
$dizi = array("a", "b", "c", "d", "e");
$bol = array_chunk($dizi, 2, true); // ikişer bölünüyor ve anahtarlar korunuyor
var_dump($bol);
?>
Çıktısı:
array(3) { [0]=> array(2) { [0]=> string(1) "a" [1]=> string(1) "b" } [1]=> array(2) { [2]=> string(1) "c" [3]=> string(1) "d" } [2]=> array(1) { [4]=> string(1) "e" } }
Görüldüğü gibi değerler, anahtarları korunarak bölündü. Bir önceki çıktıyla karşılaştırınız.
array_combine() değiştir
Anahtarların tutulduğu bir diziyle, değerlerin tutulduğu bir diziyi anahtar => değer ilişkisiyle birleştirir.
<?php
$kita = array("Asya", "Afrika", "Amerika");
$ulke = array("Çin", "Mısır", "Meksika");
$dizi = array_combine($kita, $ulke);
var_dump($dizi);
?>
Çıktısı:
array(3) { ["Asya"]=> string(3) "Çin" ["Afrika"]=> string(5) "Mısır" ["Amerika"]=> string(7) "Meksika" }
array_fill() değiştir
Diziye değer doldurur.
<?php
$dizi = array();
$dizi = array_fill(3, 4, "a"); // $dizi'ye 3.indisten başlayarak 4 adet "a" ekle
var_dump($dizi);
?>
Çıktısı:
array(4) { [3]=> string(1) "a" [4]=> string(1) "a" [5]=> string(1) "a" [6]=> string(1) "a" }
array_fill_keys() değiştir
Belirtilen anahtarları değerle doldurur ve bir dizi döndürür.
<?php
$anahtar = array(3, "anahtar", 12, "başka anahtar", "son anahtar");
$dizi = array_fill_keys($anahtar, "a");
var_dump($dizi);
?>
Çıktısı:
array(5) { [3]=> string(1) "a" ["anahtar"]=> string(1) "a" [12]=> string(1) "a" ["başka anahtar"]=> string(1) "a" ["son anahtar"]=> string(1) "a" }
array_flip() değiştir
Anahtarlarla değerlerin yerini değiştirir.
<?php
$dizi = array("Asya" => "Çin", "Afrika" => "Mısır", "Amerika" => "Meksika");
$dizi = array_flip($dizi);
var_dump($dizi);
?>
Çıktısı:
array(3) { ["Çin"]=> string(4) "Asya" ["Mısır"]=> string(6) "Afrika" ["Meksika"]=> string(7) "Amerika" }
array_push() değiştir
Dizinin sonuna eleman ekler.
<?php
$dizi = array("Avrupa", "Asya", "Afrika");
array_push($dizi, "Antarktika", "Amerika");
var_dump($dizi);
?>
Çıktısı:
array(5) { [0]=> string(6) "Avrupa" [1]=> string(4) "Asya" [2]=> string(6) "Afrika" [3]=> string(10) "Antarktika" [4]=> string(7) "Amerika" }
array_slice() değiştir
Dizinin belli bir bölümünü döndürür.
<?php
$dizi = array("a", "b", "c", "d", "e", "f", "g", "h");
var_dump(array_slice($dizi, 4)); // 4. indisten başlanarak dizinin sonuna kadar alınıyor
?>
Çıktısı:
array(4) { [0]=> string(1) "e" [1]=> string(1) "f" [2]=> string(1) "g" [3]=> string(1) "h" }
Üçüncü parametre olarak alınacak değer sayısı da belirtilebilir.
<?php
$dizi = array("a", "b", "c", "d", "e", "f", "g", "h");
var_dump(array_slice($dizi, 4, 2)); // 4. indisten başlanarak 2 eleman alınıyor
?>
Çıktısı:
array(2) { [0]=> string(1) "e" [1]=> string(1) "f" }
Dördüncü parametre olarak true belirtilirse, değerler anahtarlarıyla birlikte alınır.
<?php
$dizi = array("a", "b", "c", "d", "e", "f", "g", "h");
var_dump(array_slice($dizi, 4, 2, true));
?>
Çıktısı:
array(2) { [4]=> string(1) "e" [5]=> string(1) "f" }
array_unique() değiştir
Tekrarlanan değerleri siler.
<?php
$dizi = array("a", "c", "c", "a", "b");
$sil = array_unique($dizi);
var_dump($sil);
?>
Çıktısı:
array(3) { [0]=> string(1) "a" [1]=> string(1) "c" [4]=> string(1) "b" }
array_unique() işlevi isteğe bağlı ikinci bir parametre daha alır. SORT_REGULAR belirtilirse değerler, türleri değiştirilmeden karşılaştırılır. SORT_NUMERIC belirtildiğinde değerler sayısal olarak karşılaştırılır ve SORT_STRING belirtilirse karakter dizisi olarak karşılaştırılır.
<?php
$dizi = array("a", 10, "10");
var_dump(array_unique($dizi));
?>
Çıktısı: array(2) { [0]=> string(1) "a" [1]=> int(10) }
Yukarıdakini bir de şöyle deneyelim:
<?php
$dizi = array("a", 10, "10");
var_dump(array_unique($dizi, SORT_REGULAR));
?>
Çıktısı:
array(3) { [0]=> string(1) "a" [1]=> int(10) [2]=> string(2) "10" }
Burada SORT_REGULAR belirtildiğinden tür dönüşümü yapılmadı ve tekrarlanan değer bulunamadı. İlgili olarak bkz: Veri türleri ve Tür dönüşümü
current() değiştir
Göstericinin o an işaret ettiği elemanı döndürür.
next() değiştir
Göstericiyi bir sonraki elemana kaydırır.
prev() değiştir
Göstericiyi bir önceki elemana kaydırır.
end() değiştir
Göstericiyi son elemana kaydırır.
key() değiştir
Göstericinin o an işaret ettiği değerin anahtarını döndürür.
each() değiştir
Göstericinin o an işaret ettiği anahtar - değer çiftini dizi olarak döndürür ve göstericiyi bir sonrakine kaydırır. PHP 7.2.0. sürümünden itibaren bu özellik kaldırılmıştır.
reset() değiştir
Göstericiyi ilk elemana kaydırır.
Tüm gösterici işlevlerin kullanıldığı bir örnek:
<?php
$dizi = array("a", "b", "c", "d", "e");
echo current($dizi); // a çıktılar
echo next($dizi); // b çıktılar
var_dump(each($dizi)); // mevcut anahtar değer çifti bir dizi olarak döner. gösterici bir sonrakine kayar
/*
array(4) {
[1]=>
string(1) "b"
["value"]=>
string(1) "b"
[0]=>
int(1)
["key"]=>
int(1)
}
*/
echo current($dizi); // c çıktılar
echo end($dizi); // e çıktılar
echo prev($dizi); // d çıktılar
echo key($dizi); // 3 çıktılar
echo reset($dizi); // a çıktılar
?>