ChatGPT解决这个技术问题 Extra ChatGPT

What are the differences in die() and exit() in PHP?

What are the differences between die() and exit() functions in PHP?

I think both have the same functionality, but I doubt there is something different in both... what is it?

exit() just bails off the program with a numeric exit status, while die() prints out the error message to stderr and exits with EXIT_FAILURE status. so exit() is exit and die() is also exit :)

M
Marek Karbarz

There's no difference - they are the same.

PHP Manual for exit:

Note: This language construct is equivalent to die().

PHP Manual for die:

This language construct is equivalent to exit().


aliases allows programmers to use the one which is comfortable with. I remember exit better than die. Some others remember die better than exit.
this (php.net/manual/en/aliases.php) might give some explanation why 2 functions do the same thing
Even though they do the same thing, I usually reserve die for error related stops and exit for all other scenarios. It just seems to flow better when reading the code.
Sorry to revive this, but at least for me... die is far faster to write than exit... I'm starting to use exit because it's more readable to non-PHP-programmers, but die is just faster to type when you're in a hurry. Also, by the way I type, I don't have to change my hands' position to write die.
@mauris, It's way better for one function to have just one name. Imagine every PHP function has two names, that would be a complete mess.
G
Geoffrey Hale

DIFFERENCE IN ORIGIN

The difference between die() and exit() in PHP is their origin.

exit() is from exit() in C.

die() is from die in Perl.

FUNCTIONALLY EQUIVALENT

die() and exit() are equivalent functions.

PHP Manual

PHP Manual for die:

This language construct is equivalent to exit().

PHP Manual for exit:

Note: This language construct is equivalent to die().

PHP Manual for List of Function Aliases:

die is an alias for master function exit()

DIFFERENT IN OTHER LANGUAGES

die() and exit() are different in other languages but in PHP they are identical.

From Yet another PHP rant:

...As a C and Perl coder, I was ready to answer, "Why, exit() just bails off the program with a numeric exit status, while die() prints out the error message to stderr and exits with EXIT_FAILURE status." But then I remembered we're in messy-syntax-land of PHP. In PHP, exit() and die() are identical. The designers obviously thought "Hmm, let's borrow exit() from C. And Perl folks probably will like it if we take die() as is from Perl too. Oops! We have two exit functions now! Let's make it so that they both can take a string or integer as an argument and make them identical!" The end result is that this didn't really make things any "easier", just more confusing. C and Perl coders will continue to use exit() to toss an integer exit value only, and die() to toss an error message and exit with a failure. Newbies and PHP-as-a-first-language people will probably wonder "umm, two exit functions, which one should I use?" The manual doesn't explain why there's exit() and die(). In general, PHP has a lot of weird redundancy like this - it tries to be friendly to people who come from different language backgrounds, but while doing so, it creates confusing redundancy.


Even though this is about the 100th answer stating that they are equivalent (as also seen in my answer ^^), this really adds some VERY good points. Most of all that they are NOT the same in other languages (thus the confusion in the first place). (+1)
@Levit, No, no, you're getting it totally wrong. No one owns names and different languages reuse the same names in nonequal ways. That's fine because we don't need yet another standard way of doing things. The "confusion in the first place" is due to PHP assigning two different names to one function..
@Pacerier: Sure, if you look at it from the point of "who's fault is it", that is absolutely right. Still it is also a fact that they simply mean different things in several languages (which is ok). Looking at it from a neutral perspective, it definately holds true: There is confusion because of the different meanings (even if it is php's fault for creating two equal function aliases). I definately did not want to point a finger at any of those languages, if that was what you understood from my comment ... (great xkcd btw (Y) ^^)
This should definitely be the chosen answer, good description!
@ner0 That was said to be untrue in one of the comments.
S
Sayed Mohd Ali

As stated before, these two commands produce the same parser token.

BUT

There is a small difference, and that is how long it takes the parser to return the token.

I haven't studied the PHP parser, but if it's a long list of functions starting with "d", and a shorter list starting with "e", then there must be a time penalty looking up the function name for functions starting with "e". And there may be other differences due to how the whole function name is checked.

I doubt it will be measurable unless you have a "perfect" environment dedicated to parsing PHP, and a lot of requests with different parameters. But there must be a difference, after all, PHP is an interpreted language.


@Timeless, Perfectionists would not say "PHP is an interpreted language". PHP is a language that can either be interpreted or compiled depending on your server setup.
And... "die" is 3 characters long vs 4 for "exit". So it takes 25% less memory and file space! ;)
'"if it's a long list of functions starting with "d", and a shorter list starting with "e", then there must be a time penalty looking up the function name for functions starting with "e"'. Wouldn't you mean that the time penalty would happen when looking up the function starting with d? Usually, the bigger the list, the longer the time to find an item in it.
As you wrote, you haven't studied the PHP parser. Thanks for this useless answer as it is based on your dreams on how PHP is implemented.
D
Davicus

