How Does "Do Something or Die()" Work in PHP

How does do something OR DIE() work in PHP?

If the first statement returns true, then the entire statement must be true therefore the second part is never executed.

For example:

$x = 5;
true or $x++;
echo $x;  // 5

false or $x++;
echo $x; // 6

Therefore, if your query is unsuccessful, it will evaluate the die() statement and end the script.

Continue after or die in Php

An example of your code would be useful, but in general, the mysql_query() or die() pattern is not necessary. If you don't want execution to halt upon the failure of a given query, simply omit the or die() part:

echo 'Output something';
$res = mysql_query($sql);
if ($res) {
 /* do stuff with the query results */
} else {
  /* output an error if desired... or don't */
  echo 'There was a database error: '.mysql_error();
}
echo 'Output some more stuff';

In PHP, why does or die() work, but or return doesn't?

I want to thank you for asking this question, since I had no idea that you couldn't perform an or return in PHP. I was as surprised as you when I tested it. This question gave me a good excuse to do some research and play around in PHP's internals, which was actually quite fun. However, I'm not an expert on PHP's internals, so the following is a layman's view of the PHP internals, although I think it's fairly accurate.

or return doesn't work because return isn't considered an "expression" by the language parser - simple as that.

The keyword or is defined in the PHP language as a token called T_LOGICAL_OR, and the only expression where it seems to be defined looks like this:

 expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 TSRMLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 TSRMLS_CC); }

Don't worry about the bits in the braces - that just defines how the actual "or" logic is handled. What you're left with is expr T_LOGICAL_OR expr, which just says that it's a valid expression to have an expression, followed by the T_LOGICAL_OR token, followed by another expression.

An expr is also defined by the parser, as you would expect. It can either be a r_variable, which just means that it's a variable that you're allowed to read, or an expr_without_variable, which is a fancy way of saying that an expression can be made of other expressions.

You can do or die() because the language construct die (not a function!) and its alias exit are both represented by the token T_EXIT, and T_EXIT is considered a valid expr_without_variable, whereas the return statement - token T_RETURN - is not.

Now, why is T_EXIT considered an expression but T_RETURN is not? Honestly, I have no clue. Maybe it was just a design choice made just to allow the or die() construct that you're asking about. The fact that it used to be so widely used - at least in things like tutorials, since I can't speak to a large volume of production code - seems to imply that this may have been an intentional choice. You would have to ask the language developers to know for sure.

With all of that said, this shouldn't matter. While the or die() construct seemed ubiquitous in tutorials (see above) a few years ago, it's not really recommended, since it's an example of "clever code". or die() isn't a construct of its own, but rather it's a trick which uses - some might say abuses - two side-effects of the or operator:

it is very low in the operator precedence list, which means practically every other expression will be evaluated before it is
it is a short-circuiting operator, which means that the second operand (the bit after the or) is not executed if the first operand returns TRUE, since if one operand is TRUE in an or expression, then they both are.

Some people consider this sort of trickery to be unfavourable, since it is harder for a programmer to read yet only saves a few characters of space in the source code. Since programmer time is expensive, and disk space is cheap, you can see why people don't like this.

Instead, you should be explicit with your intent by expanding your code into a full-fledged if statement:

$handle = fopen($location, "r");
if ($handle) {
  // process the file
} else {
  return 0;
}

You can even do the variable assignment right in the if statement. Some people still find this unreadable, but most people (myself included) disagree:

if ($handle = fopen($location, "r")) {
  // process the file
} else {
  return 0;
}

One last thing: it is convention that returning 0 as a status code indicates success, so you would probably want to return a different value to indicate that you couldn't open the file.

Using 'or die()' to stop on errors in PHP

In PHP, variable assignment (the equals sign) and functions both take precedence over the or operator. That means a function gets executed first, then the return value of the function is used in the or comparison. In turn when you use two values/variables together with an or operator, it compares the two values first then returns a Boolean value.

Therefore, the order of evaluation in this example is:

$result = mysql_query($query) or die();

mysql_query($query)
Returns either a result set for DQL queries such as SELECT, or a Boolean value for DDL, DML or DCL queries such as CREATE, DROP, INSERT, UPDATE, DELETE and ALTER.
$result = mysql_query($query)
The result of this query execution is assigned to the variable $result.
$result /* = ... */ or die();
If it's either a result set or true, it's considered true (aka "truthy") so the or condition is satisfied and the statement ends here. Otherwise the script would die() instead.

echo is a language construct and therefore doesn't actually return a value, so it doesn't run like a function before the or comparison is made.

As $name or "Anonymous" is always true because the string "Anonymous" is non-empty and therefore truthy, the echo implicitly converts true to 1, hence that output.

The order of evaluation in this example is:

$name = "John Doe";
echo $name or "Anonymous";

$name = "John Doe";
Pretty straightforward — assigns the string John Doe to $name.
$name or "Anonymous"
PHP discovers that $name contains the string John Doe, so what ends up being evaluated is the following:
"John Doe" or "Anonymous"
Since at least one string is non-empty here, it's considered truthy and the condition is satisfied. This evaluation then returns true.
echo true /* $name or... */;
Converts true to 1 and prints the number 1.

Force PHP to skip exit

It's not possible to skip or disable an "exit" command.

If you want to do something before the script stops, you can use shutdown-functions or object-destructors ... but I don't think that's something you're up to, is it?

http://www.php.net/manual/en/function.exit.php

Call a function from another function in PHP

If you are using a class, then you can use $this for calling the function:

class Test {

    public function say($a) {
        return $a ;

    } 

    public function tell() {
        $c = "Hello World" ;
        $a = $this->say($c) ;
        return $a ;
    }
} 

$b= new Test() ;    
echo $b->tell() ;

If you are using a normal function, then use closure:

function tell(){
   $a = "Hello" ;
   return function($b) use ($a){
      return $a." ".$b ;
   } ;  
}

$s = tell() ;
echo $s("World") ;

How Does "Do Something or Die()" Work in PHP