Cách tốt nhất để có được phần tử cuối cùng của một mảng mà không xóa nó là gì?

Đồng ý,

Tôi biết tất cả về array_pop(), nhưng điều đó xóa phần tử cuối cùng. Cách tốt nhất để có được phần tử cuối cùng của một mảng mà không xóa nó là gì?

EDIT: Đây là một phần thưởng:

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

hoặc thậm chí

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

Nhiều câu trả lời trong chủ đề này trình bày cho chúng tôi với nhiều lựa chọn khác nhau. Để có thể chọn từ họ, tôi cần hiểu hành vi và hiệu suất của họ. Trong câu trả lời này, tôi sẽ chia sẻ những phát của tôi với bạn, làm chuẩn so với các phiên bản PHP 5.6.38, 7.2.10và 7.3.0RC1( dự kiến ngày 13 Tháng 12 năm 2018 ).

Các tùy chọn <<option code>>tôi sẽ kiểm tra là:

• lựa chọn 1. $x = array_values(array_slice($array, -1))[0];( theo đề xuất của rolacja )
• Lựa chọn 2. $x = array_slice($array, -1)[0];( theo đề xuất của Stoutie )
• tùy chọn .3. $x = array_pop((array_slice($array, -1)));( theo đề xuất của rolacja )
• tùy chọn .4. $x = array_pop((array_slice($array, -1, 1)));( theo đề xuất của Westy92 )
• tùy chọn .5. $x = end($array); reset($array);( theo đề xuất của Iznogood )
• tùy chọn .6. $x = end((array_values($array)));( theo đề xuất của TecBrat )
• tùy chọn .7. $x = $array[count($array)-1];( theo đề xuất của Mirko Pagliai )
• tùy chọn .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( theo đề xuất của thrau )
• tùy chọn .9. $x = $array[] = array_pop($array);( theo đề xuất của người dùng2782001 )
• tùy chọn 10. $x = $array[array_key_last($array)]; ( như được đề xuất bởi bản sao của Quasimodo ; có sẵn trên PHP 7.3)

(các hàm được đề cập: Array_key_last , Array_keys , Array_pop , Array_slice , Array_values , đếm , kết thúc , đặt lại )

(Các) đầu vào thử nghiệm <<input code>>để kết hợp với:

• null =$array = null;
• trống =$array = [];
• last_null =$array = ["a","b","c",null];
• auto_idx =$array = ["a","b","c","d"];
• xáo trộn =$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; }

Để thử nghiệm tôi sẽ sử dụng 5.6.38, 7.2.10và 7.3.0RC1 container Docker PHP như:

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

Mỗi kết hợp của các <<option code>>s và s được liệt kê ở trên <<input code>>sẽ được chạy trên tất cả các phiên bản PHP. Đối với mỗi lần chạy, đoạn mã sau được sử dụng:

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

Đối với mỗi lần chạy, điều này sẽ làm thay đổi giá trị cuối cùng được truy xuất cuối cùng của đầu vào kiểm tra và in thời lượng trung bình của một lần lặp tính bằng femtos giây (0,00000000000000001 giây).

Kết quả như sau:

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

Các mã F atal, W arning và N otice đã đề cập ở trên có nghĩa là:

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

Dựa trên đầu ra này, tôi rút ra kết luận sau:

• các phiên bản mới hơn của PHP hoạt động tốt hơn ngoại trừ các tùy chọn này trở nên chậm hơn đáng kể:
  • tùy chọn .6. $x = end((array_values($array)));
  • tùy chọn .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
• Các tùy chọn này có tỷ lệ tốt nhất cho các mảng rất lớn:
  • tùy chọn .5. $x = end($array); reset($array);
  • tùy chọn .7. $x = $array[count($array)-1];
  • tùy chọn .9. $x = $array[] = array_pop($array);
  • tùy chọn 10. $x = $array[array_key_last($array)]; (kể từ PHP 7.3)
• các tùy chọn này chỉ nên được sử dụng cho các mảng được lập chỉ mục tự động :
  • tùy chọn .7. $x = $array[count($array)-1];(do sử dụngcount)
  • tùy chọn .9. $x = $array[] = array_pop($array);(do gán giá trị mất khóa gốc)
• tùy chọn này không bảo toàn con trỏ bên trong của mảng
  • tùy chọn .5. $x = end($array); reset($array);
• tùy chọn này là một nỗ lực để sửa đổi tùy chọn .5. để bảo toàn con trỏ bên trong của mảng (nhưng đáng buồn là nó không mở rộng tốt cho các mảng rất lớn)
  • tùy chọn .6. $x = end((array_values($array)));
