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
This function returns the value ... arrays: <?php // Returns the key at the end of the array function endKey($array){ end($array); return key($array); } ?> Usage example: <?php $a = array("one" => "apple", "two" => "orange", ...
🌐
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
Discussions
What does <<<END mean in PHP?
Possible Duplicates: Reference - What does this symbol mean in PHP? PHP More on stackoverflow.com
🌐 stackoverflow.com
Exit is now a proper function in PHP 8.4
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. More on reddit.com
🌐 r/PHP
23
48
November 29, 2024
What is the correct way to exit or end a php script if a particular process fails - PHP - SitePoint Forums | Web Development & Design Community
Hi Occasionally, believe it or not, one or more lines of my code fails - not due to a syntax error but some other unexpected or possibly predicted event. For example $mysqli = new mysqli($host,$user,$password,$database… More on sitepoint.com
🌐 sitepoint.com
0
July 3, 2022
PHP end tag "?>" - Stack Overflow
I've had an interesting phenomenon with a PHP end tag. I had a php file that was executed by an Ajax call. In the php file was included a php library file with assorted functions. When this library... More on stackoverflow.com
🌐 stackoverflow.com
🌐
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

🌐
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.
🌐
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.
🌐
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.
Find elsewhere
🌐
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
🌐
Stack Overflow
stackoverflow.com › questions › 19953483 › php-end-tag
PHP end tag "?>" - Stack Overflow
Top answer
1 of 2
66

This is well documented. From the PHP Manual:

The closing tag of a PHP block at the end of a file is optional, and in some cases omitting it is helpful when using include() or require(), so unwanted whitespace will not occur at the end of files, and you will still be able to add headers to the response later. It is also handy if you use output buffering, and would not like to see added unwanted whitespace at the end of the parts generated by the included files.

Omitting the closing tag helps you prevent accidental whitespace or newlines from being added to the end of the file.

2 of 2
20

That's a core PHP feature: unlike other languages, you need to tag PHP code with a special tag (normally <?php) because everything else is considered literal output:

This is not PHP
<?php

echo 'This is PHP' . PHP_EOL;

?>
This is not PHP either

D:\tmp>php test.php
This is not PHP
This is PHP
This is not PHP either

Although the manual mentions HTML, PHP doesn't really know/care what content-type is outside its tags.

If you forget to close a PHP block when further stuff follows you normally get a syntax error:

This is not PHP
<?php

echo 'This is PHP' . PHP_EOL;

This is not PHP either

D:\tmp>php test.php
PHP Parse error:  syntax error, unexpected 'is' (T_STRING) in D:\tmp\borrame.php on line 6

Blank lines are a sort of special case because they are valid and almost invisible in almost all languages (PHP, HTML, CSS, JavaScript...) so they often unnoticed.

Once you've removed the ?> tag, your literal blank lines have disappeared from the script output because they've become part of the PHP code (and, as such, they've started to get ignored).

Of course, blank lines are ignored by PHP but not necessarily by whatever you are generating which, as I said, does not need to be HTML: it can be a picture, a PDF document, an Excel spreadsheet. Bogus white lines can be easily avoided by not closing the last PHP block when it's the last part of the file.

Related queries
php end python
php end w3schools
php array_key_last
php end javascript
php end example
php end command
php explode
end php w3schools