[MUSIC]

Hi, I'm Alena.

Exceptions are the object oriented approach to handling errors.

An exception is an object that's thrown by your application

in the event that something goes wrong.

This allows you to interrupt the flow of the program and customize

how the application handles errors, or gracefully exit the application.

When an exception is thrown it halts

the processing until the exception is either caught or left on handled.

If left on handled the exception stops the application.

This unhandled exception is the typical behavior for a fatal error.

But what makes exceptions, exceptionally useful is the ability to catch them.

Catching exceptions allows us to recover gracefully and

either exit our application or customize the error.

We can customize what happens based on what type of exception we receive.

I can put the yellow balls in a bag, the blue ball in a basket,

and the red ball in a box to mail somewhere else.

In production, unhandled exceptions who cause the page to stop loading, or

not load it all, but catching exceptions gives you the ability

to determine what happens with each exception.

You might redirect a user to an error page, log an issue, or

do any other type of error handling.

Let's take a look at the syntax used for

catching database exceptions with the PHP data object.

First, we have the keyword, try,

then within curly braces we have the code we want to try, or

attempt to execute, in this case, connecting to a sqlite database.

If there is an error in the connection, such as spelling sqlite with two Ls,

the PTO class will throw an exception that we catch in the next block.

After the keyword, catch, we use parenthesis to tell PHP what

we'll be catching, in this case, exception.

We then assign the exception that was caught to a new variable, e.

Then we can use that exception variable to get details using the exception methods.

We've used three methods for

this message, get message, returns, could not find driver.

Get file, returns the full path to the file.

And get line, returns the line number where the exception occurred.

You wouldn't want all these details displayed in production.

You would probably show a simple error message and log more details.

You could also try a secondary database connection at this point.

What happens in the catch block is really up to you and

the requirements of your application.

There are additional methods available for the exception class, so

make sure you check the notes associated with this video for more details.

In the next few videos we'll cover more details on how to use exceptions and

under what conditions.

But, first, here are four tips for making proper use of exceptions.

First, exceptions are part of object oriented programming.

Since an exception is an object itself,

it's really designed to work best with an object oriented approach to programming.

PHP offers a number of options for

error handling when working with procedural code.

In most cases, I recommend using errors for procedural code and

exceptions when working with objects.

If you haven't seen the workshop on error handling,

check the notes attach this video for more details.

Second, exceptions are exceptional.

Don't use exceptions to manage normal program flow.

A try catch block is not an if else statement,

your application should still function without the try catch block.

Third, exceptions are meant to be handled.

The very existence of a try catch block

indicates that exceptions are meant to be handled.

They are meant to be resolved, even if that resolution

is to rethrow the exception after doing some sort of error handling.

With errors, fatal or

otherwise, there's the possibility that something was completed halfway.

Exceptions help eliminate this possibility by halting processing long enough for

you to clean up before terminating the application.

For example, closing the connection to a database, or

cleaning up half written file.

And finally, exceptions are not meant to be silenced.

If you have an empty catch block, you are silencing the exception.

The application will not be halted and

there is no error handling in the catch block.

The exception simply disappears.

PHP throws exceptions because there's a problem, and frameworks do the same.

Handle those exceptions, don't just silence them.

Quietly handling exceptions is not the same as silencing them.

If an exception is thrown because a file does not exist, and

in your catch block you create that file,

the exception has now been handled and your code may continue processing.

Exceptions are thrown for a reason.

Catch them, handle them, don't ignore or silence them.