Apa cara terbaik untuk mendapatkan elemen terakhir dari array tanpa menghapusnya?

Baik,

Saya tahu semua tentang array_pop(), tetapi itu menghapus elemen terakhir. Apa cara terbaik untuk mendapatkan elemen terakhir dari array tanpa menghapusnya?

EDIT: Ini bonusnya:

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

atau bahkan

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

Banyak jawaban di utas ini memberi kami banyak pilihan berbeda. Untuk dapat memilih dari mereka, saya perlu memahami perilaku dan kinerja mereka. Dalam jawaban ini saya akan membagikan temuan saya dengan Anda, mengacu pada versi PHP 5.6.38, 7.2.10dan 7.3.0RC1( diharapkan 13 Desember 2018 ).

Opsi yang <<option code>>akan saya uji adalah:

• Pilihan 1. $x = array_values(array_slice($array, -1))[0];( seperti yang disarankan oleh rolacja )
• pilihan 2. $x = array_slice($array, -1)[0];( seperti yang disarankan oleh Stoutie )
• opsi .3. $x = array_pop((array_slice($array, -1)));( seperti yang disarankan oleh rolacja )
• opsi .4. $x = array_pop((array_slice($array, -1, 1)));( seperti yang disarankan oleh Westy92 )
• opsi .5. $x = end($array); reset($array);( seperti yang disarankan oleh Iznogood )
• opsi .6. $x = end((array_values($array)));( seperti yang disarankan oleh TecBrat )
• opsi .7. $x = $array[count($array)-1];( seperti yang disarankan oleh Mirko Pagliai )
• opsi .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( seperti yang disarankan oleh thrau )
• opsi .9. $x = $array[] = array_pop($array);( seperti yang disarankan oleh user2782001 )
• opsi 10. $x = $array[array_key_last($array)]; ( seperti yang disarankan oleh klon Quasimodo ; tersedia per PHP 7.3)

(fungsi yang disebutkan: array_key_last , array_keys , array_pop , array_slice , array_values , count , end , reset )

Input tes yang <<input code>>akan digabungkan dengan:

• null =$array = null;
• kosong =$array = [];
• last_null =$array = ["a","b","c",null];
• auto_idx =$array = ["a","b","c","d"];
• shuffle =$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; }

Untuk pengujian saya akan menggunakan 5.6.38, 7.2.10dan 7.3.0RC1 kontainer PHP docker seperti:

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

Setiap kombinasi dari <<option code>>s dan s yang tercantum di <<input code>>atas akan dijalankan pada semua versi PHP. Untuk setiap tes yang dijalankan, cuplikan kode berikut digunakan:

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

Untuk setiap proses, ini akan var_dump nilai terakhir yang diambil dari input tes dan mencetak durasi rata-rata satu iterasi dalam femtoseconds (0,00000000000000001 per detik).

Hasilnya adalah sebagai berikut:

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            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 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/ 

Yang disebutkan di atas F atal, W eringatan dan N otice Kode diterjemahkan sebagai:

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

Berdasarkan hasil ini saya menarik kesimpulan sebagai berikut:

• versi PHP yang lebih baru berkinerja lebih baik dengan pengecualian opsi ini yang menjadi lebih lambat:
  • opsi .6. $x = end((array_values($array)));
  • opsi .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
• skala opsi ini paling baik untuk array yang sangat besar:
  • opsi .5. $x = end($array); reset($array);
  • opsi .7. $x = $array[count($array)-1];
  • opsi .9. $x = $array[] = array_pop($array);
  • opsi 10. $x = $array[array_key_last($array)]; (sejak PHP 7.3)
• opsi ini hanya boleh digunakan untuk array yang diindeks otomatis :
  • opsi .7. $x = $array[count($array)-1];(karena penggunaancount)
  • opsi .9. $x = $array[] = array_pop($array);(karena menetapkan nilai kehilangan kunci asli)
• opsi ini tidak mempertahankan pointer internal array
  • opsi .5. $x = end($array); reset($array);