• array_key_lastchức năng mới dường như không có giới hạn nào được đề cập ở trên, ngoại trừ vẫn là một RC tại thời điểm viết bài này (vì vậy hãy sử dụng RC hoặc chờ phát hành vào tháng 12 năm 2018):
  • tùy chọn 10. $x = $array[array_key_last($array)]; (kể từ PHP 7.3)

Một chút tùy thuộc vào việc sử dụng mảng như ngăn xếp hay hàng đợi, bạn có thể thực hiện các biến thể trên tùy chọn 9.

Thử

$myLastElement = end($yourArray);

Để đặt lại nó (cảm ơn @hopeseekr):

 reset($yourArray);

Liên kết đến hướng dẫn

@David Murdoch đã thêm: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). Trên E_STRICT, điều này tạo ra cảnh báo

Strict Standards: Only variables should be passed by reference

Cảm ơn o_O Tync và mọi người!

Ngắn và ngọt.

Tôi đã đưa ra giải pháp để loại bỏ thông báo lỗi và duy trì dạng một lớp và hiệu suất hiệu quả:

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

- giải pháp trước

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

Lưu ý: Cần có thêm dấu ngoặc đơn để tránh a PHP Strict standards: Only variables should be passed by reference.

Có chuyện gì với bạn array_slice($array, -1)vậy? (Xem Hướng dẫn: http://us1.php.net/array_slice )

array_slice()trả về một mảng. Có lẽ không phải là những gì bạn đang tìm kiếm. Bạn muốn các yếu tố.

Một cách để tránh các lỗi chuyển qua tham chiếu (ví dụ: "end (mảng_values ​​($ foo))") là sử dụng call_user_func hoặc 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))));

Nếu bạn không quan tâm đến việc sửa đổi con trỏ bên trong (hỗ trợ cả mảng được lập chỉ mục và liên kết):

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

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

Nếu bạn muốn một hàm tiện ích không sửa đổi con trỏ bên trong (vì mảng được truyền theo giá trị và hàm hoạt động trên một bản sao của nó):

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

Lưu ý rằng PHP tạo ra các bản sao "đang hoạt động", tức là chỉ khi thực sự cần thiết. Bản end()thân nó sửa đổi mảng, do đó, một bản sao của mảng được tạo ra.

Vì vậy, sự thay thế sau đây thực sự nhanh hơn vì bên trong nó không sao chép mảng, nó chỉ tạo ra một lát:

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

"Foreach / return" này là một tinh chỉnh để có hiệu quả nhận được mục đầu tiên (và ở đây duy nhất).

Cuối cùng, sự thay thế nhanh nhất nhưng chỉ dành cho mảng được lập chỉ mục:

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

Đối với bản ghi, đây là một câu trả lời khác của tôi , cho phần tử đầu tiên của mảng.

chưa được kiểm tra: điều này sẽ không làm việc?

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

Vì mảng được trả về bởi Array_values ​​là thoáng qua, không ai quan tâm nếu con trỏ của nó được đặt lại.

và nếu bạn cần chìa khóa để đi với nó, tôi đoán bạn sẽ làm:

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

Tôi cần điều này khá thường xuyên để xử lý các ngăn xếp và tôi luôn thấy khó hiểu rằng không có chức năng riêng nào thực hiện nó mà không thao tác với mảng hoặc con trỏ bên trong của nó ở dạng nào đó.

Vì vậy, tôi thường mang theo một chức năng sử dụng cũng an toàn để sử dụng trên các mảng kết hợp.

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

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

Để lấy phần tử cuối cùng của một mảng, sử dụng:

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

Điểm chuẩn

Tôi đã lặp lại 1.000 lần, lấy phần tử cuối cùng của mảng nhỏ và lớn chứa lần lượt 100 và 50.000 phần tử.

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

Tôi đã sử dụng phiên bản PHP 5.5.32.

end () sẽ cung cấp phần tử cuối cùng của một mảng

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

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

Kể từ phiên bản PHP 7.3, các chức năng array_key_firstvà array_key_lastđã được giới thiệu.

Do các mảng trong PHP không phải là các kiểu mảng nghiêm ngặt, tức là các tập hợp có kích thước cố định của các trường có kích thước cố định bắt đầu từ chỉ số 0, nhưng mảng kết hợp được mở rộng động, việc xử lý các vị trí với các khóa không xác định là khó khăn và cách giải quyết không thực hiện tốt. Ngược lại, các mảng thực sẽ được xử lý nội bộ thông qua các số liệu con trỏ rất nhanh và chỉ mục cuối cùng đã được biết đến tại thời điểm biên dịch bằng cách khai báo.

