Array, keyfi sayıda değeri tek bir değişkende saklayan bir veri yapısıdır. PHP’deki bir array aslında sıralı bir map’tir, burada map değerleri anahtarlarla ilişkilendiren bir türdür.
- $array = array(‘Value1’, ‘Value2’, ‘Value3’); // Anahtarlar varsayılan olarak 0, 1, 2, …,
- $array = array(‘Value1’, ‘Value2’, ); // İsteğe bağlı sondaki virgül
- $array = array(‘key1’ => ‘Value1’, ‘key2’ => ‘Value2’, ); // Açık anahtarlar
- $array = array(‘key1’ => ‘Value1’, ‘Value2’, ); // Array ( [‘key1’] => Value1 1 => ‘Value2’)
- $array = [‘key1’ => ‘Value1’, ‘key2’ => ‘Value2’, ]; // PHP 5.4+ kısayol
- $array[] = ‘ValueX’; // Dizinin sonuna ‘ValueX’ ekler
- $array[‘keyX’] = ‘ValueX’; // ‘valueX’ öğesini ‘keyX’ anahtarına atayın
- $array += [‘keyX’ => ‘valueX’, ‘keyY’ => ‘valueY’]; // Mevcut bir diziye eleman ekleme/üzerine yazma
Anahtar bir array’in benzersiz tanımlayıcısı ve indeksidir. Bir dize veya tamsayı olabilir. Bu nedenle, geçerli anahtarlar ‘foo’, ‘5’, 10, ‘a2b’, … olabilir. Değer: Her anahtar için karşılık gelen bir değer vardır (aksi takdirde null olur ve erişim sırasında bir uyarı verilir). Değerin girdi türü üzerinde herhangi bir kısıtlaması yoktur.
Array tanımlama
Arrayler boş olarak başlatılabilir:
// Boş bir dizi $foo = array(); // PHP 5.4'ten beri kısayol gösterim mevcuttur $foo = [];
Bir dizi başlangıç değerleri ile tanımlanabilir:
// Üç dizeden oluşan basit bir dizi oluşturur
$fruit = array('apples', 'pears', 'oranges');
// PHP 5.4'ten sonraki kısayol gösterimi
$fruit = ['apples', 'pears', 'oranges'];Bir dizi özel indekslerle de başlatılabilir (ilişkisel dizi olarak da adlandırılır):
// Basit bir ilişkisel dizi
$fruit = array(
'first' => 'apples',
'second' => 'pears',
'third' => 'oranges'
);
// Anahtar ve değer aşağıdaki gibi de ayarlanabilir
$fruit['first'] = 'apples';
// PHP 5.4'ten sonraki kısayol gösterimi
$fruit = [
'first' => 'apples',
'second' => 'pears',
'third' => 'oranges'
];Eğer değişken daha önce kullanılmamışsa, PHP tarafından otomatik olarak oluşturulacaktır. Kullanışlı olsa da, bu, kodun okunmasını zorlaştırabilir:
$foo[] = 1; // Array( [0] => 1 ) $bar[][] = 2; // Array( [0] => Array( [0] => 2 ) )
Dizin genellikle kaldığınız yerden devam edecektir. PHP sayısal dizgeleri tamsayı olarak kullanmaya çalışacaktır:
$foo = [2 => 'apple', 'melon']; // Array( [2] => apple, [3] => melon ) $foo = ['2' => 'apple', 'melon']; // yukarıdakiyle aynı $foo = [2 => 'apple', 'bu geçici olarak indeks 3', '3' => 'melon']; // Yukarıdaki ile aynı! Son giriş ikincinin üzerine yazılacaktır!
Sabit boyutlu bir diziyi başlatmak için SplFixedArray kullanabilirsiniz:
$array = new SplFixedArray(3); $array[0] = 1; $array[1] = 2; $array[2] = 3; $array[3] = 4; // RuntimeException // Dizinin boyutunu 10'a yükseltin $array->setSize(10);
Not: SplFixedArray kullanılarak oluşturulan bir dizi, büyük veri kümeleri için daha az bellek ayak izine sahiptir, ancak anahtarlar tam sayı olmalıdır.
Bir diziyi dinamik bir boyutla ancak n boş olmayan elemanla (örneğin bir yer tutucu) başlatmak için aşağıdaki gibi bir döngü kullanabilirsiniz:
$myArray = array();
$sizeOfMyArray = 5;
$fill = 'placeholder';
for ($i = 0; $i < $sizeOfMyArray; $i++) {
$myArray[] = $fill;
}
// print_r($myArray); aşağıdaki sonuçları verir:
// Array ( [0] => placeholder [1] => placeholder [2] => placeholder [3] => placeholder [4] => placeholder )Tüm yer tutucularınız aynıysa, array_fill() işlevini kullanarak da oluşturabilirsiniz:
<!– language: lang-none -> array array_fill ( int $start_index , int $num , mixed $value )
Bu, start_index ile başlayan anahtarları olan num değer girdili bir dizi oluşturur ve döndürür.
Not: Eğer start_index negatif ise, negatif indeks ile başlayacak ve sonraki elemanlar için 0’dan devam edecektir.
$a = array_fill(5, 6, 'banana'); // Array ( [5] => banana, [6] => banana, ..., [10] => banana) $b = array_fill(-2, 4, 'pear'); // Array ( [-2] => pear, [0] => pear, ..., [2] => pear)
Sonuç: array_fill() ile gerçekte yapabilecekleriniz daha sınırlıdır. Döngü daha esnektir ve size daha geniş bir fırsat yelpazesi sunar.
Bir dizinin bir sayı aralığıyla (örneğin 1-4) doldurulmasını istediğinizde, ya her bir öğeyi bir diziye ekleyebilir ya da range() işlevini kullanabilirsiniz:
<!– language: lang-none -> array range ( mixed $start , mixed $end [, number $step = 1 ] )
Bu fonksiyon, bir eleman aralığı içeren bir array oluşturur. İlk iki parametre gereklidir ve (kapsayıcı) aralığın başlangıç ve bitiş noktalarını belirler. Üçüncü parametre isteğe bağlıdır ve atılan adımların boyutunu tanımlar. Adım boyutu 1 olan 0’dan 4’e kadar bir aralık oluşturulursa, ortaya çıkan dizi aşağıdaki elemanlardan oluşacaktır: 0, 1, 2, 3 ve 4. Adım boyutu 2’ye yükseltilirse (yani range(0, 4, 2)), ortaya çıkan dizi şu şekilde olacaktır: 0, 2 ve 4 olacaktır.
$array = [];
$array_with_range = range(1, 4);
for ($i = 1; $i <= 4; $i++) {
$array[] = $i;
}
print_r($array); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
print_r($array_with_range); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )range tamsayılar, floatlar, booleanlar (tamsayılara dönüştürülür) ve stringlerle çalışabilir. Ancak, float sayıları argüman olarak kullanırken float noktası hassasiyeti sorunu nedeniyle dikkatli olunmalıdır.
Array anahtarının var olup olmadığını kontrol etme
array_key_exists() veya isset() veya !empty() işlevlerini kullanabiliriz:
$map = [
'foo' => 1,
'bar' => null,
'foobar' => '',
];
array_key_exists('foo', $map); // true
isset($map['foo']); // true
!empty($map['foo']); // true
array_key_exists('bar', $map); // true
isset($map['bar']); // false
!empty($map['bar']); // falseisset() işlevinin null değerli bir öğeyi var olmayan olarak değerlendirdiğini unutmayın. Oysa !empty() işlevi, false değerine eşit olan herhangi bir öğe için aynı işlemi yapar (zayıf bir karşılaştırma kullanarak; örneğin, null, ” ve 0 değerlerinin tümü !empty() işlevi tarafından false olarak değerlendirilir). isset($map[‘foobar’]); doğru iken, !empty($map[‘foobar’]) yanlıştır. Bu hatalara yol açabilir (örneğin, ‘0’ dizesinin yanlış olarak değerlendirildiğini unutmak kolaydır), bu nedenle !empty() kullanımı genellikle hoş karşılanmaz.
Ayrıca isset() ve !empty() işlevlerinin $map hiç tanımlanmamışsa çalışacağını (ve false döndüreceğini) unutmayın. Bu da kullanımlarını biraz hataya eğilimli hale getirir:
// Değişken adında küçük bir yazım hatası olan "lang" yerine "long" kelimesine dikkat edin.
$my_array_with_a_long_name = ['foo' => true];
array_key_exists('foo', $my_array_with_a_lang_name); // uyarı verir
isset($my_array_with_a_lang_name['foo']); // false döndürürİndexli arrayleri de kontrol edebilirsiniz:
$ord = ['a', 'b']; // eşdeğer: [0 => 'a', 1 => 'b'] array_key_exists(0, $ord); // true array_key_exists(2, $ord); // false
isset() işlevinin array_key_exists() işlevinden daha iyi bir performansa sahip olduğunu unutmayın, çünkü ikincisi bir işlev, ilki ise bir dil yapısıdır.
array_key_exists() işlevinin takma adı olan key_exists() işlevini de kullanabilirsiniz.
Bir arrayin her bir elemanına bir fonksiyon uygulama
Bir dizideki her öğeye bir işlev uygulamak için array_map() işlevini kullanın. Bu yeni bir dizi döndürecektir. (Eğer Python’a aşinalığınız varsa Python’daki map işlevi ile karşılaştırabilirsiniz)
$array = array(1,2,3,4,5);
//her dizi öğesi üzerinde yineleme yapılır ve işlev parametresinde depolanır.
$newArray = array_map(function($item) {
return $item + 1;
}, $array);$newArray now is array(2,3,4,5,6);.
Anonim bir fonksiyon kullanmak yerine, adlandırılmış bir fonksiyon kullanabilirsiniz. Yukarıdaki kod parçasını aşağıdaki gibi de yazabiliriz:
function addOne($item) {
return $item + 1;
}
$array = array(1, 2, 3, 4, 5);
$newArray = array_map('addOne', $array);Adlandırılan fonksiyon bir sınıf metoduysa, fonksiyon çağrısı metodun ait olduğu sınıf nesnesine bir referans içermelidir:
class Example {
public function addOne($item) {
return $item + 1;
}
public function doCalculation() {
$array = array(1, 2, 3, 4, 5);
$newArray = array_map(array($this, 'addOne'), $array);
}
}Bir dizideki her öğeye bir işlev uygulamanın bir başka yolu da array_walk() ve array_walk_recursive() işlevleridir. Bu fonksiyonlara aktarılan geriçağırım, her dizi öğesinin hem anahtarını/indeksini hem de değerini alır. Bu fonksiyonlar yeni bir dizi döndürmez, bunun yerine başarı için bir boolean döndürür. Örneğin, basit bir dizideki her öğeyi yazdırmak için:
$array = array(1, 2, 3, 4, 5);
array_walk($array, function($value, $key) {
echo $value . ' ';
});
// prints "1 2 3 4 5"Callback’in değer parametresi, değeri doğrudan orijinal dizide değiştirmenize olanak tanıyacak şekilde referans olarak aktarılabilir:
$array = array(1, 2, 3, 4, 5);
array_walk($array, function(&$value, $key) {
$value++;
});$array now is array(2,3,4,5,6);
İç içe arrayler için, array_walk_recursive() her alt dizinin daha derinlerine inecektir:
$array = array(1, array(2, 3, array(4, 5), 6);
array_walk_recursive($array, function($value, $key) {
echo $value . ' ';
});
// çıktı "1 2 3 4 5 6"Not: array_walk ve array_walk_recursive dizi öğelerinin değerini değiştirmenize izin verir, ancak anahtarlarını değiştirmenize izin vermez. Anahtarları referans olarak callback’e aktarmak mümkündür, ancak bir etkisi yoktur.
Bir değişkenin array olup olmadığını öğrenme
is_array() işlevi, bir değişken bir dizi ise true değerini döndürür.
$integer = 1337; $array = [1337, 42]; is_array($integer); // false is_array($array); // true
Bir parametre türünü zorunlu kılmak için bir işlevde dizi türünü ipucu olarak yazabilirsiniz; başka bir şey geçirmek ölümcül bir hataya neden olur.
function foo (array $array) { /* $array bir arraydir */ }gettype() fonksiyonunu da kullanabilirsiniz.
$integer = 1337; $array = [1337, 42]; gettype($integer) === 'array'; // false gettype($array) === 'array'; // true
Birden çok array üzerinde yineleme
Örneğin bazen aynı uzunluktaki iki dizinin birlikte yinelenmesi gerekir:
$people = ['Tim', 'Tony', 'Turanga']; $foods = ['chicken', 'beef', 'slurm'];
array_map bunu gerçekleştirmenin en basit yoludur:
array_map(function($person, $food) {
return "$person likes $food\n";
}, $people, $foods);çıktısını verecektir:
Tim likes chicken Tony likes beef Turanga likes slurm
Bu, ortak bir endeks aracılığıyla da yapılabilir:
assert(count($people) === count($foods));
for ($i = 0; $i < count($people); $i++) {
echo "$people[$i] likes $foods[$i]\n";
}Eğer iki dizinin artan anahtarları yoksa, array_values($array)[$i] ifadesi, $array[$i] yerine kullanılabilir.
Her iki dizide de aynı anahtar sırası varsa, dizilerden birinde foreach-with-key döngüsü de kullanabilirsiniz:
foreach ($people as $index => $person) {
$food = $foods[$index];
echo "$person likes $food\n";
}Ayrı arrayler yalnızca aynı uzunluktalarsa ve aynı anahtar adına sahiplerse döngüye sokulabilir. Bu, bir anahtar sağlamazsanız ve numaralandırılmışlarsa, sorun olmayacağı veya anahtarları adlandırdığınız ve her dizide aynı sıraya koyduğunuz anlamına gelir.
Ayrıca array_combine da kullanabilirsiniz.
$combinedArray = array_combine($people, $foods); // $combinedArray = ['Tim' => 'chicken', 'Tony' => 'beef', 'Turanga' => 'slurm'];
Ardından, daha önce yaptığınızın aynısını yaparak bunun üzerinden döngü oluşturabilirsiniz:
foreach ($combinedArray as $person => $meal) {
echo "$person likes $meal\n";
}Array’e filtre uygulama
Bir dizideki değerleri filtrelemek ve filtre koşulunu sağlayan tüm değerleri içeren yeni bir dizi elde etmek için array_filter fonksiyonunu kullanabilirsiniz.
Array’deki boş değerleri kaldırma
Filtrelemenin en basit durumu tüm “boş” değerleri kaldırmaktır:
$my_array = [1,0,2,null,3,'',4,[],5,6,7,8]; $non_empties = array_filter($my_array); // $non_empties öğeleri: [1,2,3,4,5,6,7,8];
callback ile filtreleme
Bu kez kendi filtreleme kuralımızı tanımlıyoruz. Sadece çift sayıları almak istediğimizi varsayalım:
$my_array = [1,2,3,4,5,6,7,8];
$even_numbers = array_filter($my_array, function($number) {
return $number % 2 === 0;
});array_filter işlevi ilk bağımsız değişkeni olarak filtrelenecek diziyi ve ikinci bağımsız değişkeni olarak da filtre yüklemini tanımlayan bir geriçağrım alır.
İndekse göre filtreleme
array_filter fonksiyonuna, çağırmaya hangi değerlerin aktarılacağını ayarlamaya olanak tanıyan üçüncü bir parametre verilebilir. Bu parametre ARRAY_FILTER_USE_KEY veya ARRAY_FILTER_USE_BOTH olarak ayarlanabilir, bu da geri çağrının dizideki her öğe için değer yerine anahtarı veya argüman olarak hem değeri hem de anahtarı almasına neden olur. Örneğin, değerler yerine indekslerle uğraşmak istiyorsanız:
$numbers = [16,3,5,8,1,4,6];
$even_indexed_numbers = array_filter($numbers, function($index) {
return $index % 2 === 0;
}, ARRAY_FILTER_USE_KEY);Filtrelenmiş arraydeki indexler
array_filter’ın orijinal dizi anahtarlarını koruduğuna dikkat edin. Yaygın bir hata, filtrelenmiş dizi üzerinde bir for döngüsü kullanmayı denemek olacaktır:
<?php
$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array);
error_reporting(E_ALL); // tüm hataları ve bildirimleri göster
// masum görünen "for" döngüsü
for ($i = 0; $i < count($filtered); $i++) {
print $filtered[$i];
}
/*
Çıktı:
1
Uyarı: Tanımlanmamış ofset: 1
2
Uyarı: Tanımlanmamış ofset: 3
3
Uyarı: Tanımlanmamış ofset: 5
4
Uyarı: Tanımlanmamış ofset: 7
*/Bunun nedeni, 1 (0 vardı), 3 (null), 5 (boş dize ”) ve 7 (boş dizi []) konumlarında bulunan değerlerin ilgili dizin anahtarlarıyla birlikte kaldırılmasıdır.
İndeksli bir dizi üzerinde bir filtrenin sonucu üzerinde döngü yapmanız gerekiyorsa, doğru indekslere sahip yeni bir dizi oluşturmak için önce array_filter’ın sonucu üzerinde array_values’ı çağırmalısınız:
$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array);
$iterable = array_values($filtered);
error_reporting(E_ALL); // tüm hataları ve bildirimleri göster
for ($i = 0; $i < count($iterable); $i++) {
print $iterable[$i];
}
// Hiçbir uyarı yok!Arrayden eleman kaldırma
Bir dizinin içindeki bir elemanı, örneğin 1 indisli elemanı kaldırmak için.
$fruit = array("bananas", "apples", "peaches");
unset($fruit[1]);Bu, elmaları listeden kaldıracaktır, ancak unset’in kalan öğelerin indekslerini değiştirmediğine dikkat edin. Yani $fruit artık 0 ve 2 indislerini içerir.
İlişkisel dizi için bu şekilde kaldırabilirsiniz:
$fruit = array('banana', 'one'=>'apple', 'peaches');
print_r($fruit);
/*
Array
(
[0] => banana
[one] => apple
[1] => peaches
)
*/
unset($fruit['one']);Şimdi $fruit
print_r($fruit);
/*
Array
(
[0] => banana
[1] => peaches
)
*/Dikkat edin
unset($fruit);
değişkeni siler ve böylece tüm diziyi kaldırır, yani artık hiçbir öğesine erişilemez.
Arrayde uç elemanların kaldırılması
array_shift() – Bir elemanı dizinin başından kaydırır.
Örneğin:
$fruit = array("bananas", "apples", "peaches");
array_shift($fruit);
print_r($fruit);Çıktı:
Array ( [0] => apples [1] => peaches )
array_pop() – Elemanı arrayin sonundan çıkarır.
Örnek:
$fruit = array("bananas", "apples", "peaches");
array_pop($fruit);
print_r($fruit);Çıktı:
Array ( [0] => bananas [1] => apples )
Değişken arrayi oluşturma
$username = 'Hadibut';
$email = 'hadibut@example.org';
$variables = compact('username', 'email');
// $variables : ['username' => 'Hadibut', 'email' => 'hadibut@example.org']Bu yöntem genellikle framework’lerde iki bileşen arasında bir dizi değişkeni aktarmak için kullanılır.
Array’de bir değer olup olmadığını denetleme
in_array() işlevi, bir öğe bir dizide mevcutsa true değerini döndürür.
$fruits = ['banana', 'apple'];
$foo = in_array('banana', $fruits);
// $foo : true
$bar = in_array('orange', $fruits);
// $bar : falseBir arraydeki belirli bir öğenin anahtarını almak için array_search() işlevini de kullanabilirsiniz.
$userdb = ['Sandra Shush', 'Stefanie Mcmohn', 'Michael'];
$pos = array_search('Stefanie Mcmohn', $userdb);
if ($pos !== false) {
echo "Stefanie Mcmohn found at $pos";
}PHP 5.5 ve sonraki sürümlerde array_column() işlevini array_search() işlevi ile birlikte kullanabilirsiniz.
Bu özellikle bir ilişkisel dizide bir değerin var olup olmadığını kontrol etmek için kullanışlıdır:
$userdb = [
[
"uid" => '100',
"name" => 'Sandra Shush',
"url" => 'urlof100',
],
[
"uid" => '5465',
"name" => 'Stefanie Mcmohn',
"pic_square" => 'urlof100',
],
[
"uid" => '40489',
"name" => 'Michael',
"pic_square" => 'urlof40489',
]
];
$key = array_search(40489, array_column($userdb, 'uid'));PHP’de Array Sıralama
Php’de array’ler için çeşitli sıralama fonksiyonları vardır:
sort()
Diziyi değere göre artan sırada sıralar.
$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel']; sort($fruits); print_r($fruits);
Çıktı:
Array
(
[0] => Apfel
[1] => Banane
[2] => Orange
[3] => Zitrone
)rsort()
Arrayi değere göre azalan sırada sıralar.
$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel']; rsort($fruits); print_r($fruits);
Çıktı
Array
(
[0] => Zitrone
[1] => Orange
[2] => Banane
[3] => Apfel
)asort()
Bir diziyi değere göre artan sırada sıralar ve indexleri korur.
$fruits = [1 => 'lemon', 2 => 'orange', 3 => 'banana', 4 => 'apple']; asort($fruits); print_r($fruits);
Çıktı
Array
(
[4] => apple
[3] => banana
[1] => lemon
[2] => orange
)arsort()
Bir diziyi değere göre azalan sırada sıralar ve indexleri korur.
$fruits = [1 => 'lemon', 2 => 'orange', 3 => 'banana', 4 => 'apple']; arsort($fruits); print_r($fruits);
Çıktı
Array
(
[2] => orange
[1] => lemon
[3] => banana
[4] => apple
)ksort()
Bir diziyi anahtara göre artan sırada sıralama
$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple']; ksort($fruits); print_r($fruits);
Çıktı:
Array
(
[a] => orange
[b] => banana
=> apple
[d] => lemon
)krsort()
Bir diziyi anahtara göre azalan sırada sıralar.
$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple']; krsort($fruits); print_r($fruits);
Çıktı:
Array
(
[d] => lemon
=> apple
[b] => banana
[a] => orange
)natsort()
Bir diziyi bir insanın yapacağı şekilde sıralayın (doğal sıralama).
$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack']; natsort($files); print_r($files);
Çıktı:
Array
(
[4] => File2.stack
[0] => File8.stack
[2] => file7.stack
[3] => file13.stack
[1] => file77.stack
)natcasesort()
Bir diziyi bir insanın yapacağı şekilde sıralayın (doğal sıralama), ancak büyük/küçük harfe duyarlı olmasın
$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack']; natcasesort($files); print_r($files);
Çıktı:
Array
(
[4] => File2.stack
[2] => file7.stack
[0] => File8.stack
[3] => file13.stack
[1] => file77.stack
)shuffle()
Bir diziyi karıştırır (rastgele sıralanır).
$array = ['aa', 'bb', 'cc']; shuffle($array); print_r($array);
Açıklamada yazıldığı gibi bu işlem rastgeledir, bu nedenle burada neyle sonuçlanabileceğine dair yalnızca bir örnek verilmiştir
Array
(
[0] => cc
[1] => bb
[2] => aa
)usort()
Bir diziyi kullanıcı tanımlı bir karşılaştırma fonksiyonu ile sıralar.
function compare($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
$array = [3, 2, 5, 6, 1];
usort($array, 'compare');
print_r($array);Çıktı:
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 5
[4] => 6
)uasort()
Bir diziyi kullanıcı tanımlı bir karşılaştırma işleviyle sıralayın ve anahtarları koruyun.
function compare($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
$array = ['a' => 1, 'b' => -3, 'c' => 5, 'd' => 3, 'e' => -5];
uasort($array, 'compare');
print_r($array);Çıktı:
Array
(
[e] => -5
[b] => -3
[a] => 1
[d] => 3
=> 5
)uksort()
Bir arrayi kullanıcı tanımlı bir karşılaştırma işleviyle anahtarlara göre sıralayın.
function compare($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
$array = ['ee' => 1, 'g' => -3, '4' => 5, 'k' => 3, 'oo' => -5];
uksort($array, 'compare');
print_r($array);Çıktı:
Array
(
[ee] => 1
[g] => -3
[k] => 3
[oo] => -5
[4] => 5
)Bir stringi array’e bölme
explode ve strstr, alt dizeleri ayırıcılara göre almak için daha basit yöntemlerdir.
Ortak bir karakterle ayrılmış birkaç metin parçası içeren bir dize, explode işleviyle parçalara ayrılabilir.
$fruits = "apple,pear,grapefruit,cherry";
print_r(explode(",",$fruits)); // ['apple', 'pear', 'grapefruit', 'cherry']Yöntem ayrıca aşağıdaki gibi kullanılabilen bir limit parametresini de destekler:
$fruits= 'apple,pear,grapefruit,cherry';
Limit parametresi sıfır ise, bu 1 olarak kabul edilir.
print_r(explode(',',$fruits,0)); // ['apple,pear,grapefruit,cherry']Limit ayarlanmışsa ve pozitifse, döndürülen dizi en fazla limit elemanı içerecek ve son eleman dizenin geri kalanını içerecektir.
print_r(explode(',',$fruits,2)); // ['apple', 'pear,grapefruit,cherry']Parametre negatifse, son -limit hariç tüm bileşenler döndürülür.
print_r(explode(',',$fruits,-1)); // ['apple', 'pear', 'grapefruit']explode, bir dizeyi tek bir satırda değişkenlere ayrıştırmak için list ile birleştirilebilir:
$email = "user@example.com";
list($name, $domain) = explode("@", $email);Ancak, explode sonucunun yeterli eleman içerdiğinden emin olun, aksi takdirde tanımlanmamış dizin uyarısı tetiklenir.
strstr, verilen ifadenin ilk geçtiği yerden önceki alt dizeyi çıkarır veya yalnızca bunu döndürür.
$string = "1:23:456";
echo json_encode(explode(":", $string)); // ["1","23","456"]
var_dump(strstr($string, ":")); // string(7) ":23:456"
var_dump(strstr($string, ":", true)); // string(1) "1"Array kesişimini bulma
array_intersect fonksiyonu, bu fonksiyona aktarılan tüm arraylerde bulunan değerlerden oluşan bir dizi döndürür.
$array_one = ['one', 'two', 'three']; $array_two = ['two', 'three', 'four']; $array_three = ['two', 'three']; $intersect = array_intersect($array_one, $array_two, $array_three); // $intersect : ['two', 'three']
Dizi anahtarları korunur. Orijinal dizilerdeki dizinler korunmaz.
array_intersect sadece dizilerin değerlerini kontrol eder. array_intersect_assoc fonksiyonu dizilerin anahtarlarla kesişimini döndürür.
$array_one = [1 => 'one',2 => 'two',3 => 'three']; $array_two = [1 => 'one', 2 => 'two', 3 => 'two', 4 => 'three']; $array_three = [1 => 'one', 2 => 'two']; $intersect = array_intersect_assoc($array_one, $array_two, $array_three); // $intersect : [1 =>'one',2 => 'two']
array_intersect_key fonksiyonu sadece anahtarların kesişimini kontrol eder. Tüm dizilerde var olan anahtarları döndürür.
$array_one = [1 => 'one',2 => 'two',3 => 'three']; $array_two = [1 => 'one', 2 => 'two', 3 => 'four']; $array_three = [1 => 'one', 3 => 'five']; $intersect = array_intersect_key($array_one, $array_two, $array_three); // $intersect : [1 =>'one',3 => 'three']
Array başlangıcına eleman ekleme
Bazen bir dizinin başına, dizi içindeki mevcut elemanlardan herhangi birini (sırasını) değiştirmeden bir eleman eklemek istersiniz. Böyle bir durumda array_unshift() işlevini kullanabilirsiniz.
array_unshift() işlevi geçirilen elemanları dizinin başına ekler. Eleman listesinin bir bütün olarak öncelendiğine dikkat edin, böylece öncelenen elemanlar aynı sırada kalır. Tüm sayısal dizi anahtarları sıfırdan saymaya başlayacak şekilde değiştirilirken, değişmez anahtarlara dokunulmaz.
PHP belgeleri
Bunun için aşağıdaki gibi bir şey yapabilirsiniz:
$myArray = array(1, 2, 3); array_unshift($myArray, 4);
Bu artık dizinize ilk eleman olarak 4’ü ekleyecektir. Bunu şu şekilde doğrulayabilirsiniz:
print_r($myArray);
Bu, şu sırada bir dizi döndürür: 4, 1, 2, 3.
array_unshift diziyi anahtar-değer çiftlerini sıfırlamaya zorladığından, yeni eleman aşağıdaki girdilerin n+1 anahtarlarına sahip olmasına izin verdiğinden, yeni bir dizi oluşturmak ve mevcut diziyi yeni oluşturulan diziye eklemek daha akıllıca olacaktır.
Örnek:
$myArray = array('apples', 'bananas', 'pears');
$myElement = array('oranges');
$joinedArray = $myElement;
foreach ($myArray as $i) {
$joinedArray[] = $i;
}Çıktı ($joinedArray):
Array ( [0] => oranges [1] => apples [2] => bananas [3] => pears )
Arrayleri birleştirme veya birbirine ekleme
$fruit1 = ['apples', 'pears']; $fruit2 = ['bananas', 'oranges']; $all_of_fruits = array_merge($fruit1, $fruit2); // $all_of_fruits'un değeri : [0 => 'apples', 1 => 'pears', 2 => 'bananas', 3 => 'oranges']
array_merge’in sayısal indeksleri değiştireceğini, ancak dize indekslerinin üzerine yazacağını unutmayın
$fruit1 = ['one' => 'apples', 'two' => 'pears']; $fruit2 = ['one' => 'bananas', 'two' => 'oranges']; $all_of_fruits = array_merge($fruit1, $fruit2); //$all_of_fruits'un değeri : ['one' => 'bananas', 'two' => 'oranges']
array_merge, indeksi yeniden numaralandıramazsa, ilk dizinin değerlerinin üzerine ikinci dizinin değerlerini yazar.
İki diziyi, ilk dizinin değerlerinin üzerine asla yazılmayacak şekilde birleştirmek için + işlecini kullanabilirsiniz, ancak sayısal dizinleri yeniden numaralandırmaz, bu nedenle ilk dizide de kullanılan bir dizine sahip dizilerin değerlerini kaybedersiniz.
$fruit1 = ['one' => 'apples', 'two' => 'pears']; $fruit2 = ['one' => 'bananas', 'two' => 'oranges']; $all_of_fruits = $fruit1 + $fruit2; // $all_of_fruits : ['one' => 'apples', 'two' => 'pears'] $fruit1 = ['apples', 'pears']; $fruit2 = ['bananas', 'oranges']; $all_of_fruits = $fruit1 + $fruit2; // $all_of_fruits : [0 => 'apples', 1 => 'pears']
ArrayAccess ve Iterator Arayüzleri
Bir başka kullanışlı özellik de özel nesne koleksiyonlarınıza PHP’de diziler olarak erişmektir. PHP (>=5.0.0) çekirdeğinde bunu destekleyen iki arayüz bulunmaktadır: ArrayAccess ve Iterator. İlki özel nesnelerinize dizi olarak erişmenizi sağlar.
ArrayAccess
Bir kullanıcı sınıfımız ve tüm kullanıcıları depolayan bir veritabanı tablomuz olduğunu varsayalım. Bir UserCollection sınıfı oluşturmak istiyoruz. Böylece:
- benzersiz kullanıcı adı oluşturmamızı sağlarız
- Kullanıcı koleksiyonumuz üzerinde temel (en azından Oluştur, Al ve Sil) işlemleri gerçekleştiririz.
Aşağıdaki kaynağı ele alalım (bundan sonra 5.4 sürümünden beri mevcut olan [] kısa dizi oluşturma sözdizimini kullanacağız):
class UserCollection implements ArrayAccess {
protected $_conn;
protected $_requiredParams = ['username','password','email'];
public function __construct() {
$config = new Configuration();
$connectionParams = [
//veritabanına olan bağlantınız
];
$this->_conn = DriverManager::getConnection($connectionParams, $config);
}
protected function _getByUsername($username) {
$ret = $this->_conn->executeQuery('SELECT * FROM `User` WHERE `username` IN (?)',
[$username]
)->fetch();
return $ret;
}
// ArrayAccess arayüzünün gerektirdiği yöntemlerin BAŞLANGICI
public function offsetExists($offset) {
return (bool) $this->_getByUsername($offset);
}
public function offsetGet($offset) {
return $this->_getByUsername($offset);
}
public function offsetSet($offset, $value) {
if (!is_array($value)) {
throw new \Exception('değeri bir array olmalıdır');
}
$passed = array_intersect(array_values($this->_requiredParams), array_keys($value));
if (count($passed) < count($this->_requiredParams)) {
throw new \Exception('Değer en az aşağıdaki parametreleri içermelidir: ' . implode(',', $this->_requiredParams));
}
$this->_conn->insert('User', $value);
}
public function offsetUnset($offset) {
if (!is_string($offset)) {
throw new \Exception('değer silinecek kullanıcı adı olmalıdır');
}
if (!$this->offsetGet($offset)) {
throw new \Exception('kullanıcı bulunamadı');
}
$this->_conn->delete('User', ['username' => $offset]);
}
// ArrayAccess arayüzünün gerektirdiği yöntemlerin sonu
}sonra şunu yapabiliriz :
$users = new UserCollection();
var_dump(empty($users['testuser']),isset($users['testuser']));
$users['testuser'] = ['username' => 'testuser',
'password' => 'testpassword',
'email' => 'test@test.com'];
var_dump(empty($users['testuser']), isset($users['testuser']), $users['testuser']);
unset($users['testuser']);
var_dump(empty($users['testuser']), isset($users['testuser']));Bu da kodu başlatmadan önce test kullanıcısı olmadığını varsayarak aşağıdaki çıktıyı verecektir:
bool(true)
bool(false)
bool(false)
bool(true)
array(17) {
["username"]=>
string(8) "testuser"
["password"]=>
string(12) "testpassword"
["email"]=>
string(13) "test@test.com"
}
bool(true)
bool(false)NOT: array_key_exists fonksiyonu ile bir anahtarın varlığını kontrol ettiğinizde offsetExists çağrılmaz. Dolayısıyla aşağıdaki kod iki kez false çıktısı verecektir:
var_dump(array_key_exists('testuser', $users));
$users['testuser'] = ['username' => 'testuser',
'password' => 'testpassword',
'email' => 'test@test.com'];
var_dump(array_key_exists('testuser', $users));Iterator
Yukarıdaki sınıfımızı Iterator arayüzünden birkaç fonksiyonla genişleterek foreach ve while ile yinelemeye izin verelim.
İlk olarak, iteratörün mevcut indeksini tutan bir özellik eklememiz gerekiyor, bunu sınıf özelliklerine $_position olarak ekleyelim:
// yineleyicinin geçerli konumu, Iterator arayüz yöntemleri tarafından gereklidir protected $_position = 1;
İkinci olarak, sınıfımız tarafından uygulanan arayüzler listesine Iterator arayüzünü ekleyelim:
class UserCollection implements ArrayAccess, Iterator {daha sonra arayüz fonksiyonları tarafından gerekli olanları ekleyin:
// Iterator arayüzünün gerektirdiği yöntemlerin BAŞLANGICI
public function current () {
return $this->_getById($this->_position);
}
public function key () {
return $this->_position;
}
public function next () {
$this->_position++;
}
public function rewind () {
$this->_position = 1;
}
public function valid () {
return null !== $this->_getById($this->_position);
}
// Iterator arayüzünün gerektirdiği yöntemlerin SONUSonuç olarak burada her iki arayüzü de uygulayan sınıfın tam kaynağını görüyorsunuz. Bu örneğin mükemmel olmadığını unutmayın, çünkü veritabanındaki ID’ler sıralı olmayabilir, ancak bu sadece size ana fikri vermek için yazılmıştır: ArrayAccess ve Iterator arayüzlerini uygulayarak nesne koleksiyonlarınızı mümkün olan her şekilde ele alabilirsiniz:
class UserCollection implements ArrayAccess, Iterator {
// yineleyici geçerli konumu, Iterator arayüz yöntemleri tarafından gerekli
protected $_position = 1;
// <son kod parçacığındaki yöntemleri buraya ekleyin>
// Iterator arayüzünün gerektirdiği yöntemlerin BAŞLANGICI
public function current () {
return $this->_getById($this->_position);
}
public function key () {
return $this->_position;
}
public function next () {
$this->_position++;
}
public function rewind () {
$this->_position = 1;
}
public function valid () {
return null !== $this->_getById($this->_position);
}
// Iterator arayüzünün gerektirdiği yöntemlerin SONU
}ve tüm kullanıcı nesneleri arasında döngü yapan bir foreach:
foreach ($users as $user) {
var_dump($user['id']);
}aşağıdaki gibi bir çıktı verecektir:
string(2) "1" string(2) "2" string(2) "3" string(2) "4" ...
Yalnızca bazı array anahtarlarına izin verme
Dizilerinizde yalnızca belirli anahtarlara izin vermek istediğinizde, özellikle diziniz istek (request) parametrelerinden geliyorsa, array_intersect_key’i array_flip ile birlikte kullanabilirsiniz.
$parameters = ['foo' => 'bar', 'bar' => 'baz', 'boo' => 'bam']; $allowedKeys = ['foo', 'bar']; $filteredParameters = array_intersect_key($parameters, array_flip($allowedKeys)); // $filteredParameters : ['foo' => 'bar', 'bar' => 'baz]
parameters değişkeni izin verilen herhangi bir anahtar içermiyorsa, filteredParameters değişkeni boş bir arrayden oluşacaktır.
PHP 5.6’dan beri, ARRAY_FILTER_USE_KEY bayrağını üçüncü parametre olarak aktararak array_filter’ı bu görev için de kullanabilirsiniz:
$parameters = ['foo' => 1, 'hello' => 'world'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_filter($parameters,function ($key) use ($allowedKeys) {return in_array($key, $allowedKeys);},ARRAY_FILTER_USE_KEY);array_filter kullanımı, anahtara karşı rastgele bir test gerçekleştirme esnekliği sağlar, örneğin $allowedKeys düz dizeler yerine regex desenleri içerebilir. Ayrıca array_intersect_key() ile array_flip() kombinasyonuna göre kodun amacını daha açık bir şekilde belirtir.
PHP’de String’i Array’e dönüştürme
implode() tüm string değerlerini birleştirir ancak tüm anahtar bilgilerini kaybeder:
$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];
echo implode(" ", $arr); // AA BB CCAnahtarların birleştirilmesi array_keys() çağrısı kullanılarak yapılabilir:
$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];
echo implode(" ", array_keys($arr)); // a b cAnahtarları değerlerle iç içe geçirmek daha karmaşıktır ancak bir fonksiyon yardımıyla yapılabilir:
$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];
echo implode(" ", array_map(function($key, $val) {
return "$key:$val"; // anahtarı değerle birleştiren işlev
}, array_keys($arr), $arr));
// Çıktı: a:AA b:BB c:CCArrayi parçalara ayırma
array_chunk() bir arrayi parçalara böler
Diyelim ki aşağıdaki tek boyutlu diziye sahibiz,
$input_array = array('a', 'b', 'c', 'd', 'e');Şimdi yukarıdaki PHP dizisi üzerinde array_chunk() işlevini kullanalım,
$output_array = array_chunk($input_array, 2);
Yukarıdaki kod arrayimizi 2 elemanlı array parçalarına ayıracak ve aşağıdaki gibi çok boyutlu bir dizi oluşturacaktır.
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
[1] => d
)
[2] => Array
(
[0] => e
)
)Dizinin tüm elemanları verilen boyuta eşit olarak bölünememişse, çıktı dizisinin son elemanı kalan elemanlar olacaktır.
İkinci argümanı 1’den küçük olarak geçersek, E_WARNING fırlatılır ve çıktı dizisi NULL olur.
Array değerlerini anahtarlarla değiştirme
array_flip fonksiyonu tüm anahtarları değerler ile değiştirir.
$colors = array(
'one' => 'red',
'two' => 'blue',
'three' => 'yellow',
);
array_flip($colors);
//çıktı:
array(
'red' => 'one',
'blue' => 'two',
'yellow' => 'three'
)İki diziyi birleştirirken birinden anahtarları diğerinden değerleri getirmek
Aşağıdaki örnekte, iki dizinin, anahtarlar ilk diziden ve değerler ikinci dizinin öğeleri olacak şekilde tek bir ilişkisel dizide nasıl birleştirileceği gösterilmektedir:
$array_one = ['key1', 'key2', 'key3'];
$array_two = ['value1', 'value2', 'value3'];
$array_three = array_combine($array_one, $array_two);
var_export($array_three);
/*
array (
'key1' => 'value1',
'key2' => 'value2',
'key3' => 'value3',
)
*/array reduce
array_reduce diziyi tek bir değere indirger. Temel olarak, array_reduce, son yinelemenin sonucuyla her öğeyi gözden geçirecek ve bir sonraki yineleme için yeni değer üretecektir.
Kullanım: array_reduce ($array, function($carry, $item){...}, $defaul_value_of_first_carry)
- $carry son yineleme turundan elde edilen sonuçtur.
- $item dizideki geçerli konumun değeridir.
Dizinin toplamı
$result = array_reduce([1, 2, 3, 4, 5], function($carry, $item){
return $carry + $item;
});sonuç:15
Arraydeki en büyük sayı
$result = array_reduce([10, 23, 211, 34, 25], function($carry, $item){
return $item > $carry ? $item : $carry;
});Çıktı:211
Tüm öğeler 100’den fazla mı
$result = array_reduce([101, 230, 210, 341, 251], function($carry, $item){
return $carry && $item > 100;
}, true); //varsayılan değer trueçıktı:true
Herhangi bir öğe 100’den az mı
$result = array_reduce([101, 230, 21, 341, 251], function($carry, $item){
return $carry || $item < 100;
}, false);//varsayılan değer falseresult:true
implode($array, $piece) benzeri
$result = array_reduce(["hello", "world", "PHP", "language"], function($carry, $item){
return !$carry ? $item : $carry . "-" . $item ;
});çıktı:"hello-world-PHP-language"
eğer bir implode metodu yaparsanız, kaynak kodu :
function implode_method($array, $piece){
return array_reduce($array, function($carry, $item) use ($piece) {
return !$carry ? $item : ($carry . $piece . $item);
});
}
$result = implode_method(["hello", "world", "PHP", "language"], "-");Çıktı:"hello-world-PHP-language"
Liste kullanarak dizileri yeniden yapılandırma
Değişken değerlerinden oluşan bir listeyi bir arraye hızlıca atamak için list() işlevini kullanın. Ayrıca bkz. compact()
// $a, $b ve $c'ye ilgili dizi elemanlarının değerlerini atar. //sıfırdan itibaren numaralandırılmış anahtarlara sahip $array list($a, $b, $c) = $array;
PHP 7.1 ile kısa liste sözdizimini kullanabiliriz:
// $a, $b ve $c'ye $array'deki ilgili dizi elemanlarının değerlerini atar ve anahtarları sıfırdan itibaren numaralandırır [$a, $b, $c] = $array;
// Sırasıyla "a", "b" ve "c" anahtarlarıyla $array içindeki dizi elemanlarının değerlerini $a, $b ve $c olarak atar ["a" => $a, "b" => $b, "c" => $c] = $array;