• opsi ini merupakan upaya untuk memodifikasi opsi .5. untuk mempertahankan pointer internal array (tapi sayangnya itu tidak skala dengan baik untuk array yang sangat besar)
  • opsi .6. $x = end((array_values($array)));
• array_key_lastfungsi baru tampaknya tidak memiliki keterbatasan yang disebutkan di atas dengan pengecualian masih menjadi RC pada saat penulisan ini (jadi gunakan RC atau tunggu rilisnya 2018):
  • opsi 10. $x = $array[array_key_last($array)]; (sejak PHP 7.3)

Sedikit tergantung pada apakah menggunakan array sebagai stack atau sebagai antrian, Anda dapat membuat variasi pada opsi 9.

Mencoba

$myLastElement = end($yourArray);

Untuk meresetnya (terima kasih @hopeseekr):

 reset($yourArray);

Tautan ke manual

@ David Murdoch menambahkan: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). Pada E_STRICT ini menghasilkan peringatan

Strict Standards: Only variables should be passed by reference

Terima kasih o_O Tync dan semuanya!

Pendek dan manis.

Saya datang dengan solusi untuk menghapus pesan kesalahan dan mempertahankan bentuk satu-liner dan kinerja yang efisien:

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

- solusi sebelumnya

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

Catatan: Tanda kurung tambahan diperlukan untuk menghindari a PHP Strict standards: Only variables should be passed by reference.

Ada apa dengan ini array_slice($array, -1)? (Lihat Manual: http://us1.php.net/array_slice )

array_slice()mengembalikan array. Mungkin bukan yang Anda cari. Anda menginginkan elemen.

Salah satu cara untuk menghindari kesalahan pass-by-reference (mis. "End (array_values ​​($ foo))") adalah dengan menggunakan call_user_func atau call_user_func_array:

// 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))));

Jika Anda tidak peduli tentang memodifikasi pointer internal (mendukung array yang diindeks dan asosiatif):

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

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

Jika Anda menginginkan fungsi utilitas yang tidak mengubah pointer internal (karena array dilewatkan oleh nilai, dan fungsi beroperasi pada salinannya):

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

Perhatikan bahwa PHP menghasilkan salinan "on-the-fly", yaitu hanya ketika benar-benar dibutuhkan. Itu end()sendiri memodifikasi array, sehingga secara internal salinan array dihasilkan.

Jadi, alternatif berikut ini sebenarnya lebih cepat karena secara internal tidak menyalin array, itu hanya membuat irisan:

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

Ini "foreach / return" adalah tweak untuk secara efisien mendapatkan item pertama (dan di sini tunggal).

Akhirnya, alternatif tercepat tetapi hanya untuk array yang diindeks:

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

Sebagai catatan, inilah jawaban saya yang lain , untuk elemen pertama array.

belum diuji: bukankah ini akan berhasil?

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

Karena array yang dikembalikan oleh array_values ​​cepat, tidak ada yang peduli jika pointernya diatur ulang.

dan jika Anda memerlukan kunci untuk menggunakannya, saya kira Anda akan melakukannya:

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

Saya perlu ini cukup sering untuk berurusan dengan tumpukan, dan saya selalu merasa bingung bahwa tidak ada fungsi asli yang melakukannya tanpa memanipulasi array atau pointer internal dalam beberapa bentuk.

Jadi saya biasanya membawa fungsi util yang juga aman untuk digunakan pada array asosiatif.

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

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

Untuk mendapatkan elemen terakhir dari sebuah array, gunakan:

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

Tolok ukur

Saya mengulangi 1.000 kali, meraih elemen terakhir dari array kecil dan besar yang masing-masing berisi 100 dan 50.000 elemen.

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

Saya menggunakan PHP Versi 5.5.32.

end () akan memberikan elemen terakhir dari sebuah array

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

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

Pada PHP versi 7.3 fungsi array_key_firstdan array_key_lasttelah diperkenalkan.

Karena array dalam PHP bukan tipe array yang ketat, yaitu koleksi berukuran tetap bidang berukuran tetap mulai dari indeks 0, tetapi array asosiatif diperpanjang secara dinamis, penanganan posisi dengan kunci yang tidak diketahui sulit dan penyelesaiannya tidak berkinerja baik. Sebaliknya array nyata akan ditangani secara internal melalui pointer arithmethics dengan sangat cepat dan indeks terakhir sudah diketahui pada saat kompilasi oleh deklarasi.

Setidaknya masalah dengan posisi pertama dan terakhir diselesaikan oleh fungsi builtin sekarang sejak versi 7.3. Ini bahkan berfungsi tanpa peringatan pada literal array di luar kotak:

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

Jelas yang terakhir nilai adalah:

$array[array_key_last($array)];

$lastValue = end(array_values($array))

Tidak ada modifikasi yang dilakukan pada $ array pointer. Ini menghindari

reset($array)

yang mungkin tidak diinginkan dalam kondisi tertentu.

Untuk saya:

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

Dengan asosiatif:

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

Jawaban teratasnya bagus, tetapi seperti yang disebutkan oleh @ paul-van-leeuwen dan @ quasimodos-clone, PHP 7.3 akan memperkenalkan dua fungsi baru untuk menyelesaikan masalah ini secara langsung - array_key_first () dan array_key_last () .

Anda dapat mulai menggunakan sintaks ini hari ini dengan fungsi polyfill (atau shim) berikut.

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

Peringatan: Ini membutuhkan PHP 5.4 atau lebih tinggi.

Untuk melakukan ini dan menghindari E_STRICT dan tidak mengacaukan dengan pointer internal array yang dapat Anda gunakan:

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

$last_element = lelement($array);

lelement hanya berfungsi dengan salinan sehingga tidak mempengaruhi pointer array.

Solusi lain:

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

Satu lagi solusi yang mungkin ...

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

Bagaimana tentang:

current(array_slice($array, -1))

• bekerja untuk array asosiatif
• bekerja ketika $array == [](kembali false)
• tidak memengaruhi array asli

Anda akan mendapatkan elemen terakhir dari array dengan mudah menggunakan logika di bawah ini

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

Tidak hanya elemen terakhir tetapi Anda juga bisa mendapatkan kedua terakhir, ketiga terakhir dan seterusnya dengan menggunakan logika di bawah ini.

untuk elemen terakhir kedua Anda harus melewati angka 2 saja dalam pernyataan di atas misalnya:
echo ($ array [count ($ array) -2]));

