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