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

427

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
Theodore R. Smith
sumber
11
Percaya atau tidak muncul dan memasangnya kembali adalah salah satu cara tercepat saya melakukan benchmark ini. $ val = $ array [] = array_pop ($ array); echo $ val;
user2782001
2
Pertanyaan ini menghasilkan banyak pilihan. Untuk membantu saya memilih, saya melakukan perbandingan beberapa opsi yang paling terkenal / berbeda dan membagikan hasilnya sebagai jawaban terpisah . (: @ user2782001 menyarankan favorit saya sejauh ini di komentar di atas. :) Terima kasih kepada semua untuk kontribusi!
Paul van Leeuwen
1
@TheodoreRSmith Ketika PHP 7.3 dirilis, Anda dapat mempertimbangkan untuk membuat ( saran oleh klon Quasimodo ini sebagai 'jawaban yang diterima' (untuk pertimbangan Anda) ...
Paul van Leeuwen

Jawaban:

176

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:

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

Paul van Leeuwen
sumber
Jika Anda menemukan opsi tertentu yang hilang, Anda dapat mengujinya sendiri dengan menyalin-rekatkan potongan kode di atas, membandingkannya dengan opsi yang sebelumnya telah diuji. Untuk menambahkan opsi ke daftar ini akan menguji ulang semua kombinasi untuk hasil kinerja yang sebanding. Jika Anda memiliki opsi tertentu yang menurut Anda harus ditambahkan, silakan beri komentar, saya ingin menambahkannya (walaupun mungkin perlu waktu).
Paul van Leeuwen
1
Jawaban yang sangat bagus, satu komentar: untuk opsi array asosiatif 9 tidak dapat digunakan juga, karena kami menetapkan kembali ke kunci yang diindeks otomatis daripada nama kunci sebelumnya.
Gras Double
1
Ringkasan yang bagus! Silakan tambahkan jawaban saya menggunakan PHP 7.3 yang baru. berfungsi $array[array_key_last($array)];untuk tolok ukur Anda. Dan tolong beri saya beberapa pemberitahuan ketika selesai. Saya ingin melihat hasil kinerja sebagai perbandingan.
Klon Quasimodo
2
@sz itu sebagian besar diproduksi dengan banyak keras kepala dan kesabaran tetapi pemilihan umum dan fungsi edit multi-baris dari Sublime text editor membantu. regenerasi itu memakan waktu hampir sehari, jadi jika saya perlu melakukannya lagi saya mungkin akan menulis sesuatu yang mengubah output dari semua 210 eksekusi docker ke tabel secara otomatis :-)
Paul van Leeuwen
1
@ quasimodos-clone I membuat ulang seluruh tabel berdasarkan rilis PHP 5, 7 dan RC Anda terbaru. Saya kira kita akan ingin membuatnya lagi Desember mendatang ketika itu sebenarnya dirilis. Terima kasih telah membawa fungsi baru ini menjadi perhatian semua orang.
Paul van Leeuwen
487

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!

Iznogood
sumber
38
Gunakan $myLastElement = end(array_values($yourArray));dan sekarang Anda tidak perlu menelepon reset().
David Murdoch
5
@ Davidvidurochoch Mungkin, tapi itu pasti mengocok RAM dan CPU, menciptakan array temp untuk nilai-nilai array ...
Theodore R. Smith
12
Jika server Anda menggunakan terlalu banyak RAM sehingga memanggil satu fungsi tambahan sederhana adalah pemecah kesepakatan, saya sarankan Anda memeriksa kembali konfigurasi dan sumber daya server Anda.
Chris Baker
3
end(array_values())akan memberikan E_STRICT: "Hanya variabel yang harus dilewatkan dengan referensi"
kolypto
32
Tambahkan tanda kurung tambahan untuk menghindari peringatan ketat:end((array_values($yourArray)))
Daniel W.
212

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.

rolacja
sumber
31
Setelah tepat 5 tahun, 6 bulan dan 2 hari, Anda telah mengirimkan jawaban yang lebih unggul !! Terima kasih! dan terima kasih Stack Overflow !!
Theodore R. Smith
1
Sambut jawaban, tetapi menambahkan tanda kurung tambahan terasa sedikit hackisch. PhpStorm juga akan menandai ini sebagai kesalahan. Info tambahan untuk menambahkan tanda kurung tambahan ( phpsadness.com/sad/51 ). Untuk mengatasi kesalahan, Anda bisa menjadikan ini sebagai '2-liner': $array = array_slice($array, -1); $lastEl = array_pop($array);Secara pribadi saya pikir ini lebih baik (tanpa 'bug' parser)
Maurice
3
Anda dapat menggunakan dereferencing seperti ini: array_slice ($ array, -1) [0]
Vikash
1
Anda tidak bisa jika Anda memiliki string sebagai indeks dalam array
rolacja
3
Jawaban ini masih membutuhkan setidaknya dua pemeriksaan untuk menghindari pemberitahuan PHP. 1. periksa apakah array_size() > 1 2. Periksa apakah array sebenarnya adalah array. Saya masih berpegang pada jawaban oleh @Iznogood karena end()fungsi built-in PHP sudah melakukan semua kerja keras dengan cara yang lebih efisien.
Ema4rl
37

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.

