Maybe I\'m missing it somewhere in the PHP manual, but what exactly is the difference between an error and an exception? The only difference that I can see is that errors and exceptions are handled differently. But what causes an exception and what causes an error?
可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试):
问题:
回答1:
Exceptions are thrown - they are intended to be caught. Errors are generally unrecoverable. Lets say for instance - you have a block of code that will insert a row into a database. It is possible that this call fails (duplicate ID) - you will want to have a \"Error\" which in this case is an \"Exception\". When you are inserting these rows, you can do something like this
try {
$row->insert();
$inserted = true;
} catch (Exception $e) {
echo \"There was an error inserting the row - \".$e->getMessage();
$inserted = false;
}
echo \"Some more stuff\";
Program execution will continue - because you \'caught\' the exception. An exception will be treated as an error unless it is caught. It will allow you to continue program execution after it fails as well.
回答2:
I usually set_error_handler to a function that takes the error and throws an exception so that whatever happens i\'ll just have exceptions to deal with. No more @file_get_contents just nice and neat try/catch.
In debug situations i also have an exception handler that outputs an asp.net like page. I\'m posting this on the road but if requested I will post example source later.
edit:
Addition as promised, I\'ve cut and pasted some of my code together to make a sample. I\'ve saved the below to file on my workstation, you can NO LONGER see the results here (because the link is broken).
<?php
define( \'DEBUG\', true );
class ErrorOrWarningException extends Exception
{
protected $_Context = null;
public function getContext()
{
return $this->_Context;
}
public function setContext( $value )
{
$this->_Context = $value;
}
public function __construct( $code, $message, $file, $line, $context )
{
parent::__construct( $message, $code );
$this->file = $file;
$this->line = $line;
$this->setContext( $context );
}
}
/**
* Inspire to write perfect code. everything is an exception, even minor warnings.
**/
function error_to_exception( $code, $message, $file, $line, $context )
{
throw new ErrorOrWarningException( $code, $message, $file, $line, $context );
}
set_error_handler( \'error_to_exception\' );
function global_exception_handler( $ex )
{
ob_start();
dump_exception( $ex );
$dump = ob_get_clean();
// send email of dump to administrator?...
// if we are in debug mode we are allowed to dump exceptions to the browser.
if ( defined( \'DEBUG\' ) && DEBUG == true )
{
echo $dump;
}
else // if we are in production we give our visitor a nice message without all the details.
{
echo file_get_contents( \'static/errors/fatalexception.html\' );
}
exit;
}
function dump_exception( Exception $ex )
{
$file = $ex->getFile();
$line = $ex->getLine();
if ( file_exists( $file ) )
{
$lines = file( $file );
}
?><html>
<head>
<title><?= $ex->getMessage(); ?></title>
<style type=\"text/css\">
body {
width : 800px;
margin : auto;
}
ul.code {
border : inset 1px;
}
ul.code li {
white-space: pre ;
list-style-type : none;
font-family : monospace;
}
ul.code li.line {
color : red;
}
table.trace {
width : 100%;
border-collapse : collapse;
border : solid 1px black;
}
table.thead tr {
background : rgb(240,240,240);
}
table.trace tr.odd {
background : white;
}
table.trace tr.even {
background : rgb(250,250,250);
}
table.trace td {
padding : 2px 4px 2px 4px;
}
</style>
</head>
<body>
<h1>Uncaught <?= get_class( $ex ); ?></h1>
<h2><?= $ex->getMessage(); ?></h2>
<p>
An uncaught <?= get_class( $ex ); ?> was thrown on line <?= $line; ?> of file <?= basename( $file ); ?> that prevented further execution of this request.
</p>
<h2>Where it happened:</h2>
<? if ( isset($lines) ) : ?>
<code><?= $file; ?></code>
<ul class=\"code\">
<? for( $i = $line - 3; $i < $line + 3; $i ++ ) : ?>
<? if ( $i > 0 && $i < count( $lines ) ) : ?>
<? if ( $i == $line-1 ) : ?>
<li class=\"line\"><?= str_replace( \"\\n\", \"\", $lines[$i] ); ?></li>
<? else : ?>
<li><?= str_replace( \"\\n\", \"\", $lines[$i] ); ?></li>
<? endif; ?>
<? endif; ?>
<? endfor; ?>
</ul>
<? endif; ?>
<? if ( is_array( $ex->getTrace() ) ) : ?>
<h2>Stack trace:</h2>
<table class=\"trace\">
<thead>
<tr>
<td>File</td>
<td>Line</td>
<td>Class</td>
<td>Function</td>
<td>Arguments</td>
</tr>
</thead>
<tbody>
<? foreach ( $ex->getTrace() as $i => $trace ) : ?>
<tr class=\"<?= $i % 2 == 0 ? \'even\' : \'odd\'; ?>\">
<td><?= isset($trace[ \'file\' ]) ? basename($trace[ \'file\' ]) : \'\'; ?></td>
<td><?= isset($trace[ \'line\' ]) ? $trace[ \'line\' ] : \'\'; ?></td>
<td><?= isset($trace[ \'class\' ]) ? $trace[ \'class\' ] : \'\'; ?></td>
<td><?= isset($trace[ \'function\' ]) ? $trace[ \'function\' ] : \'\'; ?></td>
<td>
<? if( isset($trace[ \'args\' ]) ) : ?>
<? foreach ( $trace[ \'args\' ] as $i => $arg ) : ?>
<span title=\"<?= var_export( $arg, true ); ?>\"><?= gettype( $arg ); ?></span>
<?= $i < count( $trace[\'args\'] ) -1 ? \',\' : \'\'; ?>
<? endforeach; ?>
<? else : ?>
NULL
<? endif; ?>
</td>
</tr>
<? endforeach;?>
</tbody>
</table>
<? else : ?>
<pre><?= $ex->getTraceAsString(); ?></pre>
<? endif; ?>
</body>
</html><? // back in php
}
set_exception_handler( \'global_exception_handler\' );
class X
{
function __construct()
{
trigger_error( \'Whoops!\', E_USER_NOTICE );
}
}
$x = new X();
throw new Exception( \'Execution will never get here\' );
?>
回答3:
The answer deserves talking about the elephant in the room
Errors is the old way of handling an error condition at run-time. Typically the code would make a call to something like set_error_handler before executing some code. Following the tradition of assembly language interrupts. Here is how some BASIC code would look.
on error :divide_error
print 1/0
print \"this won\'t print\"
:divide_error
if errcode = X
print \"divide by zero error\"
It was hard to make sure that set_error_handler would be called with the right value. And even worse, a call could be made to a separate procedure that would change the error handler. Plus many times calls were interspersed with set_error_handler calls and handlers. It was easy for code to quickly get out of control. Exception handling came to the rescue by formalizing syntax and semantics of what good code was really doing.
try {
print 1/0;
print \"this won\'t print\";
} catch (DivideByZeroException $e) {
print \"divide by zero error\";
}
No separate function or risk of calling the wrong error handler. The code now is guaranteed to be in the same place. Plus we get better error messages.
PHP used to only have error handling, when many other languages already had evolved to the preferable exception handling model. Eventually the makers of PHP implemented exception handling. But likely to support old code, they kept error handling and provided a way to make error handling look like exception handling. Except that, there is no guarantee that some code may not reset the error handler which was precisely what exception handling was meant to provide.
Final answer
Errors that were coded before exception handling was implemented, are likely still errors. New errors are likely exceptions. But there is no design or logic to which are errors and which are exceptions. It\'s just based in what was available at the time it was coded, and the preference of the programmer coding it.
回答4:
One thing to add here is about handling exceptions and errors. For the purpose of the application developer, both errors and exceptions are \"bad things\" that you want to record to learn about the problems that your application has - so that your customers have a better experience in the long run.
So it makes sense to write an error handler that does the same thing as what you do for exceptions.
回答5:
As stated in other answers, setting error handler to exception thrower is the best way to handle errors in PHP. I use a bit simpler setup:
set_error_handler(function ($errno, $errstr, $errfile, $errline ) {
if (error_reporting()) {
throw new \\ErrorException($errstr, 0, $errno, $errfile, $errline);
}
});
Please note the error_reporting() check to keep @ operator working. Also, there is no need to define custom exception, PHP has one nice class for that.
Great benefit of throwing exceptions is that exception has stack trace associated with them, so it is easy to find where is the problem.
回答6:
I think the anwser you\'re looking for is that;
Errors are the standard stuff you\'re used to, like echoing a $variable that doesnt exist.
Exceptions are only from PHP 5 onwards and come when dealing with objects.
To keep it simple:
Exceptions are the errors you get when dealing with objects. The try/catch statement lets you do something about them though, and is used much like the if/else statement. Try to do this, if problem, doesnt matter, do this.
If you dont \"catch\" an exception, then it turns into a standard error.
Errors are the php fundemental errors which usually halt your script.
Try/catch is often used for establishing database connections like PDO, which is fine if you want to redirect the script or do something else if the connection doesnt work. But if you just want to display the error message and stop the script then you dont need it, the uncaught exception turns into a fatal error. Or you can use a site-wide error handling setting as well.
Hope that helps
回答7:
Re: \"but what exactly is the difference between an error and an exception?\"
There are a lot of good answers about the differences here. I\'ll just add in something that hasn\'t yet been talked about - performance. Specifically, this is for the difference between throwing/handling exceptions and handling a return code (either success or some error). Usually, in php, this means returning false or null, but they can be more detailed such as with file uploading: http://php.net/manual/en/features.file-upload.errors.php You could even return an Exception object!
I\'ve done a few performance runs in different languages/systems. Generally speaking, exception handling is about 10,000x slower than checking for an error return code.
So, if it absolutely, positively needs to finish executing before it even started - well, you\'re out of luck because time travel doesn\'t exist. Without time travel, return codes are the fastest option available.
Edit:
PHP is highly optimized for exception handling. Real world tests show that throwing an exception is only 2-10x slower than returning a value.
回答8:
Exceptions are thrown intentionally by code using a throw, errors... not so much.
Errors come about as a result of something which isn\'t handled typically. (IO errors, TCP/IP errors, null reference errors)
回答9:
I intend to give you a most unusual discussion of error control.
I built a very good error handler into a language years ago, and though some of the names have changed, the principles of error processing are the same today. I had a custom built multi-tasking OS and had to be able to recover from data errors at all levels with no memory leaks, stack growth or crashes. So what follows is my understanding of how errors and exceptions must operate and how they differ. I will just say I do not have an understanding of how the internals of try catch works, so am guessing to some measure.
The first thing that happens under the covers for error processing is jumping from one program state to another. How is that done? I\'ll get to that.
Historically, errors are older and simpler, and exceptions are newer and a bit more complex and capable. Errors work fine until you need to bubble them up, which is the equivalent of handing a difficult problem to your supervisor.
Errors can be numbers, like error numbers, and sometimes with one or more associated strings. For example if a file-read error occurs you might be able to report what it is and possibly gracefully fail. (Hay, it\'s a step up from just crashing like in the old days.)
What is not often said about exceptions is that exceptions are objects layered on a special exception stack. It\'s like a return stack for program flow, but it holds a return state just for error trys and catches. (I used to call them ePush and ePop, and ?Abort was a conditional throw which would ePop and recover to that level, while Abort was a full die or exit.)
On the bottom of the stack is the information about the initial caller, the object that knows about the state when the outer try was started, which is often when your program was started. On top that, or the next layer on the stack, with up being the children, and down being the parents, is the exception object of the next inner try/catch block.
If you put a try inside a try you are stacking the inner try on top of the outer try. When an error occurs in the inner try and either the inner catch can\'t handle it or the error is thrown to the outer try, then control is passed to the outer catch block (object) to see if it can handle the error, i.e. your supervisor.
So what this error stack really does is to be able to mark and restore program flow and system state, in other words, it allows a program to not crash the return stack and mess up things for others (data) when things go wrong. So it also saves the state of any other resources like memory allocation pools and so it can clean them up when catch is done. In general this can be a very complicated thing, and that is why exception handling is often slow. In general quite a bit of state needs to go into these exception blocks.
So a try/catch block sort of sets a state to be able to return to if all else gets messed up. It\'s like a parent. When our lives get messed up we can fall back into our parent\'s lap and they will make it all right again.
Hope I didn\'t disappoint you.
回答10:
Once set_error_handler() is defined, error handler is similar to Exception\'s. See code below:
<?php
function handleErrors( $e_code ) {
echo \"error code: \" . $e_code . \"<br>\";
}
set_error_handler( \"handleErrors\" );
trigger_error( \"trigger a fatal error\", E_USER_ERROR);
echo \"after error.\"; //it would run if set_error_handler is defined, otherwise, it wouldn\'t show
?>
{var%20f='http://v.t.sina.com.cn/share/share.php?appkey=1515056452',u=z||d.location,p=['&url=',e(u),'&title=',e(t||d.title),'&source=',e(r),'&sourceUrl=',e(l),'&content=',c||'gb2312','&pic=',e(p||'')].join('');function%20a(){if(!window.open([f,p].join(''),'mb',['toolbar=0,status=0,resizable=1,width=440,height=430,left=',(s.width-440)/2,',top=',(s.height-430)/2].join('')))u.href=[f,p].join('');};if(/Firefox/.test(navigator.userAgent))setTimeout(a,0);else%20a();})(screen,document,encodeURIComponent,'','','https://img.manongdao.com/sparkler-677774__340.jpg', '推荐 只靠听说 的文章《PHP: exceptions vs errors?》','https://www.manongdao.com/article-7070.html','页面编码gb2312|utf-8默认gb2312'));){kind=link}