Untuk mendapatkan nilai terakhir dari Array:

array_slice($arr,-1,1) ;

Untuk Menghapus array formulir nilai terakhir:

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

Secara sederhana: $last_element = end((array_values($array)))

Tidak mengatur ulang array dan tidak memberikan peringatan STRICT.

PS. Karena jawaban yang paling banyak dipilih masih belum memiliki tanda kurung ganda, saya mengirimkan jawaban ini.

Saya pikir ini sedikit perbaikan pada semua jawaban yang ada:

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

• Berkinerja lebih baik daripada end()atau menggunakan solusi array_keys(), terutama dengan array besar
• Tidak akan mengubah pointer internal array
• Tidak akan mencoba mengakses offset yang tidak ditentukan untuk array kosong
• Akan berfungsi seperti yang diharapkan untuk array kosong, array yang diindeks, array campuran, dan array asosiatif

Gunakan fungsi end ().

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

Saat ini, saya lebih suka selalu memiliki pembantu ini, seperti yang disarankan di jawaban php.net/end .

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

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

Ini akan selalu membuat pointer seperti itu dan kita tidak akan pernah perlu khawatir tentang tanda kurung, standar ketat atau apa pun.

Catatan: Untuk (PHP 7> = 7.3.0) kita dapat menggunakan array_key_last - Mendapat kunci terakhir dari array

array_key_last ( array $array ) : mixed

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

Bagaimana jika Anda ingin mendapatkan elemen terakhir dari array di dalam loop dari array itu?

Kode di bawah ini akan menghasilkan loop tak terhingga:

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

Solusinya jelas sederhana untuk array non asosiatif:

$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;
}

Pada PHP 7.3, array_key_lasttersedia

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

Sangat sederhana

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

solusi sederhana saya, cantik dan mudah dimengerti.

array_reverse($array)[0];