PHP/Diziler

Diziler

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

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

is_array()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

Bir dizideki değerlerin toplamını hesaplar.

<?php
$dizi = array(3, 64, 646, 7565);
echo array_sum($dizi); // 8278 çıktılar
?>

array_product()

Bir dizideki değerlerin çarpımını hesaplar.

<?php
$dizi = array(3, 64, 646);
echo array_product($dizi); // 124032 çıktılar
?>

shuffle()

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()

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()

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()

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()

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()

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()

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()

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()

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()

Göstericinin o an işaret ettiği elemanı döndürür.

next()

Göstericiyi bir sonraki elemana kaydırır.

prev()

Göstericiyi bir önceki elemana kaydırır.

end()

Göstericiyi son elemana kaydırır.

key()

Göstericinin o an işaret ettiği değerin anahtarını döndürür.

each()

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()

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