Stoutie
sumber
21
Gunakan array_slice($array, -1)[0]untuk mendapatkan elemen.
Pang
2
Ini jawabannya. "end" Mengubah pointer internal array? Meminta masalah, dan sangat sulit dibaca!
Gerard ONeill
Sukai pendekatan ini, meskipun seperti yang ditunjukkan oleh @Pang, itu tidak cukup lengkap. reset(array_slice($array, -1))adalah pendekatan lain (yang tidak akan menyebabkan kesalahan jika array_slice()mengembalikan sesuatu yang "lebih kecil" dari satu elemen array)
rinogo
Pendekatan terbaik karena Anda dapat langsung memodifikasi elemen:array_slice($array, -1)[0] = "";
HAlex
20

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))));
Warbo
sumber
Pendekatan hebat! (masukkan standar 'Ini seharusnya jawaban yang diterima' di sini)
Typo
3
Atau cukup tambahkan paranthesis tambahan. Lebih pendek dan lebih manis:end((array_values($yourArray)))
Dzhuneyt
4
Trik tanda kurung tambahan bergantung pada bug di PHP, dan pendekatan itu tidak lagi berfungsi di versi PHP yang lebih baru (atau setidaknya, tidak di PHP 7).
Matt Browne
1
Dan call_user_functriknya juga tidak berfungsi di PHP 7. Saya pikir Anda terjebak dengan membuat variabel sementara.
Matt Browne
15

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.

Gras Double
sumber
Anda memberikan 2 implementasi alternatif untuk suatu array_lastfungsi. Untuk yang pertama, Anda menyatakan bahwa yang $arraydisalin dan yang kedua yang tidak disalin. Di mana perbedaan / mengapa itu disalin dalam implementasi pertama dan bukan pada yang kedua?
Paul van Leeuwen
1
@ PaulvanLeeuwen Saya mengerti mengapa Anda bingung. Saya mencoba mengklarifikasi jawabannya , apakah lebih baik?
Gras Double
10

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));
?>
TecBrat
sumber
9

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]];
}
thrau
sumber
1
Berita bagus, mereka menjadikannya fungsi asli :-) Anda dapat mengawasi perencanaan rilisnya di sini: wiki.php.net/todo/php73 (diharapkan pada 13 Desember 2018 saat penulisan ini).
Paul van Leeuwen
9

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.

Westy92
sumber
bagaimana dengan menggunakan $ array [array_keys ($ array) [count (array_keys ($ array)) - 1]]?
user2782001
hmm..array_keys tampaknya berskala cukup buruk.
user2782001
1
Ini sebenarnya gila lebih cepat untuk array besar (0,0002) untuk pop item dan meletakkannya kembali ... $ val = $ ar [] = $ array_pop ($ ar);
user2782001
1
@ Westy92 Unit Anda tampak salah pada tolok ukur. Angka terkecil yang Anda berikan adalah 0,00031 ... mikrodetik yaitu sekitar 0,3 nanodetik. Itu berarti bahwa pengujian Anda memerlukan satu tick jam untuk dijalankan jika Anda memiliki komputer yang baru. Saya kira Anda berarti milidetik atau bahkan beberapa detik .
cesoid
1
Nilai-nilai jelas beberapa urutan besarnya salah. Kenapa sih fokus pada kinerja?
istepaniuk
6

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
Ajith
sumber
1
Solusi ini berfungsi, tetapi itu mengubah pointer internal array, saya tidak berpikir itu adalah cara yang benar.
UnixAgain
5

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)];
Kloning Quasimodo
sumber
1
Terima kasih telah membawa ini menjadi perhatian semua orang. Bagi mereka yang ingin menggunakan ini: mohon jangan bahwa ini adalah RC pada saat penulisan ini. Ini dijadwalkan untuk rilis Desember 2018.
Paul van Leeuwen
1
Ini berita bagus. Saya baru saja memposting polyfill / shim dalam jawaban saya di bawah ini sehingga orang dapat mulai menggunakan sintaks ini segera.
Mark Thomson
3
$lastValue = end(array_values($array))

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

reset($array)

yang mungkin tidak diinginkan dalam kondisi tertentu.

Vihaan Verma
sumber
3

Untuk saya:

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

Dengan asosiatif:

