Try end:

$myLastElement = end($yourArray);

Note that this doesn't just return the last element of the passed array, it also modifies the array's internal pointer, which is used by current, each, prev, and next.

For PHP >= 7.3.0:

If you are using PHP version 7.3.0 or later, you can use array_key_last, which returns the last key of the array without modifying its internal pointer. So to get the last value, you can do:

$myLastElement = $yourArray[array_key_last($yourArray)];
Answer from Iznogood on Stack Overflow
🌐
PHP
php.net › manual › en › function.end.php
PHP: end - Manual
If all you want is the last item of the array without affecting the internal array pointer just do the following: <?php function endc( $array ) { return end( $array ); } $items = array( 'one', 'two', 'three' ); $lastItem = endc( $items ); // three $current = current( $items ); // one ?> This works because the parameter to the function is being sent as a copy, not as a reference to the original variable.
🌐
W3Schools
w3schools.com › php › func_array_end.asp
PHP end() Function
json_decode() json_encode() json_last_error() PHP Keywords · abstract and as break callable case catch class clone const continue declare default do echo else elseif empty enddeclare endfor endforeach endif endswitch endwhile extends final finally fn for foreach function global if implements include include_once instanceof insteadof interface isset list namespace new or print private protected public require require_once return static switch throw trait try use var while xor yield yield from PHP Libxml
People also ask
How many versions of PHP are there?
There have been multiple major versions: 1.0, 2.0, 3.0, 4.0, 5.x, 7.x, and 8.x. Each major version includes minor releases and updates.
🌐
cloudways.com
cloudways.com › home › php version history: brief timeline of the world's most used backend language
PHP Version History: Brief Timeline of World’s Most Used Back-end ...
Which version of PHP is the best?
As of 2026, PHP 8.5 is the latest stable release and the recommended version for new projects. It offers improved performance, enhanced type safety, better debugging tools, and modern language features. If your hosting provider does not yet support PHP 8.5, PHP 8.4 remains a stable and production-ready option.
🌐
cloudways.com
cloudways.com › home › php version history: brief timeline of the world's most used backend language
PHP Version History: Brief Timeline of World’s Most Used Back-end ...
When was PHP first released, and who created it?
PHP was first released in June 1995 by Rasmus Lerdorf as a set of Perl scripts to track visits to his online resume. It evolved into a full programming language powering millions of websites today.
🌐
cloudways.com
cloudways.com › home › php version history: brief timeline of the world's most used backend language
PHP Version History: Brief Timeline of World’s Most Used Back-end ...
🌐
Stack Overflow
stackoverflow.com › questions › 3687358 › how-to-get-the-last-element-of-an-array-without-deleting-it
php - How to get the last element of an array without deleting it? - Stack Overflow
Top answer
1 of 16
645

Try end:

$myLastElement = end($yourArray);

Note that this doesn't just return the last element of the passed array, it also modifies the array's internal pointer, which is used by current, each, prev, and next.

For PHP >= 7.3.0:

If you are using PHP version 7.3.0 or later, you can use array_key_last, which returns the last key of the array without modifying its internal pointer. So to get the last value, you can do:

$myLastElement = $yourArray[array_key_last($yourArray)];
2 of 16
362

The many answers in this thread present us with many different options. To be able to choose from them I needed to understand their behavior and performance. In this answer I will share my findings with you, benchmarked against PHP versions 5.6.38, 7.2.10 and 7.3.0RC1 (expected Dec 13 2018).

The options (<<option code>>s) I will test are:

  • option .1. $x = array_values(array_slice($array, -1))[0]; (as suggested by rolacja)
  • option .2. $x = array_slice($array, -1)[0]; (as suggested by Stoutie)
  • option .3. $x = array_pop((array_slice($array, -1))); (as suggested by rolacja)
  • option .4. $x = array_pop((array_slice($array, -1, 1))); (as suggested by Westy92)
  • option .5. array); reset($array); (as suggested by Iznogood)
  • option .6. $x = end((array_values($array))); (as suggested by TecBrat)
  • option .7. array[count($array)-1]; (as suggested by Mirko Pagliai)
  • option .8. $keys = array_keys($array); array[$keys[count($keys)-1]]; (as suggested by thrau)
  • option .9. array[] = array_pop($array); (as suggested by user2782001)
  • option 10. array[array_key_last($array)]; (as suggested by Quasimodo's clone ; available per PHP 7.3)

(functions mentioned: array_key_last , array_keys , array_pop , array_slice , array_values , count , end , reset)

The test inputs (<<input code>>s) to combine with:

  • null = $array = null;
  • empty = $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<100;$i++) { $array[] = $i; }
  • 100000 = $array = []; for(i<100000;$i++) { $array[] = $i; }