PHP manual on die:

die — Equivalent to exit

You can even do die; the same way as exit; - with or without parens.

The only advantage of choosing die() over exit(), might be the time you spare on typing an extra letter ;-)


it also make convenience when someone came from other language, were they get of some familiarity in either of the way
note that if running php interactively (php -a) die;, die();, exit; and exit(); have no effect, while exit (without semicolon) exits interactive mode.
In interactive mode the die()/exit() function still does what is described in its documentation: it outputs a message and terminates the current script. It terminates only the script, not the interpreter. The interpreter does what it usually does when a script ends: shows the prompt and waits for another script or a command. exit without semicolon at the prompt is a command to the interpreter to terminate itself. You can also use quit for the same purpose.
m
matronator

Here is something that's pretty interesting. Although exit() and die() are equivalent, die() closes the connection. exit() doesn't close the connection.

die():

<?php
    header('HTTP/1.1 304 Not Modified');
    die();
?>

exit():

<?php
    header('HTTP/1.1 304 Not Modified');
    exit();
?>

Results:

die():

HTTP/1.1 304 Not Modified 
Connection: close

exit():

HTTP/1.1 304 Not Modified 
Connection: Keep-Alive 
Keep-Alive: timeout=5, max=100

Just incase in need to take this into account for your project.

Credits: https://stackoverflow.com/a/20932511/4357238


Just tested it and exit and die work the same way, they both close connection.
L
Lukas

As all the other correct answers says, die and exit are identical/aliases.

Although I have a personal convention that when I want to end the execution of a script when it is expected and desired, I use exit;. And when I need to end the execution due to some problems (couldn't connect to db, can't write to file etc.), I use die("Something went wrong."); to "kill" the script.

When I use exit:

header( "Location: http://www.example.com/" ); /* Redirect browser */
/* Make sure that code below does not get executed when we redirect. */
exit; // I would like to end now.

When I use die:

$data = file_get_contents( "file.txt" );
if( $data === false ) {
    die( "Failure." ); // I don't want to end, but I can't continue. Die, script! Die!
}
do_something_important( $data );

This way, when I see exit at some point in my code, I know that at this point I want to exit because the logic ends here. When I see die, I know that I'd like to continue execution, but I can't or shouldn't due to error in previous execution.

Of course this only works when working on a project alone. When there is more people nobody will prevent them to use die or exit where it does not fit my conventions...


I like this answer. To all those lamenting how two names cause confusion, use that to your advantage.
a
aagjalpankaj

Functionality-wise they are identical but I use them in the following scenarios to make code readable:

Use die() when there is an error and have to stop the execution.

e.g. die( 'Oops! Something went wrong' );

Use exit() when there is not an error and have to stop the execution.

e.g. exit( 'Request has been processed successfully!' );


S
Simon77

https://i.stack.imgur.com/0IB1z.png


P
Pedram Behroozi

This page says die is an alies of exit, so they are identical. But also explains that:

there are functions which changed names because of an API cleanup or some other reason and the old names are only kept as aliases for backward compatibility. It is usually a bad idea to use these kind of aliases, as they may be bound to obsolescence or renaming, which will lead to unportable script.

So, call me paranoid, but there may be no dieing in the future.


It also says In some cases there is no preferred name among the multiple ones, is_int() and is_integer() are equally good for example. Looking at the php-src commit history on GitHub, the die() construct has been in PHP at least since 1999 when it was converted into an SVN repository, and probably for as long as the language has existed. It seems absurd to imagine that it will ever be deprecated.
@MarkAmery, While his premises don't lead to his conclusion, the conclusion itself is valid: ~ "Call me paranoid, but there may be no exit in the future. Or there may be no die in the future"
@Pacerier Quite right. There may be no PHP in the future, so let's all quit this programming gig and become undertakers or tax collectors. Nothing is certain but death and taxes, after all.
@MarkAmery, "No PHP in the future" seems to be over above-average paranoid. History has shown that insanely popular languages don't die off so easily (Fortran!).
Don't be paranoid. exit will never die. :)
o
o.k.w

