please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
PHP'de bir dizi aslında sıralı bir eşlemdir. Bir eşlem, değerleri anahtarlarla ilişkilendiren bir veri türüdür. Bu veri türü farklı kullanım amaçları için en iyilenebilir; bir dizi, bir yöneysel liste, bir isim-değer çiftleri tablosu, bir sözlük, bir nesne listesi, yığıt, kuyruk ve daha bir sürü başka şey olarak ele alınabilir. Dizilerin değerleri, ağaçlar, diziler ve hatta çok boyutlu diziler bile olabilir.
Tüm bu veri yapılarının açıklanması bu kılavuzun amacını aşar. Fakat, en azından her biri için birer örnek verilebilir. Bu konuda daha fazla bilgi edinmek için bu konuyla ilgili olarak yayımlanmış eserleri inceleyiniz.
Bir dizi array() işlevi kullanılarak belirtilebilir.
Bağımsız değişken olarak, birbirlerinden virgüllerle ayrılmış çok sayıda
anahtar =>
değer
çifti alabilir.
array( anahtar => değer, anahtar2 => değer2, anahtar3 => değer3, ... )
Son dizi elemanından sonraki virgül seçimliktir ve konmayabilir.
Bu genellikle tek satırlık dizilerde yapılır. Yani,
array(1, 2, )
yerine
array(1, 2)
yazmak tercih edilir. Diğer taraftan,
çok satırlı dizilerde yeni elemanların sona eklenmesini
kolaylaştırdığından sondaki virgülün konulması tercih edilir.
Bilginize:
array()
yerine[]
kullanılan kısa bir dizi sözdizimi de vardır.
Örnek 1 - Basit bir dizi
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
);
// Kısa dizi sözdizimi kullanımı
$array = [
"foo" => "bar",
"bar" => "foo",
];
?>
Bir anahtar ya int ya da string türünde olabilir. Bir değer ise herhangi bir türde olabilir.
Ek olarak anahtar için şu tür çarpıtmaları oluşur:
+
imi ile başlamadıkça int türüne çarpıtılır. Yani,
"8"
anahtarı aslında 8
olarak
saklanır. Diğer yandan, "08"
geçerli bir onluk
tamsayı olmadığından tür çarpıtmasına uğramaz.
8.7
anahtarı aslında
8
olarak saklanır.
true
anahtarı 1
,
false
anahtarı da 0
olarak saklanır.
null
aslında ""
olarak saklanır.
Illegal offset
type
uyarısına sebep olur.
Dizi bildiriminde çok sayıda eleman aynı anahtarı kullanıyorsa, diğerleri birbirlerinin üzerine yazıyormuşçasına sadece son eleman kullanılır.
Örnek 2 - Tür Çarpıtma ve Üzerine Yazma örneği
<?php
$array = array(
1 => "a",
"1" => "b",
1.5 => "c",
true => "d",
);
var_dump($array);
?>
Yukarıdaki örneğin çıktısı:
array(1) { [1]=> string(1) "d" }
Yukarıdaki örnekte tüm anahtarlar 1
'e çarpıtıldığından
her yeni eleman değeri bir öncekinin üzerie yazılır ve dizide sadece son
atanan değer kalır.
PHP indisli ve ilişkisel diziler arasında bir ayrım yapmadığından int ve string türündeki anahtarlar aynı anda bulunabilir.
Örnek 3 - Karışık int ve string anahtarlar
<?php
dizi = array(
"foo" => "bar",
"bar" => "foo",
100 => -100,
-100 => 100,
);
var_dump($dizi);
Yukarıdaki örneğin çıktısı:
array(4) { ["foo"]=> string(3) "bar" ["bar"]=> string(3) "foo" [100]=> int(-100) [-100]=> int(100) }
anahtar belirtmek isteğe bağlıdır. Bir anahtar belirtmeksizin bir değer atanıyorsa bu değer, mevcut int anahtarların en büyüğüne bir eklenerek elde edilen int anahtarlı elemana atanır.
Örnek 4 - Anahtarsız indisli diziler
<?php
$dizi = array("foo", "bar", "hello", "world");
var_dump($dizi);
?>
Yukarıdaki örneğin çıktısı:
array(4) { [0]=> string(3) "foo" [1]=> string(3) "bar" [2]=> string(5) "hello" [3]=> string(5) "world" }
Bazı değerlere anahtar belirtirken bazılarına belirtmemek mümkündür.
Örnek 5 - Tüm elemanlar için birer anahtar belirtilmeyebilir
<?php
$dizi = array(
"a",
"b",
6 => "c",
"d",
);
var_dump($dizi);
?>
Yukarıdaki örneğin çıktısı:
array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [6]=> string(1) "c" [7]=> string(1) "d" }
Gördüğünüz gibi son değer "d"
, 7
anahtarına atanmıştı. Bunun sebebi önceki en büyük tamsayılı indisin
6
olmasıdır.
Örnek 6 - Karmaşık Tür Çarpıtma ve Geçersizleştirme örneği
Bu örnekte anahtarlar üzerinde tür çarpıtmanın ve öğelerin üzerine yazılmasının tüm çeşitleri gösterilmiştir.
<?php
$array = array(
1 => 'a',
'1' => 'b', // "a" değeri "b" ile geçersiz olur
1.5 => 'c', // "b" değeri "c" ile geçersiz olur
-1 => 'd',
'01' => 'e', // tamsayı dizesi olmadığından korunur
'1.5' => 'f', // tamsayı dizesi olmadığından korunur
true => 'g', // "c" değeri "g" ile geçersiz olur
false => 'h',
'' => 'i',
null => 'j', // "i" değeri "j" ile geçersiz olur
'k', // 2 anahtarına "k" değeri atanır, çünkü önceki en büyük tamsayı: 1
2 => 'l', // "k" değeri "l" ile geçersiz olur
);
var_dump($array);
?>
Yukarıdaki örneğin çıktısı:
array(7) { [1]=> string(1) "g" [-1]=> string(1) "d" ["01"]=> string(1) "e" ["1.5"]=> string(1) "f" [0]=> string(1) "h" [""]=> string(1) "j" [2]=> string(1) "l" }
Dizi elemanlarına array[anahtar]
sözdizimi
kullanılarak erişilir.
Örnek 7 - Dizi elemenlarına erişim
<?php
$dizi = array(
"foo" => "bar",
42 => 24,
"çok" => array(
"boyutlu" => array(
"dizi" => "foo"
)
)
);
var_dump($dizi["foo"]);
var_dump($dizi[42]);
var_dump($dizi["çok"]["boyutlu"]["dizi"]);
?>
Yukarıdaki örneğin çıktısı:
string(3) "bar" int(24) string(3) "foo"
Bilginize:
PHP 8.0.0 öncesinde, dizilere erişmek için köşeli ayraçların yerine kaşlı ayraçlar da kullanılabilirdi (yani, yukarıdaki örnekte
$dizi[42]
ve$dizi{42}
aynı şeyi yapar). Dizilere erişirken köşeli ayraçların yerine kaşlı ayraç kullanımı PHP 7.4.0 itibariyle önerilmemekte olup PHP 8.0.0 ve sonrasında desteklenmemektedir.
Örnek 8 - Dizi başvurusu
<?php
function getArray() {
return array(1, 2, 3);
}
$ikinciEleman = getArray()[1];
?>
Bilginize:
Atanmamış bir dizi elemanına erişme çabası, atanmamış bir değişkene erişme çabasıyla aynı sonucu verir:
E_WARNING
seviyesinde (PHP 8.0.0 öncesindeE_NOTICE
seviyesinde) bir hata çıktılanır ve sonuçnull
olur.
Bilginize:
string türünde olmayan bir sayıl değeri başka bir diziye atama işlemi sessiz bir
null
atamasıyla sonuçlanır. PHP 7.4.0 öncesinde, bir hata iletisi çıktılanmazdı. PHP 7.4.0 ve sonrasında, birE_NOTICE
çıktılanırken, PHP 8.0.0 ve sonrasında, birE_WARNING
çıktılanır.
Mevcut bir dizi, doğrudan değer atamak suretiyle değiştirilebilir.
Bu işlem, diziye köşeli ayraçlar arasında belirtilen bir anahtar
kullanılarak değer atamak biçeminde yapılır. Diziye yeni bir değer atamak
için köşeli ayraçlar boş olarak ([]
) belirtilebilir.
$dizi[anahtar] = değer; $dizi[] = değer; // anahtar sadece int veya string türünde olabilir. // değer herhangi bir türde olabilir.
$dizi mevcut değilse, değer olarak null
veya false
atanmışsa dizi oluşturulur. Yani bu işlem yeni bir dizi oluşturmak için
kullanılabilir. Ancak bunun yapılması önerilmez. Çünkü
$dizi bir dize değer içeriyor olabileceğinden bu
değer yerinde kalır ve []
aslında bir
dize erişim işleci
haline gelir. Bir değişkeni doğrudan atamayla ilkendirmek daha iyidir.
Bilginize: PHP 7.1.0 ve sonrasında, boş indis işlecini bir dizeye uygulamak ölümcül hataya sebep olur. Evvelce, dize sessizce bir diziye dönüştürülürdü.
Bilginize: PHP 8.1.0 itibariyle,
false
değerden yeni bir dizi oluşturulması önerilmemektedir.null
ve tanımsız değerlerden yeni bir dizi oluşturulması ise hala mümkündür.
Anahtar kullanarak bir elemana yeni bir değer atamak bu elemanın değerinin değiştirilmesi demektir. Belli bir anahtar/değer çiftini silmek için unset() işlevini kullanın.
<?php
$dizi = array(5 => 1, 12 => 2);
$dizi[] = 56; // Betiğin bu noktasında bu atama
// $dizi[13] = 56; ile aynıdır
$dizi["x"] = 42; // "x" anahtarlı yeni bir eleman atar
unset($dizi[5]); // Elemanı diziden siler
unset($dizi); // Dizinin tamamını siler
?>
Bilginize:
Yukarıda değinildiği gibi, bir diziye yeni değeri bir anahtar belirtmeden atamak, mevcut en büyük int indisine bir eklenerek elde edilen anahtar (en azından
0
değil) kullanılarak gerçekleşir. Dizide henüz bir int indis yoksa anahtar olarak0
(sıfır) kullanılır.Dikkat ederseniz, dizinin mevcut olması halinde, yeni bir değer atamak için en büyük tamsayı indisli anahtar kullanmaya gerek yoktur. Buna sadece dizi yeniden indislenmişse gerek olabilir. Aşağıdaki örnek anlatımı pekiştirecektir:
<?php
// Basit bir dizi oluşturalım.
$dizi = array(1, 2, 3, 4, 5);
print_r($dizi);
// Şimdi bütün elemanları silelim ama dizi kalsın:
foreach ($dizi as $i => $value) {
unset($dizi[$i]);
}
print_r($dizi);
// Bir eleman ekleyelim (dikkat: yeni anahtar 0 değil 5 olacak!)
$dizi[] = 6;
print_r($dizi);
// Yeniden indisleyelim:
$dizi = array_values($dizi);
$dizi[] = 7;
print_r($dizi);
?>Yukarıdaki örneğin çıktısı:
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )
Diziler, []
(PHP 7.1.0 ve sonrası) veya
list() dil yapıları kullanılarak yeniden
yapılandırılabilir. Bu dil yapıları bir dizinin içindeki farklı
değişkenleri yeniden yapılandırmakta da kullanılabilir.
<?php
$source_array = ['foo', 'bar', 'baz'];
[$foo, $bar, $baz] = $source_array;
echo $foo; // "foo" basar
echo $bar; // "bar" basar
echo $baz; // "baz" basar
?>
Dizilerin yeniden yapılandırmasında çok boyutlu bir dizi, foreach kullanılarak yinelemeli olarak yeniden yapılandırılabilir.
<?php
$source_array = [
[1, 'John'],
[2, 'Jane'],
];
foreach ($source_array as [$id, $name]) {
// $id ve $name ile ilgili yinelemeler
}
?>
Bir değişken sağlanmamış dizi elemanları yok sayılır. Yeniden
yapılandırma daima 0
. indisten başlar.
<?php
$source_array = ['foo', 'bar', 'baz'];
// 2. indisteki elemana $baz ile atama
[, , $baz] = $source_array;
echo $baz; // "baz" basar
?>
PHP 7.1.0 ve sonrasında, ilişkisel diziler de yeniden yapılandırılabilmektedir. Ayrıca, sayısal indisli dizilerde indisler doğrudan belirtilebildiğinden doğru elemanın daha kolay belirlenebilmesini de sağlar.
<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];
// 'baz' indisli elemana $üç değişkenini atamak
['baz' => $üç] = $source_array;
echo $üç; // 3 basar
$source_array = ['foo', 'bar', 'baz'];
// 2. indisteki elemana $baz değişkenini atamak
[2 => $baz] = $source_array;
echo $baz; // "baz" basar
?>
Dizi yeniden yapılandırması iki değişkeni kolayca takaslamak için de kullanılabilir.
<?php
$a = 1;
$b = 2;
[$b, $a] = [$a, $b];
echo $a; // 2 basar
echo $b; // 1 basar
?>
Bilginize:
Atamalarda çoğaltma işleci (
...
) desteklenmemektedir.
Bilginize:
Tanımlanmamış bir dizi anahtarına erişmeye çalışmak, diğer tanımsız değişkenlere erişmekle aynıdır:
E_WARNING
seviyesinde (PHP 8.0.0 öncesindeE_NOTICE
seviyesinde) bir hata çıktılanır ve sonuçnull
olur.
Dizilerle çalışmak için kullanılabilecek işlevlerin tamamını Dizi İşlevleri bölümünde bulabilirsiniz.
Bilginize:
unset() işlevi bir diziden anahtar silmeyi mümkün kılar. Ama bu silme işlemi dizinin yeniden indislenmesiyle sonuçlanmaz. Eğer silme işleminin gerçekten "sil ve kaydır" yapmasını istiyorsanız, anahtarı sildikten sonra array_values() işlevini kullanarak diziyi yeniden indislemelisiniz.
<?php
$a = array(1 => 'bir', 2 => 'iki', 3 => 'üç');
unset($a[2]);
/* Bu silme işlemi dizi şöyle tanımlanmış gibi sonuçlanacaktır:
$a = array(1 => 'bir', 3 => 'üç');
böyle DEĞİL:
$a = array(1 => 'bir', 2 =>'üç');
*/
$b = array_values($a);
// $b artık array(0 => 'bir', 1 =>'üç') olmuştur
?>
foreach denetim yapısı özellikle diziler için tasarlanmıştır. Diziler üzerinde hareket edilmesini kolaylaştırır.
$foo[bar]
niye yanlıştır?
Bir dize sayıllı indis daima tırnak içinde kullanılır. Örneğin,
$foo[bar]
yanlışken $foo['bar']
doğrudur. Ama, neden? Eski betiklerde şu sözdizimine sıkça rastlanır:
<?php
$foo[bar] = 'düşman';
echo $foo[bar];
// ve saire
?>
Bu yanlıştır, ama çalışır. Bunun sebebi, bu kodun bir dizeden ziyade
tanımsız bir sabit (bar
) belirtiyor olmasıdır. PHP
ilerde şans eseri ismi aynı zamanda değeri olan bir sabit tanımlayabilir.
PHP otomatik olarak bir çıplak dizeyi (tırnak
içine alınmamış bir dizeyi), bu çıplak dizeyi içeren bir dizeye
dönüştüreceğinden bu çalışır. Örneğin, bar
isminde
tanımlanmış bir sabit yoksa, PHP bar
sabitine
'bar'
dizesini yerleştirecek ve bunu kullanacaktır.
Son çare olarak, tanımlanmamış bir sabitin çıplak bir dize olarak işleme
sokulması E_NOTICE
seviyesinde bir hata
çıktılanmasına sebep olur. Bu, PHP 7.2.0'dan itibaren kullanımdan
kaldırılmış olup E_WARNING
seviyesinde bir hataya
sebep olur. PHP 8.0.0 ve sonrasında, bu durumda, bir
Error istisnası yavrulanmaktadır.
Bilginize: Bu, "anahtarlar daima tırnak içine alınır" demek değildir. sabitleri ve değişkenleri tek tırnak içine almayın, çünkü o zaman yorumlanmazlar.
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Basit bir dizi:
$dizi = array(1, 2);
$sayaç = count($dizi);
for ($i = 0; $i < $sayaç; $i++) {
echo "\n$i indisi inceleniyor: \n";
echo "Kötü: " . $dizi['$i'] . "\n";
echo "İyi: " . $dizi[$i] . "\n";
echo "Kötü: {$dizi['$i']}\n";
echo "İyi: {$dizi[$i]}\n";
}
?>Yukarıdaki örneğin çıktısı:
0 indisi inceleniyor: Notice: Undefined index: $i in /dosya/yolu/betik.php on line 10 Kötü: İyi: 1 Notice: Undefined index: $i in /dosya/yolu/betik.php on line 12 Kötü: İyi: 1 1 indisi inceleniyor: Notice: Undefined index: $i in /dosya/yolu/betik.php on line 10 Kötü: İyi: 2 Notice: Undefined index: $i in /dosya/yolu/betik.php on line 12 Kötü: İyi: 2
Bu davranışla ilgili diğer örnekler:
<?php
// Tüm hataları görelim
error_reporting(E_ALL);
$dizi = array('meyve' => 'elma', 'sebze' => 'havuç');
// Doğru
print $dizi['meyve']; // elma
print $dizi['sebze']; // havuç
// Yanlış. Bu çalışır, fakat meyve tanımlanmamış bir sabit
// olmadığından E_NOTICE seviyesinde bir PHP hatası oluşur
//
// Notice: Use of undefined constant meyve - assumed 'meyve'...
print $dizi[meyve]; // elma
// Bu, neler olup bittiğini gösteren bir sabit tanımlar;
// 'sebze' değeri meyve sabitine atanır.
define('meyve', 'sebze');
// Şimdi farkı görelim
print $dizi['meyve']; // elma
print $dizi[meyve]; // havuç
// Bir dize içinde olduğundan bu da doğrudur.
// Dizge içinde kalan sabitler, sabit olarak ele alınmazlar;
// dolayısıyla burada bir E_NOTICE oluşmaz.
print "Turfanda $dizi[meyve]"; // Turfanda elma
// Bir istisna: Dizge içinde kaşlı ayraç içine alınmış
// sabitler, sabit olarak ele alınırlar.
print "Turfanda {$dizi[meyve]}"; // Turfanda havuç
print "Turfanda {$dizi['meyve']}"; // Turfanda elma
// Bu çalışmaz ve şöyle bir çözümleme hatasıyla sonuçlanır:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Bu, dizeler içindeki süper küresellere de uygulanır.
print "Turfanda $dizi['meyve']";
print "Turfanda $_GET['foo']";
// Ard arda eklemek de bir seçenektir
print "Turfanda " . $dizi['meyve']; // Turfanda elma
?>
error_reporting yönergesine
E_NOTICE
seviyesinden hataları gösterecek bir atama
yapılırsa (örneğin, E_ALL
atanarak), böyle
kullanımlar hemen görünür duruma gelir. error_reporting yönergesinin
öntanımlı değeriyle E_NOTICE
seviyesinden hatalar
gösterilmez.
Sözdizimi bölümünde
değinildiği gibi, köşeli ayraçlar ('[
' ve
']
') içinde belirtilenlerin birer ifade olması
gerekir. Yani, aşağıdaki gibi bir kod çalışacaktır:
<?php
echo $dizi[birişlev($bar)];
?>
Bu, bir işlevin dönüş değerinin dizi indisi olarak kullanımına bir örnektir. PHP kendi sabitlerini de tanır:
<?php
$error_descriptions[E_ERROR] = "Ölümcül bir hata oluştu";
$error_descriptions[E_WARNING] = "PHP bir uyarı verdi";
$error_descriptions[E_NOTICE] = "Bu sadece bilgilendirici bir uyarı";
?>
E_ERROR
sabitinin de ilk örnekteki
bar
kadar geçerli bir betimleyici oluşuna dikkat
ediniz. Fakat, E_ERROR
eşittir 1
,
vb. olduğundan aşağıdaki örnek de aynı işi yapar:
<?php
$error_descriptions[1] = "Ölümcül bir hata oluştu";
$error_descriptions[2] = "PHP bir uyarı verdi";
$error_descriptions[8] = "Bu sadece bilgilendirici bir uyarı";
?>
Bilinmeyen bir gelecekte PHP ekibi başkalarının kodlarıyla çelişen bir
sabit, bir anahtar sözcük veya bir değişken eklemek isteyebilir.
Örneğin, empty
ve default
birer anahtar sözcük olduklarından bu amaçla
kullanılmaları yanlıştır.
Bilginize: Yinelemek gerekirse, çift tırnak imleri arasına alınmış bir dize, dizi indisini tırnak içine almadığından geçerlidir; yani,
"$foo[bar]"
geçeridir. Yukarıdaki örnekleri bu gözle tekrar inceleyin ve ayrıca dizelerin içinde değişken çözümleme bölümüne de bakın.
int, float, string,
bool veya resource türünde bir değeri
array türünde bir değere dönüştürme işlemi, sıfır indisli bir
elemana bu değerin atanması ile sonuçlanır. Başka bir deyişle,
(array) $sayılDeğer
ile
array($sayılDeğer)
arasında bir fark yoktur.
Bir object türü array türüne dönüştürme işlemi,
elemanları nesnenin üyeleri olan bir dizi ile sonuçlanır. Anahtarlar, bir
kaç istisnai durum dışında üyelerin isimleridir: Tamsayı özellikler
erişilebilir değildir; private
değişkenlerin önüne sınıf
isimleri getirilir; public
değişkenlerin önünde bir
'*' olur. Diğer taraftan, başlarına birşeyler eklenmiş böyle değişkenlerin
değerleri null
olur.
Veri türüne sahip
özellikler ilklendirilmemişse sessizce yok sayılır.
<?php
class A {
private $B;
protected $C;
public $D;
function __construct()
{
$this->{1} = null;
}
}
var_export((array) new A());
?>
Yukarıdaki örneğin çıktısı:
array ( '' . "\0" . 'A' . "\0" . 'B' => NULL, '' . "\0" . '*' . "\0" . 'C' => NULL, 'D' => NULL, 1 => NULL, )
Bu durum beklenmedik davranışlara yol açabilir:
<?php
class A {
private $A; // Bu '\0A\0A' haline gelir.
}
class B extends A {
private $A; // Bu '\0B\0A' haline gelir.
public $AA; // Bu 'AA' haline gelir.
}
var_dump((array) new B());
?>
Yukarıdaki örneğin çıktısı:
array(3) { ["BA"]=> NULL ["AA"]=> NULL ["AA"]=> NULL }
Bu örneğin çıktısı 'AA' isimli iki anahtar görüntülerse de onlardan birinin ismi aslında '\0A\0A''dır.
null
, bir diziye dönüştürülmek istenirse sonuç boş bir dizi olur.
Dizileri array_diff() işleviyle veya dizi işleçleri kullanılarak karşılaştırmak mümkündür.
...
ile öncelenmiş bir dizi dizinin tanımlanması sırasında
bulunduğu yerde genişletilir. Yalnızca
Traversable arayüzünü gerçekleyen diziler
genişletilebilir. ...
ile genişletme PHP 7.4.0 ve sonrasında
kullanılabilmektedir.
Defalarca genişletme yapmak ve ...
işlecinin önüne ve ardına
normal elemanları eklemek mümkündür:
Örnek 9 - Basit dizi genişletmesi
<?php
// Kısa dizi sözdizimi kullanarak.
// Ayrıca, array() sözdizimi da çalışır.
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; //[1, 2, 3]
$arr3 = [0, ...$arr1]; //[0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; //[1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; //[1, 2, 3, 1, 2, 3]
function getArr() {
return ['a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; //['a', 'b', 'c' => 'd']
?>
...
işleci ile bir diziyi genişletme işlemi
array_merge() işlevindeki gibi yapılır. Yani, sonraki
dizge anahtarlar öncekileri geçersiz kılarken tamsayı anahtarlar yeniden
sıralanır:
Örnek 10 - Yinelenen anahtarlarla dizi genişletme
<?php
// dizge anahtar
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]
// integer key
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// Burada özgün tamsayı anahtarlar korunmamıştır.
?>
Bilginize:
Dizge ya da tamsayı olmayan anahtarlar TypeError istisnasına yol açar. Böyle anahtarlar sadece Traversable nesnesi tarafından üretilebilir.
Bilginize:
PHP 8.1 öncesinde, dizge anahtarlı bir dizi genişletilmiyordu:
<?php
$arr1 = [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Ölümcül hata: Dizge anahtarlı diziler genişletilemez: example.php:5
$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5]
?>
PHP'nin array türü çok yeteneklidir. Bazı örnekler:
<?php
// Bu:
$a = array( 'renk' => 'kırmızı',
'lezzet' => 'tatlı',
'şekil' => 'yuvarlak',
'isim' => 'elma',
4 // anahtarı 0 olacaktır
);
$b = array('a', 'b', 'c');
// . . . buna tamamen eşdeğerdir:
$a = array();
$a['renk'] = 'kırmızı';
$a['lezzet'] = 'tatlı';
$a['şekil'] = 'yuvarlak';
$a['isim'] = 'elma';
$a[] = 4; // anahtarı 0 olacaktır
$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// Yukarıdaki kod çalıştırıldığında $a, array('renk' => 'kırmızı',
// 'lezzet' => 'tatlı', 'şekil' => 'yuvarlak', 'isim' => 'elma', 0 => 4)
// dizisiyle, $b ise array(0 => 'a', 1 => 'b', 2 => 'c') veya basitçe
// array('a', 'b', 'c') dizisiyle sonuçlanacaktır.
?>
Örnek 11 - array() kullanımı
<?php
// Özellik eşlemeli dizi
$map = array( 'sürüm' => 4,
'sistem' => 'Linux',
'dil' => 'english',
'kısaltma' => true
);
// tamamen sayısal anahtarlar
$dizi = array( 7,
8,
0,
156,
-10
);
// Bu, array(0 => 7, 1 => 8, ...) ile aynıdır
$geçişli = array( 10, // key = 0
5 => 6,
3 => 7,
'a' => 4,
11, // anahtar = 6 (en büyük tamsayı indis 5 idi)
'8' => 2, // anahtar = 8 (tamsayı!)
'02' => 77, // anahtar = '02'
0 => 12 // 10 değerinin üzerine 12 yazılacak
);
// boş dizi
$boş = array();
?>
Örnek 12 - Döngü içinde elemen değiştirme
<?php
$renkler = array('Turuncu', 'Pembe', 'Mor', 'Turkuaz');
foreach ($renkler as $renk) {
echo "$renk rengi sever misiniz?\n";
}
?>
Yukarıdaki örneğin çıktısı:
Turuncu rengi sever misiniz? Pembe rengi sever misiniz? Mor rengi sever misiniz? Turkuaz rengi sever misiniz?
Dizi değerleri gönderimli aktarıldıklarından dizi değerlerini doğrudan değiştirmek mümkündür. Fakat arada bazı şeyler yapmak gerekir:
Örnek 13 - Derlem
<?php
<?php
$renkler = array('Turuncu', 'Pembe', 'Mor', 'Turkuaz');
foreach ($renkler as &$renk) {
$renk = mb_strtoupper($renk);
}
unset($renk); /* Aşağıdaki atamalarda $renk son
dizi elemanını değiştirmesin */
print_r($renkler);
?>
Yukarıdaki örneğin çıktısı:
Array ( [0] => TURUNCU [1] => PEMBE [2] => MOR [3] => TURKUAZ )
Bu örnekte dizi indisleri 1'den başlatılmaktadır.
Örnek 14 - İndisi 1'den başlatmak
<?php
$ilkçeyrek = array(1 => 'Ocak', 'Şubat', 'Mart');
print_r($ilkçeyrek);
?>
Yukarıdaki örneğin çıktısı:
Array ( [1] => Ocak [2] => Şubat [3] => Mart )
Örnek 15 - Diziyi doldurmak
<?php
// bir diziyi bir dizin'in içeriği ile dolduralım
$tutamak = opendir('.');
while (false !== ($dosya = readdir($tutamak))) {
$dosyalar[] = $dosya;
}
closedir($tutamak);
?>
Diziler sıralıdır. Sıralama çeşitli sıralama işlevleri ile değiştirilebilir. Daha fazla bilgi için Dizi İşlevleri bölümüne bakınız. Bir dizinin eleman sayısını öğrenmek için count()işlevi kullanılabilir.
Örnek 16 - Dizi elemanlarının sıraya sokulması
<?php
sort($dosyalar);
print_r($dosyalar);
?>
Bir dizinin elemanlarına her türlü değer atanabileceğinden başka bir dizi de atanabilir. Böylece iç içe ve çok boyutlu dizilerin oluşturulması mümkün olur.
Örnek 17 - İç içe ve çok boyutlu diziler
<?php
$yemişler = array ( "yemişler" => array ( "a" => "iğde",
"b" => "badem",
"c" => "ceviz"
),
"sayılar" => array ( 1,
2,
3,
4,
5,
6
),
"yuvalar" => array ( "birinci",
5 => "ikinci",
"üçüncü"
)
);
// Yukarıdaki dizinin değerlerinin kullanıldığı bazı örnekler
echo $yemişler["yuvalar"][5]; // "ikinci" basar
echo $yemişler["meyveler"]["a"]; // "iğde" basar
unset($yemişler["yuvalar"][0]); // "birinci" silinir
// Yeni bir çok boyutlu dizi oluşturalım
$meyveler["elma"]["yeşil"] = "ekşi";
?>
Dizi atamaları daima değerleri kopyalamak şeklinde gerçekleşir. Bir diziyi gönderimli olarak kopyalamak için gönderim işleci kullanılır.
<?php
$dizi1 = array(2, 3);
$dizi2 = $dizi1;
$dizi2[] = 4; // $dizi2 değişti,
// $dizi1 hala array(2, 3)
$dizi3 = &$dizi1;
$dizi3[] = 4; // şimdi $dizi1 ve $dizi3 aynı
?>
please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
I think your first, main example is needlessly confusing, very confusing to newbies:
$array = array(
"foo" => "bar",
"bar" => "foo",
);
It should be removed.
For newbies:
An array index can be any string value, even a value that is also a value in the array.
The value of array["foo"] is "bar".
The value of array["bar"] is "foo"
The following expressions are both true:
$array["foo"] == "bar"
$array["bar"] == "foo"
"If you convert a NULL value to an array, you get an empty array."
This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.
<?php $values = search(...); ?>
Now you want to merge the array with another array. What do we do if $values is NULL? No problem:
<?php $combined = array_merge((array)$values, $other); ?>
Voila.
Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:
<html>
<body>
<?php
printf("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<input type="hidden" name="Windows3.1" value="Sux">
<input type="submit" value="Click" />
</form>
</body>
</html>
Once you click on the button, the page displays the following:
POST: Array ( [Windows3_1] => Sux )
Note that array value buckets are reference-safe, even through serialization.
<?php
$x='initial';
$test=array('A'=>&$x,'B'=>&$x);
$test=unserialize(serialize($test));
$test['A']='changed';
echo $test['B']; // Outputs "changed"
?>
This can be useful in some cases, for example saving RAM within complex structures.