PHP’de Array

Array, keyfi sayıda değeri tek bir değişkende saklayan bir veri yapısıdır.

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.

Söz dizimi 

  • $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

Parametreler

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']); // false

isset() 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 : false

Bir 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 SONU

Sonuç 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 CC

Anahtarları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 c

Anahtarları 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:CC

Arrayi 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 false

result: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;
Bu yazı topluluk tarafından oluşturuldu. Lisans bilgisine bakabilirsiniz. Yanlış veya eksik bilgileri düzenlemek için github üzerinden katkıda bulunabilirsiniz.

Kategoriler: Ders, PHP

Okumaya devam et!
Sonraki Yazı: PHP Fonksiyonel Programlama

PHP’nin işlevsel programlaması fonksiyonlara dayanır.

PHP ile mail gönderme

Tipik bir e-postanın üç ana bileşeni vardır: Bir alıcı (e-posta adresi olarak gösterilir) Bir konu Bir mesaj gövdesi PHP’de mail göndermek, yerleşik mail() işlevini çağırmak kadar basit olabilir.

PHP’de Array

Array, keyfi sayıda değeri tek bir değişkende saklayan bir veri yapısıdır.

PHP Fonksiyonel Programlama

PHP’nin işlevsel programlaması fonksiyonlara dayanır.

PHP Veri Türleri

PHP zayıf tiplemeli bir dildir.

Yorum Gönderin

E-posta hesabınız yayımlanmayacak.

koddla
Tema Mundana by WowThemes.net.