They are essentially the same, though this article suggest otherwise.


That article is just weird; from the scanner definition you can tell they are equivalent; if there's any difference, perhaps the test was run without an opcache.
The article is about a benchmark that can't be reproduced as the code is not published. Just ignore it.
L
Luo Jiong Hui

Functionally, they are identical. So to choose which one to use is totally a personal preference. Semantically in English, they are different. Die sounds negative. When I have a function which returns JSON data to the client and terminate the program, it can be awful if I call this function jsonDie(), and it is more appropriate to call it jsonExit(). For that reason, I always use exit instead of die.


The OP is asking about PHP exit and die functions only.
Yes, and I was answering that question only. To be aware however, the question is not about the difference in functionality only.
One of the most lovely functions of mine is called pd() - Which means Please Die. So I'm not sure that die is a bad thing in such a context :)
As a full stack developer, I am not only seeing myself as a programmer, but also a User Experience designer. And in this context, sympathy is important. Sympathy not only affects how I design UI, but also how I code.
D
Dhiva Banyu Wigara

From what I know when I look at this question here

It said there that "in PHP, there is a distinct difference in Header output. In the examples below I chose to use a different header but for sake of showing the difference between exit() and die() that doesn't matter", and tested (personally)


M
MERT DOĞAN

The result of exit() function and die() function is allways same. But as explained in alias manual page (http://php.net/manual/en/aliases.php), it says that die() function calls exit function. I think it is hard coded like below:

function die($msg){
  exit($msg);
}

This is not a performance issue for small, medium and large projects but if project has billions multiply billions multiply billions processes, this happens very important performance optimization state.

But very most of people don't thinks this is a problem, because if you have that much processes, you must think more problem than if a function is master or alias.

But, exact answer is that; allways master function is more faster than alias.

Finally; Alias manual page says that, you may no longer use die. It is only an alias, and it is deprecated.

It is usually a bad idea to use these kind of aliases, as they may be bound to obsolescence or renaming, which will lead to unportable script. This list is provided to help those who want to upgrade their old scripts to newer syntax.


Aliasing is not 'calling a function'. Check your assumptions before elaborating hypothesis.
@dolmen Aliases allways calles main functions in hard codes. This is a general programming rule.
@MERTDOĞAN An alias doesn't call anything. An alias (in programming or in real life) is just another name of an object (that already has a name). die() is not a separate function. It is just another name of exit(). This answer contains incorrect statements about aliases and their performance.
docs.php.net/manual/en/… Aliases allways calles like above example. Learn something and come back.
Just for the record, @axiac is correct in that die doesn't call exit. They simply both map to T_EXIT, as in <ST_IN_SCRIPTING>"exit" { RETURN_TOKEN_WITH_IDENT(T_EXIT); } <ST_IN_SCRIPTING>"die" { RETURN_TOKEN_WITH_IDENT(T_EXIT); } at: github.com/php/php-src/blob/master/Zend/…
n
noowie

Something I have noticed in my scripts at least is that exit() will stop the currently executing script and pass control back to any calling script, while die will stop php in its tracks. I would say that is quite a big difference?


@AdarshMadrecha this is not true. If they are inside or outside a subfunction, php script allways stops.
You can stop the execution of an icluded file with return statement but not with exit.
I
Icheb

They sound about the same, however, the exit() also allows you to set the exit code of your PHP script.

Usually you don't really need this, but when writing console PHP scripts, you might want to check with for example Bash if the script completed everything in the right way.

Then you can use exit() and catch that later on. Die() however doesn't support that.

Die() always exists with code 0. So essentially a die() command does the following:

<?php
echo "I am going to die";
exit(0);
?>

Which is the same as:

<?php
die("I am going to die");
?>

That's not true. die and exit are identical (they produce the same parser token (T_EXIT) and are executed by the same code). If the parameter is an integer, it will return that code to the shell. If it is not, it will output it and return 0. So die and exit are literally aliases for each-other.
well if you know you can use exit("I'm exiting...");
23 upvotes so far for an answer that's simply false! This is why I never vote on answers until I've read all the competing answers to the question and understand them all (barring terribly written ones I can't make any sense of).
This is exactly what @GeoffreyHale writes about in his answer. What you posted as answer is what one would expect, coming from a language like Perl or C. But as the others mentioned it is not true for php. You might really consider editing your answer to reflect this, or deleting it otherwise.