$last =array_values($array)[count($array - 1)]
Mirko Pagliai
sumber
Harap berikan konteks untuk jawaban Anda.
Shawn
2
@Shawn Konteks apa? Tidak perlu konteks. Kode ditambahkan untuk array asosiatif.
Mirko Pagliai
3

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.

Mark Thomson
sumber
2

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.

Damiene
sumber
2

Solusi lain:

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

Satu lagi solusi yang mungkin ...

$last_element = array_reverse( $array )[0];
Charles Garrison
sumber
Tidak bekerja pada array asosiatif sepertinya bukan alasan yang cukup untuk menurunkan saya. Dari segi kualitas jawaban ini tidak lebih buruk daripada banyak jawaban lain untuk pertanyaan ini. Saya tidak mengerti mengapa saya melihat setidaknya 2 downvotes saat ini. (skor -2). Bagaimanapun, upvote bagi saya, tidak terlalu buruk.
Paul van Leeuwen
2

Bagaimana tentang:

current(array_slice($array, -1))
  • bekerja untuk array asosiatif
  • bekerja ketika $array == [](kembali false)
  • tidak memengaruhi array asli
Bouke Versteegh
sumber
2

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

Amzad Khan
sumber
1

Untuk mendapatkan nilai terakhir dari Array:

array_slice($arr,-1,1) ;

Untuk Menghapus array formulir nilai terakhir:

array_slice($arr,0,count($arr)-1) ;
Rishabh
sumber
1
array_slice($arr,-1,1)akan menghasilkan array lain dengan panjang 1, bukan elemen terakhir
Vic
Mari kita ambil contoh: $a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); Hasil:Array ( [0] => brown )
Rishabh
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.

Daan
sumber
1

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
Adelmar
sumber
Sayangnya itu tidak bekerja dengan array asosiatif, karena item slice mungkin memiliki kunci bernama.
Gras Double
Anda benar, diedit untuk menambahkan perbaikan ( array_valuespada irisan elemen tunggal)
Adelmar
1

Gunakan fungsi end ().

$array = [1,2,3,4,5];
$last = end($array); // 5
Brian Berneker
sumber
1
Perhatikan saja bahwa fungsi ini menggerakkan pointer array Anda ke posisi itu.
giovannipds
Perhatikan juga bahwa ini diposting sebagai jawaban 8 tahun sebelumnya. stackoverflow.com/a/3687368/1255289
miken32
1

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.

giovannipds
sumber
Sudah disebutkan di atas: stackoverflow.com/a/45333947/1255289
miken32
0

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

lokender singh
sumber
1
Ini sudah tercakup dalam beberapa jawaban lain.
miken32
tapi saya jawab lebih awal dari yang lain
lokender singh
-1

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
 }
}
Vadim Podlevsky
sumber
2
Saya tahu tentang fungsi end () dan reset (). Komentar saya terkait dengan loop seperti foreach atau saat Anda tidak dapat menggunakan fungsi-fungsi ini karena fungsi reset me-reset pointer bagian dalam array yang digunakan dalam loop untuk iterasi. Maaf untuk itu, pertanyaannya lebih sederhana, saya hanya ingin memberikan situasi yang lebih maju yang saya temui dalam proyek saya. Salam Hormat.
Vadim Podlevsky
Ini salah dalam banyak hal (array dengan duplikat, perbandingan tidak ketat ...) dan dalam hal apapun tidak benar-benar terkait dengan pertanyaan.
Tgr
gunakan fungsi end ($ array) untuk mendapatkan elemen terakhir, mengapa Anda tidak perlu menggunakan loop?
Mahak Choudhary
1
@ MahakChoudhary Komentar saya adalah tambahan untuk "bagaimana mendapatkan elemen terakhir dari array jika Anda melakukan beberapa manipulasi yang sudah ada di dalam loop array ini. Menggunakan end () akan mengatur ulang pointer bawaan dan memutus loop iterasi. Ceria!
Vadim Podlevsky
-1
$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;
}
Hussy Borad
sumber
-1

Pada PHP 7.3, array_key_lasttersedia

$lastEl = $myArray[array_key_last($myArray)];
Tagarikdi Djakouba
sumber
Ini telah disebutkan dalam beberapa jawaban lain.
miken32
-1

Sangat sederhana

$array = array('a', 'b', 'c', 'd');
end($array)
Jasmeen Maradeeya
sumber
Perlu disebutkan bahwa ini memiliki perilaku aneh jika Anda menggunakan array dengan celah. yaitu $a = array(); $a[2] = 'c'; $a[1] = 'b'; echo end($a); akan kembalib
Simon Zyx
Ini sudah diposting 9 tahun yang lalu. stackoverflow.com/a/3687368/1255289
miken32