Bir dizinin son öğesini silmeden almanın en iyi yolu nedir?

Tamam,

Her şeyi biliyorum array_pop(), ama bu son elementi siler. Bir dizinin son öğesini silmeden almanın en iyi yolu nedir?

EDIT: İşte bir bonus:

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');

ya da

$array = array('a', 'b', 'c', 'd');
unset($array[2]);
echo $array[sizeof($array) - 1]; // Output: PHP Notice:  Undefined offset:  2 in - on line 4

Bu konudaki birçok cevap bize birçok farklı seçenek sunuyor. Onlardan seçim yapabilmek için davranışlarını ve performanslarını anlamam gerekiyordu. Bu cevap olarak PHP sürümleri karşılaştırmanız seninle bulgularımı paylaşacak 5.6.38, 7.2.10ve 7.3.0RC1( 2018 13 Aralık beklenen ).

<<option code>>Test edeceğim seçenekler :

• seçenek 1. $x = array_values(array_slice($array, -1))[0];( Önerilen göre rolacja )
• seçenek 2. $x = array_slice($array, -1)[0];( Önerilen göre Stoutie )
• seçenek .3. $x = array_pop((array_slice($array, -1)));( Önerilen göre rolacja )
• seçenek .4. $x = array_pop((array_slice($array, -1, 1)));( Önerilen göre Westy92 )
• seçenek .5. $x = end($array); reset($array);( Iznogood tarafından önerildiği gibi )
• seçenek .6. $x = end((array_values($array)));( Önerilen göre TecBrat )
• seçenek .7. $x = $array[count($array)-1];( Mirko Pagliai tarafından önerildiği gibi )
• seçenek .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( Önerilen göre thrau )
• seçenek .9. $x = $array[] = array_pop($array);( Önerilen göre user2782001 )
• seçenek 10. $x = $array[array_key_last($array)]; ( Quasimodo'nun klonu tarafından önerildiği gibi ; PHP 7.3 için mevcuttur)

(fonksiyonlar söz: array_key_last , array_keys , array_pop , array_slice , array_values , sayım , son , sıfırlama )

Şunlarla <<input code>>birleştirilecek test girişleri :

• null =$array = null;
• boş =$array = [];
• last_null =$array = ["a","b","c",null];
• auto_idx =$array = ["a","b","c","d"];
• karıştır =$array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";
• 100 =$array = []; for($i=0;$i<100;$i++) { $array[] = $i; }
• 100000 =$array = []; for($i=0;$i<100000;$i++) { $array[] = $i; }

Test için 5.6.38, 7.2.10ve 7.3.0RC1 PHP docker kapsayıcılar kullanacağım :

sudo docker run -it --rm php:5.6.38-cli-stretch php -r '<<<CODE HERE>>>'

Yukarıda listelenen her <<option code>>s ve <<input code>>s kombinasyonu , PHP'nin tüm sürümlerinde çalıştırılır. Her test çalıştırması için aşağıdaki kod snippet'i kullanılır:

<<input code>>  error_reporting(E_ALL);  <<option code>>  error_reporting(0); $before=microtime(TRUE); for($i=0;$i<100;$i++){echo ".";for($j=0;$j<100;$j++){  <<option code>>  }}; $after=microtime(TRUE); echo "\n"; var_dump($x); echo round(($after-$before)/(100*100)*1000*1000*1000);

Her çalışma için bu, test girişinin son alınan son değerini değiştirir ve femtosaniye cinsinden bir yinelemenin ortalama süresini yazdırır (saniyenin 0,000000000000001th).

Sonuçlar aşağıdaki gibidir:

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            T  E  S  T     I  N  P  U  T     -     5  .  6  .  3  8                            ||                             T  E  S  T     I  N  P  U  T     -     7  .  2  .  1  0                           ||                             T  E  S  T     I  N  P  U  T     -     7  .  3  .  0  R  C  1                     ||
||                                                                      ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||
||============================OPTIONS - ERRORS==========================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||
||  2.  $x = array_slice($array, -1)[0];                                ||            W1 |            N1 |             - |             - |             - |             - |             - ||            W1 |            N1 |             - |             - |             - |             - |             - ||            W1 |            N1 |             - |             - |             - |             - |             - ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||       W1 + W3 |             - |             - |             - |             - |             - |             - ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||       W1 + W3 |             - |             - |             - |             - |             - |             - ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  5.  $x = end($array); reset($array);                                ||       W4 + W5 |             - |             - |             - |             - |             - |             - ||       W4 + W5 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||       W4 + W5 |             - |             - |             - |             - |             - |             - ||
||  6.  $x = end((array_values($array)));                               ||       W2 + W4 |             - |             - |             - |             - |             - |             - ||  W2 + N2 + W4 |             - |             - |             - |             - |             - |             - ||  W2 + N2 + W4 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  7.  $x = $array[count($array)-1];                                   ||             - |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||            W6 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||
||  9.  $x = $array[] = array_pop($array);                              ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||
|| 10.  $x = $array[array_key_last($array)];                            ||            F1 |            F1 |            F1 |            F1 |            F1 |            F1 |            F1 ||            F2 |            F2 |            F2 |            F2 |            F2 |            F2 |            F2 ||            W8 |            N4 |            F2 |            F2 |            F2 |            F2 |            F2 ||
||========================OPTIONS - VALUE RETRIEVED=====================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  2.  $x = array_slice($array, -1)[0];                                ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  5.  $x = end($array); reset($array);                                ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  6.  $x = end((array_values($array)));                               ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  7.  $x = $array[count($array)-1];                                   ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  9.  $x = $array[] = array_pop($array);                              ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
|| 10.  $x = $array[array_key_last($array)];                            ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||
||=================OPTIONS - FEMTOSECONDS PER ITERATION=================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||           803 |           466 |           390 |           384 |           373 |           764 |     1.046.642 ||           691 |           252 |           101 |           128 |            93 |           170 |        89.028 ||           695 |           235 |            90 |            97 |            95 |           188 |        87.991 ||
||  2.  $x = array_slice($array, -1)[0];                                ||           414 |           349 |           252 |           248 |           246 |           604 |     1.038.074 ||           373 |           249 |            85 |            91 |            90 |           164 |        90.750 ||           367 |           224 |            78 |            85 |            80 |           155 |        86.141 ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||           724 |           228 |           323 |           318 |           350 |           673 |     1.042.263 ||           988 |           285 |           309 |           317 |           331 |           401 |        88.363 ||           877 |           266 |           298 |           300 |           326 |           403 |        87.279 ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||           734 |           266 |           358 |           356 |           349 |           699 |     1.050.101 ||           887 |           288 |           316 |           322 |           314 |           408 |        88.402 ||           935 |           268 |           335 |           315 |           313 |           403 |        86.445 ||
||  5.  $x = end($array); reset($array);                                ||           715 |           186 |           185 |           180 |           176 |           185 |           172 ||           674 |            73 |            69 |            70 |            66 |            65 |            70 ||           693 |            65 |            85 |            74 |            68 |            70 |            69 ||
||  6.  $x = end((array_values($array)));                               ||           877 |           205 |           320 |           337 |           304 |         2.901 |     7.921.860 ||           948 |           300 |           336 |           308 |           309 |           509 |    29.696.951 ||           946 |           262 |           301 |           309 |           302 |           499 |    29.234.928 ||
||  7.  $x = $array[count($array)-1];                                   ||           123 |           300 |           137 |           139 |           143 |           140 |           144 ||           312 |           218 |            48 |            53 |            45 |            47 |            51 ||           296 |           217 |            46 |            44 |            53 |            53 |            55 ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||           494 |           593 |           418 |           435 |           399 |         3.873 |    12.199.450 ||           665 |           407 |           103 |           109 |           114 |           431 |    30.053.730 ||           647 |           445 |            91 |            95 |            96 |           419 |    30.718.586 ||
||  9.  $x = $array[] = array_pop($array);                              ||           186 |           178 |           175 |           188 |           180 |           181 |           186 ||            83 |            78 |            75 |            71 |            74 |            69 |            83 ||            71 |            64 |            70 |            64 |            68 |            69 |            81 ||
|| 10.  $x = $array[array_key_last($array)];                            ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           370 |           223 |            49 |            52 |            61 |            57 |            52 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/ 

Yukarıda belirtilen F Atal, B UYARI ve N kodları olarak tercüme otice:

F1 = Fatal error: Call to undefined function array_key_last() in Command line code on line 1
F2 = Fatal error: Uncaught Error: Call to undefined function array_key_last() in Command line code:1
W1 = Warning: array_slice() expects parameter 1 to be array, null given in Command line code on line 1
W2 = Warning: array_values() expects parameter 1 to be array, null given in Command line code on line 1
W3 = Warning: array_pop() expects parameter 1 to be array, null given in Command line code on line 1
W4 = Warning: end() expects parameter 1 to be array, null given in Command line code on line 1
W5 = Warning: reset() expects parameter 1 to be array, null given in Command line code on line 1
W6 = Warning: array_keys() expects parameter 1 to be array, null given in Command line code on line 1
W7 = Warning: count(): Parameter must be an array or an object that implements Countable in Command line code on line 1
W8 = Warning: array_key_last() expects parameter 1 to be array, null given in Command line code on line 1
N1 = Notice: Undefined offset: 0 in Command line code on line 1
N2 = Notice: Only variables should be passed by reference in Command line code on line 1
N3 = Notice: Undefined offset: -1 in Command line code on line 1
N4 = Notice: Undefined index:  in Command line code on line 1

Bu çıktıya dayanarak aşağıdaki sonuçları çıkarıyorum:

• PHP'nin daha yeni sürümleri, önemli ölçüde yavaşlayan bu seçenekler dışında daha iyi performans gösterir:
  • seçenek .6. $x = end((array_values($array)));
  • seçenek .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
• bu seçenekler çok büyük diziler için en iyi ölçeği oluşturur:
  • seçenek .5. $x = end($array); reset($array);
  • seçenek .7. $x = $array[count($array)-1];
  • seçenek .9. $x = $array[] = array_pop($array);
  • seçenek 10. $x = $array[array_key_last($array)]; (PHP 7.3'ten beri)
• bu seçenekler yalnızca otomatik dizinli diziler için kullanılmalıdır :
  • seçenek .7. $x = $array[count($array)-1];(kullanımı nedeniylecount)
  • seçenek .9. $x = $array[] = array_pop($array);(değer kaybeden orijinal anahtarın atanması nedeniyle)
• bu seçenek dizinin dahili işaretçisini korumaz
  • seçenek .5. $x = end($array); reset($array);
• bu seçenek, seçenek .5'i değiştirme girişimidir . dizinin dahili işaretçisini korumak için (ama ne yazık ki çok büyük diziler için iyi ölçeklenmiyor)
  • seçenek .6. $x = end((array_values($array)));
• yeni array_key_lastişlevin, bu yazma sırasında hala bir RC olması dışında, yukarıda belirtilen sınırlamalardan hiçbirine sahip olmadığı görülüyor (bu nedenle RC'yi kullanın veya Aralık 2018'de yayınlanmasını bekleyin):
  • seçenek 10. $x = $array[array_key_last($array)]; (PHP 7.3'ten beri)

Diziyi yığın olarak mı yoksa kuyruk olarak mı kullandığınıza bağlı olarak , seçenek 9'da varyasyon yapabilirsiniz.

Deneyin

$myLastElement = end($yourArray);

Sıfırlamak için (teşekkürler @hopeseekr):

 reset($yourArray);

Bağlantı kılavuzu

@David Murdoch ekledi: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). E_STRICT'de bu uyarı veriyor

Strict Standards: Only variables should be passed by reference

Teşekkürler o_O Tync ve herkese!

Kısa ve güzel.

Hata mesajını kaldırmak ve tek katmanlı formu ve verimli performansı korumak için bir çözüm buldum:

$lastEl = array_values(array_slice($array, -1))[0];

- önceki çözüm

$lastEl = array_pop((array_slice($array, -1)));

Not: Ek parantezler a PHP Strict standards: Only variables should be passed by reference.

Sorun nedir array_slice($array, -1)? (Bkz. Kılavuz: http://us1.php.net/array_slice )

array_slice()bir dizi döndürür. Muhtemelen aradığın şey değil. Elemanı istiyorsunuz.

Referans by-pass hatalarından kaçınmanın bir yolu (örn. "End (dizi_değerleri ($ foo))") call_user_func veya call_user_func_array kullanmaktır:

// PHP Fatal error: Only variables can be passed by reference
// No output (500 server error)
var_dump(end(array(1, 2, 3)));

// No errors, but modifies the array's internal pointer
// Outputs "int(3)"
var_dump(call_user_func('end', array(1, 2, 3)));

// PHP Strict standards:  Only variables should be passed by reference
// Outputs "int(3)"
var_dump(end(array_values(array(1, 2, 3))));

// No errors, doesn't change the array
// Outputs "int(3)"
var_dump(call_user_func('end', array_values(array(1, 2, 3))));

Dahili işaretçiyi değiştirmeyi umursamıyorsanız (hem dizine eklenen hem de ilişkilendirilebilir dizileri destekler):

// false if empty array
$last = end($array);

// null if empty array
$last = !empty($array) ? end($array) : null;

Dahili işaretçiyi değiştirmeyen bir yardımcı program işlevi istiyorsanız (dizi değere göre iletildiğinden ve işlev bir kopyası üzerinde çalıştığından):

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    return end($array);
}

PHP'nin "anında" kopyalar ürettiğini, yani yalnızca gerçekten gerektiğinde kopyaladığını unutmayın. end()Kendisi dizi, bu nedenle içten dizinin bir kopyası oluşturulur değiştirir.

Bu nedenle, aşağıdaki alternatif aslında diziyi kopyalamadığı için sadece daha hızlıdır, sadece bir dilim yapar:

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    foreach (array_slice($array, -1) as $value) {
        return $value;
    }
}

Bu "foreach / return", ilk (ve burada tekli) öğeyi verimli bir şekilde almak için yapılan bir değişikliktir.

Son olarak, yalnızca dizinlenmiş diziler için en hızlı alternatif:

$last = !empty($array) ? $array[count($array)-1] : null;

Kayıt için, dizinin ilk öğesi için benim başka bir cevabım .

denenmemiş: bu işe yaramaz mı?

<?php
$last_element=end(array_values($array));
?>

Array_values ​​tarafından döndürülen dizi geçici olduğundan, hiç kimse işaretçinin sıfırlanıp sıfırlanmadığını umursamıyor.

ve onunla gitmek için anahtara ihtiyacınız varsa sanırım bunu yaparsınız:

<?php
$last_key=end(array_keys($array));
?>

Ben yığınları ile başa çıkmak için bu oldukça sık ihtiyacım var ve her zaman kendimi şaşkın bulmak dizisi veya herhangi bir biçimde iç işaretçisini manipüle etmeden hiçbir yerel işlevi yoktur.

Bu yüzden genellikle ilişkisel dizilerde de kullanımı güvenli bir util işlevi taşırım.

function array_last($array) {
    if (count($array) < 1)
        return null;

    $keys = array_keys($array);
    return $array[$keys[sizeof($keys) - 1]];
}

Bir dizinin son öğesini almak için şunu kullanın:

$lastElement = array_slice($array, -1)[0];

Karşılaştırma

1000 kez yineledim, sırasıyla 100 ve 50.000 eleman içeren küçük ve büyük dizilerin son elemanını yakaladım.

Method: $array[count($array)-1];
Small array (s): 0.000319957733154
Large array (s): 0.000526905059814
Note: Fastest!  count() must access an internal length property.
Note: This method only works if the array is naturally-keyed (0, 1, 2, ...).

Method: array_slice($array, -1)[0];
Small array (s): 0.00145292282104
Large array (s): 0.499367952347

Method: array_pop((array_slice($array, -1, 1)));
Small array (s): 0.00162816047668
Large array (s): 0.513121843338

Method: end($array);
Small array (s): 0.0028350353241
Large array (s): 4.81077480316
Note: Slowest...

PHP Sürüm 5.5.32 kullandım.

end (), bir dizinin son öğesini sağlayacaktır

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
echo end($array); //output: c

$array1 = array('a', 'b', 'c', 'd');
echo end($array1); //output: d

PHP sürümü 7.3 fonksiyonları itibariyle array_key_firstve array_key_lasttanıtıldı.

PHP'deki diziler katı dizi türleri olmadığı için, yani dizin 0'dan başlayan sabit boyutlu alanların sabit boyutlu koleksiyonları, ancak dinamik olarak genişletilmiş ilişkisel dizi olduğundan, bilinmeyen anahtarlarla konumların işlenmesi zordur ve geçici çözümler çok iyi performans göstermez. Buna karşılık, gerçek diziler dahili olarak işaretçi aritmetikleri yoluyla çok hızlı bir şekilde ele alınacak ve son indeks derleme zamanında deklarasyon ile bilinmektedir.

En azından ilk ve son konumdaki sorun, 7.3 sürümünden bu yana yerleşik işlevlerle çözüldü. Bu , kutudan çıkarılmış dizi değişmezleri üzerinde herhangi bir uyarı olmadan bile çalışır :

$first = array_key_first( [1, 2, 'A'=>65, 'B'=>66, 3, 4 ] );
$last  = array_key_last ( [1, 2, 'A'=>65, 'B'=>66, 3, 4 ] );

Açıkçası son değer :

$array[array_key_last($array)];

$lastValue = end(array_values($array))

$ Dizi işaretçileri üzerinde hiçbir değişiklik yapılmaz. Bu,

reset($array)

bazı durumlarda istenmeyebilir.

Benim için:

$last = $array[count($array) - 1];

İlişkilendirmelerle:

$last =array_values($array)[count($array - 1)]

En iyi cevaplar harika, ancak @ paul-van-leeuwen ve @ quasimodos-clone tarafından belirtildiği gibi, PHP 7.3 bu sorunu doğrudan çözmek için iki yeni işlev sunacaktır - array_key_first () ve array_key_last () .

Bu sözdizimini bugün aşağıdaki çoklu dolgu (veya dolgu) işlevleriyle kullanmaya başlayabilirsiniz.

// Polyfill for array_key_last() available from PHP 7.3
if (!function_exists('array_key_last')) {
  function array_key_last($array) {
    return array_slice(array_keys($array),-1)[0];
  }
}

// Polyfill for array_key_first() available from PHP 7.3
if (!function_exists('array_key_first')) {
  function array_key_first($array) {
    return array_slice(array_keys($array),0)[0];
  }
}

// Usage examples:
$first_element_key   = array_key_first($array);
$first_element_value = $array[array_key_first($array)];

$last_element_key    = array_key_last($array);
$last_element_value  = $array[array_key_last($array)];

Dikkat: Bu, PHP 5.4 veya üstünü gerektirir.

Bunu yapmak ve dizinin dahili işaretçisini karıştırmamak için E_STRICT'den kaçınmak için şunları kullanabilirsiniz:

function lelement($array) {return end($array);}

$last_element = lelement($array);

lelement yalnızca bir kopyayla çalışır, böylece dizinin işaretçisini etkilemez.

Başka bir çözüm:

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
$lastItem = $array[(array_keys($array)[(count($array)-1)])];
echo $lastItem;

Bir olası çözüm daha ...

$last_element = array_reverse( $array )[0];

Nasıl olur:

current(array_slice($array, -1))

• çağrışımlı diziler için çalışır
• ne zaman çalışır $array == [](döner false)
• orijinal diziyi etkilemez

Aşağıdaki mantığı kullanarak bir dizideki son öğeyi kolayca alacaksınız

$array = array('a', 'b', 'c', 'd');
echo ($array[count($array)-1]);

Sadece son eleman değil, aynı zamanda aşağıdaki mantığı kullanarak ikinci son, üçüncü son ve benzerlerini de alabilirsiniz.

ikinci son eleman için yukarıdaki ifadede sadece 2 sayısını geçmeniz gerekir, örneğin:
echo ($ array [count ($ array) -2]);

Diziden son değeri almak için:

array_slice($arr,-1,1) ;

Son değer form dizisini kaldırmak için:

array_slice($arr,0,count($arr)-1) ;

basitçe: $last_element = end((array_values($array)))

Diziyi sıfırlamaz ve STRICT uyarıları vermez.

PS. En çok oy verilen cevap hala çift parantez olmadığından, bu cevabı gönderdim.

Bence bu mevcut cevapların tamamında küçük bir gelişme:

$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;

• Özellikle büyük dizilerde end()kullanılanlardan daha iyi performans veya çözümlerarray_keys()
• Dizinin dahili işaretçisini değiştirmeyecek
• Boş diziler için tanımlanmamış bir ofsete erişmeye çalışmaz
• Boş diziler, dizinlenmiş diziler, karışık diziler ve ilişkilendirilebilir diziler için beklendiği gibi çalışır

End () işlevini kullanın.

$array = [1,2,3,4,5];
$last = end($array); // 5

Bugünlerde, bir php.net/end cevabında önerildiği gibi, her zaman bu yardımcıya sahip olmayı tercih ederim .

<?php
function endc($array) {
    return end($array);
}

$items = array('one','two','three');
$lastItem = endc($items); // three
$current = current($items); // one
?>

Bu, işaretçiyi her zaman olduğu gibi tutacaktır ve asla parantez, katı standartlar veya herhangi bir şey hakkında endişelenmemiz gerekmeyecektir.

Not: (PHP 7> = 7.3.0) için array_key_last kullanabiliriz - Bir dizinin son anahtarını döndürür

array_key_last ( array $array ) : mixed

Ref: http://php.net/manual/tr/function.array-key-last.php

Dizinin son öğesini dizisinin döngüsünün içine almak isterseniz ne olur?

Aşağıdaki kod sonsuz bir döngüye neden olacaktır:

foreach ($array as $item) {
 $last_element = end($array);
 reset($array);
 if ($last_element == $item) {
   // something useful here
 }
}

Çözüm, ilişkisel olmayan diziler için açıktır:

$last_element = $array[sizeof ($array) - 1];
foreach ($array as $key => $item) {
 if ($last_element == $item) {
   // something useful here
 }
}

$file_name_dm =  $_FILES["video"]["name"];    

                           $ext_thumb = extension($file_name_dm);

                            echo extension($file_name_dm); 
function extension($str){
    $str=implode("",explode("\\",$str));
    $str=explode(".",$str);
    $str=strtolower(end($str));
     return $str;
}

PHP 7.3'ten itibaren array_key_lastkullanılabilir

$lastEl = $myArray[array_key_last($myArray)];

Çok basit

$array = array('a', 'b', 'c', 'd');
end($array)

benim basit çözümüm, güzel ve kolay anlaşılır.

array_reverse($array)[0];