Ít nhất vấn đề với vị trí đầu tiên và cuối cùng được giải quyết bằng các hàm dựng sẵn ngay từ phiên bản 7.3. Điều này thậm chí hoạt động mà không có bất kỳ cảnh báo nào về mảng chữ ngoài hộp:

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

Rõ ràng giá trị cuối cùng là:

$array[array_key_last($array)];

$lastValue = end(array_values($array))

Không có sửa đổi được thực hiện để con trỏ mảng $. Điều này tránh

reset($array)

mà có thể không được mong muốn trong một số điều kiện nhất định.

Cho tôi:

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

Với sự kết hợp:

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

Các câu trả lời hàng đầu rất hay, nhưng như được đề cập bởi @ paul-van-leeuwen và @ quasimodos-clone, PHP 7.3 sẽ giới thiệu hai hàm mới để giải quyết vấn đề này trực tiếp - Array_key_first () và Array_key_last () .

Bạn có thể bắt đầu sử dụng cú pháp này ngay hôm nay với các hàm polyfill (hoặc shim) sau đây.

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

Hãy cẩn thận: Điều này đòi hỏi PHP 5.4 trở lên.

Để làm điều này và tránh E_STRICT và không gây rối với con trỏ bên trong của mảng, bạn có thể sử dụng:

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

$last_element = lelement($array);

lelement chỉ hoạt động với một bản sao để nó không ảnh hưởng đến con trỏ của mảng.

Giải pháp khác:

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

Thêm một giải pháp khả thi ...

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

Làm thế nào về:

current(array_slice($array, -1))

• làm việc cho mảng kết hợp
• hoạt động khi $array == [](trả về false)
• không ảnh hưởng đến mảng ban đầu

Bạn sẽ nhận được phần tử cuối cùng từ một mảng dễ dàng bằng cách sử dụng logic bên dưới

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

Không chỉ yếu tố cuối cùng mà bạn còn có thể có được thứ hai cuối cùng, thứ ba cuối cùng và như vậy bằng cách sử dụng logic dưới đây.

đối với phần tử cuối cùng thứ hai, bạn phải vượt qua số 2 trong câu lệnh trên, ví dụ:
echo ($ mảng [Count ($ mảng) -2]);

Để nhận giá trị cuối cùng từ Mảng:

array_slice($arr,-1,1) ;

Để xóa mảng mẫu giá trị cuối cùng:

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

Đơn giản: $last_element = end((array_values($array)))

Không đặt lại mảng và không đưa ra cảnh báo STRICT.

Tái bút Vì câu trả lời được bình chọn nhiều nhất vẫn chưa có dấu ngoặc kép, tôi đã gửi câu trả lời này.

Tôi nghĩ rằng đây là một cải tiến nhỏ trên tất cả các câu trả lời hiện có:

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

• Thực hiện tốt hơn end()hoặc giải pháp sử dụng array_keys(), đặc biệt là với các mảng lớn
• Không sửa đổi con trỏ bên trong của mảng
• Không cố gắng truy cập vào phần bù không xác định cho mảng trống
• Sẽ hoạt động như mong đợi cho các mảng trống, mảng được lập chỉ mục, mảng hỗn hợp và mảng kết hợp

Sử dụng hàm end ().

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

Ngày nay, tôi muốn luôn có người trợ giúp này, như được đề xuất tại câu trả lời của php.net/end .

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

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

Điều này sẽ luôn giữ con trỏ như hiện tại và chúng ta sẽ không bao giờ phải lo lắng về dấu ngoặc đơn, các tiêu chuẩn nghiêm ngặt hoặc bất cứ điều gì.

Lưu ý: Với (PHP 7> = 7.3.0), chúng ta có thể sử dụng mảng_key_last - Lấy khóa cuối cùng của một mảng

array_key_last ( array $array ) : mixed

Tham chiếu: http://php.net/manual/en/feft.array-key-last.php

Điều gì nếu bạn muốn có được phần tử cuối cùng của mảng bên trong vòng lặp của mảng đó?

Mã dưới đây sẽ dẫn đến một vòng lặp vô hạn:

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

Giải pháp rõ ràng là đơn giản cho các mảng không liên kết:

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

Kể từ phiên bản PHP 7.3, đã array_key_lastcó sẵn

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

Rất đơn giản

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

giải pháp đơn giản của tôi, đẹp và dễ hiểu.

array_reverse($array)[0];