For testing I will use the 5.6.38, 7.2.10 and 7.3.0RC1 PHP docker containers like:

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

Each combination of the above listed <<option code>>s and <<input code>>s will be run on all versions of PHP. For each test run the following code snippet is used:

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

For each run this will var_dump the last retrieved last value of the test input and print the average duration of one iteration in femtoseconds (0.000000000000001th of a second).

The results are as follows:

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            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.  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.  array[count($array)-1];                                   ||             - |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||
||  8.  $keys = array_keys($array); array[$keys[count($keys)-1]]; ||            W6 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||
||  9.  array[] = array_pop($array);                              ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||
|| 10.  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.  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.  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); 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.  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.  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.  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.  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); 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.  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.  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 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/

The above mentioned Fatal, Warning and Notice codes translate as:

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

Based on this output I draw the following conclusions:

  • newer versions of PHP perform better with the exception of these options that became significantly slower:
    • option .6. $x = end((array_values($array)));
    • option .8. $keys = array_keys($array); array[$keys[count($keys)-1]];
  • these options scale best for very large arrays:
    • option .5. array); reset($array);
    • option .7. array[count($array)-1];
    • option .9. array[] = array_pop($array);
    • option 10. array[array_key_last($array)]; (since PHP 7.3)
  • these options should only be used for auto-indexed arrays:
    • option .7. array[count($array)-1]; (due to use of count)
    • option .9. array[] = array_pop($array); (due to assigning value losing original key)
  • this option does not preserve the array's internal pointer
    • option .5. array); reset($array);
  • this option is an attempt to modify option .5. to preserve the array's internal pointer (but sadly it does not scale well for very large arrays)
    • option .6. $x = end((array_values($array)));
  • the new array_key_last function seems to have none of the above mentioned limitations with the exception of still being an RC at the time of this writing (so use the RC or await it's release Dec 2018):
    • option 10. array[array_key_last($array)]; (since PHP 7.3)

A bit depending on whether using the array as stack or as queue you can make variations on option 9.

🌐
Stack Overflow
stackoverflow.com › questions › 5539669 › what-does-end-mean-in-php
What does <<<END mean in PHP?
Top answer
1 of 4
14

Heredoc syntax:

A third way to delimit strings is the heredoc syntax: <<<. After this operator, an identifier is provided, then a newline. The string itself follows, and then the same identifier again to close the quotation.

The closing identifier must begin in the first column of the line. Also, the identifier must follow the same naming rules as any other label in PHP: it must contain only alphanumeric characters and underscores, and must start with a non-digit character or underscore.

Warning It is very important to note that the line with the closing identifier must contain no other characters, except a semicolon (;). That means especially that the identifier may not be indented, and there may not be any spaces or tabs before or after the semicolon. It's also important to realize that the first character before the closing identifier must be a newline as defined by the local operating system. This is \n on UNIX systems, including Mac OS X. The closing delimiter must also be followed by a newline.

If this rule is broken and the closing identifier is not "clean", it will not be considered a closing identifier, and PHP will continue looking for one. If a proper closing identifier is not found before the end of the current file, a parse error will result at the last line.

Heredocs can not be used for initializing class properties. Since PHP 5.3, this limitation is valid only for heredocs containing variables...

2 of 4
1

Read it here: http://php.net/manual/en/language.types.string.php#language.types.string.syntax.heredoc

🌐
Cloudways
cloudways.com › home › php version history: brief timeline of the world's most used backend language
PHP Version History: Brief Timeline of World’s Most Used Back-end Language [INFOGRAPHICS]
5 days ago - PHP 7.x → End of Life.
🌐
GeeksforGeeks
geeksforgeeks.org › php › php-end-function
PHP end() Function - GeeksforGeeks
September 16, 2024 - The end() function is an inbuilt function in PHP and is used to find the last element of the given array.
Find elsewhere
🌐
End of Life Date
endoflife.date › php
PHP | endoflife.date
3 weeks ago - The PHP Release Cycle was extended in March 2024 from 3 to 4 years: 2 years of bug fixes, and 2 years of security fixes.
🌐
Tutorial Republic
tutorialrepublic.com › php-reference › php-end-function.php
PHP end() Function - Tutorial Republic
The following example shows the end() function in action. Run this code » · <?php // Sample array $colors = array("red", "green", "blue", "orange", "yellow", "black"); // Getting the last element echo end($colors); // Prints: black ?> The end() function accepts the following parameters.
🌐
PHP: The Right Way
phptherightway.com › pages › The-Basics.html
The Basics | PHP: The Right Way
January 22, 2026 - Within a function, using ‘return’ alleviates the need for ‘break’ as it ends the function · <?php $answer = test(2); // the code from both 'case 2' and 'case 3' will be implemented function test($a) { switch ($a) { case 1: // code... break; // break is used to end the switch statement case 2: // code...
🌐
3D Bay
clouddevs.com › home › php guides › guide: how to use php’s end() function
A Deep Dive into PHP's end() Function
May 19, 2025 - The end() function in PHP is designed to move the internal pointer of an array to its last element and return that element’s value.
🌐
Reddit
reddit.com › r/php › exit is now a proper function in php 8.4
r/PHP on Reddit: Exit is now a proper function in PHP 8.4
November 29, 2024 -

This may be something you are aware of if you are closely following the PHP development.

There is this very common code snippet used in many code bases:

die(var_dump($var));

This worked prior to PHP 8.4, which is actually invalid given that die() is an alias of exit() and it expects an exit code rather than the output are trying to dump

This miss information was commonly spread in tutorials in the early days:

<?php  
$site = "https://www.w3schools.com/";  
fopen($site,"r")  
or die("Unable to connect to $site");  
?>

source

instead you would have to do:

var_dump($var); die();
// or
var_dump($var); exit();
// funny enough, this still works
var_dump($var); exit;

Thought it was worth sharing in case you've missed this, and you are like me who always used this wrong.

Great to see either way that PHP is evolving in the correct direction and slowly getting rid of these artifacts of the past.

Edit: Formatting

Top answer
1 of 5
38
exit()/die() always (I remember it since PHP 3) allowed a string Parameter, thus the fopen() or die("failed to open") pattern was always valid. That pattern wasn't a good pattern as besides from simple scripts that's not a good way to handle an error, but valid.
2 of 5
31
You gave examples of how these were used wrongly and how they should be used (I agree with that), but didn't explain what changes since now exit is a function. So I'm not sure what your point is.
🌐
Uptimia
uptimia.com › home › questions › how to get the last element of an array in php without deleting it?
How To Get The Last Element Of An Array in PHP Without Deleting It?
October 30, 2024 - $array = ['a', 'b', 'c', 'd']; $lastElement = end($array); reset($array); This allows you to continue using other array functions without unexpected behavior. For PHP versions 7.3.0 and later, the array_key_last() function gets the last element without changing the array's internal pointer.
🌐
Locutus
locutus.io › php › array › end
PHP's end in JavaScript | Locutus
January 19, 2026 - You you can install via yarn add locutus and require this function via const end = require('locutus/php/array/end').
🌐
Envato Tuts+
code.tutsplus.com › home › coding fundamentals
Get the First and Last Elements of an Array in PHP | Envato Tuts+
April 19, 2021 - One thing you should keep in mind ... again, this will not work with associative arrays. You can use the end() function in PHP to get the last element of any PHP array....
🌐
SitePoint
sitepoint.com › php
What is the correct way to exit or end a php script if a particular process fails - PHP - SitePoint Forums | Web Development & Design Community
July 3, 2022 - execute()){ echo 'Congratulation, your account has been created '; } else { echo 'Sorry, there was a problem creating your account - please contact site admin '; } When a failure occurs, can I use die("Houston we have a problem"); o...
🌐
W3docs
w3docs.com › learn-php › end.html
Understanding PHP's array end() function
It ends the execution of a PHP script.
🌐
Mc
sandbox.mc.edu › ~bennet › php › man › function.end.html
end
(PHP 3, PHP 4 >= 4.0.0)end -- Set the internal pointer of an array to its last element
Related queries
php end python
php end w3schools
php array_key_last
php end javascript
php end command
end php example
php array last key
remove last element of array php