Главная » Ошибки » PHP: Исключения – класс Exception

PHP: Исключения – класс Exception

Что такое исключение в PHP7

Исключения – это специальное условие, которое возникает в исключительной ситуации (обычно в случае ошибки), при возникновении которого мы можем понять, что что-то в процессе отличается от предполагаемого хода событий.

Пример: Предположим, мы разрабатываем блог и работаем над методами удаления категории. По логике вещей нельзя удалить категорию, в которой есть посты. Здесь нам приходят на помощь исключения. Очень урезанный и простой пример, но отражающий суть:

// Где-то (модель или сервис)
public function delete($id)
{
$category = Category::find($id);
// Если категория не найдена – кидаем исключение
if (!$category) throw new Exception(‘Page Not Found!’);
// Если в категории есть посты – кидаем исключение
if (count($category->posts) > 0) throw new Exception(‘Cannot delete category with posts!’);
// Если всё хорошо – продолжаем выполнение кода
// Удаляем категорию
}

// В контроллере
public function deleteAction($id)
{
try {
// Если метод delete() из модели возвращает true
$model->delete($id);
} catch (Exception $e) {
// Если false – ловим брошенное из модели исключение
echo $e->getMessage();
// Или вывести в уведомление через сессию, например
// Session::set(‘error’, $e->getMessage());
}
}

Согласитесь, удобно. Вместо того, чтобы просто возвращать false в случае, когда срабатывает условие if (count($category->products) > 0), лучше кинуть исключение и как-то оповестить пользователя о каких-либо возникших исключительных ситуациях. Если же мы просто вернём false, то мы сами со временем не сможем понять, что именно там случилось и почему этот метод не работает. Поэтому, я советую всегда пользоваться исключениями, но слишком не увлекаясь этим делом.

Сколько уровней ошибок доступно в PHP?

В PHP 5 целых 16 уровней ошибок. Эти ошибки представляют категорию, а иногда и серьезность ошибки в PHP. Их много, но многочисленные категории позволяют легко определить, где отлаживать ошибку, исходя только из ее уровня. Итак, если вы хотите сделать что-то конкретное только для ошибок пользователя, например, проверку ввода, вы можете определить обработчик условий для всего, что начинается с E_USER. Если вы хотите убедиться, что вы закрыли ресурс, вы можете сделать это, указав на ошибки, оканчивающиеся на _ERROR.

Ошибки в PHP по большей части классифицируются по степени серьезности (предупреждение об ошибке, уведомление) и источнику (пользователь, компилятор, среда выполнения).

Я хочу остановиться на нескольких популярных из них.

Во-первых, у нас есть общие ошибки:

  • E_ERROR (значение 1): это типичная фатальная ошибка. Если вы видите этого плохого парня, ваше приложение готово. Перезагрузите и попробуйте еще раз.
  • E_WARNING (2): это ошибки, которые не приводят к сбою вашего приложения. Похоже, что большинство ошибок находятся на этом уровне.

Читайте также:  Технические тенденции, которые нужно знать на 2022 год

Далее у нас есть пользовательские ошибки:

  • E_USER_ERROR (256): созданная пользователем версия указанной выше фатальной ошибки. Это часто создается с помощью trigger_error ().
  • E_USER_NOTICE (1024): созданная пользователем версия информационного события. Обычно это не оказывает неблагоприятного воздействия на приложение, как и log.info ().

Последняя категория, на которую следует обратить внимание, — это ошибки жизненного цикла приложения, обычно с «core» или «compile» в названии:

  • EE_CORE_ERROR (16): Подобно фатальным ошибкам выше, эта ошибка может возникнуть только при запуске приложения PHP.
  • EE_COMPILE_WARNING (128): нефатальная ошибка, которая возникает только тогда, когда скрипт PHP не компилируется.

Есть еще несколько ошибок. Вы можете найти их полный список здесь.

Handling Multiple Exceptions

PHP 7.1 introduced multiple exceptions catching, where a single catch statement could be used to handle multiple exceptions. Consider this code snippet:

Ошибки отображения PHP

Отображение сообщений об ошибках в PHP часто сбивает с толку. Просто погуглите «Отображение сообщения об ошибке PHP» и посмотрите. Почему так?

В PHP вы можете решить, отображать ли ошибки или нет. Это отличается от сообщения о них. Сообщение о них гарантирует, что ошибки не будут проглочены. Но отображение их покажет их пользователю. Вы можете настроить отображение всех ошибок PHP с помощью директив display_errors и display_startup_errors:

Их включение гарантирует, что они будут отображаться в теле веб-ответа пользователю. Обычно рекомендуется отключать их в среде, не связанной с разработкой. Целочисленный параметр метода также является битовой маской, как в error_reporting(). Здесь также применяются те же правила и параметры для этого параметра.

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

help@w3schools.com

Your Suggestion:

Your E-mail:Page address:Description:
<текстареа rows="10" class="w3-input w3-border" id="err_desc" name="err_desc" style="width:100%;margin-top:5px;resize:vertical;"> Submit
–>

×

Класс Exception

Исключение (Exception) – это объект, являющийся экземпляром встроенного класса Exception. Этот объект создаётся для хранения информации о произошедшей ошибке и для вывода сообщений о ней.

Конструктор класса Exception может принимать два необязательных параметра – это строка, содержащая сообщение об ошибке и её код. Класс Exception так же содержит методы, помогающие установить причину возникшей ошибки:

  • getMessage() – возвращает строку, которая была передана конструктору и содержит сообщение об ошибке.
  • getCode() – возвращает код ошибки (тип int), который был передан конструктору.
  • getFile() – возвращает имя файла в котором было сгенерировано исключение.
  • getLine() – возвращает номер строки в которой было сгенерировано исключение.
  • getTrace() – возвращает многомерный массив, содержащий последовательность методов, вызов которых привёл к генерированию исключения. Так же содержит параметры, которые были переданы этим методам и номера строк, где осуществлялись вызовы.
  • getTraceAsString() – возвращает строковую версию данных, которые возвращает метод getTrace().
  • __toString() – магический метод, который вызывается, когда экземпляр класса Exception приводится к строке.

Как помогают отчеты о сбоях

PHP упрощает настройку внешних инструментов отчетов об ошибках, подобных тем, которые предлагает Raygun. Он предоставляет несколько различных ловушек для своей среды выполнения, чтобы обрабатывать ошибки и отправлять их по сети. См. Этот пример, взятый со страницы PHP Raygun :

namespace
{
// paste your ‘requires’ statement

$client = new Raygun4phpRaygunClient(“apikey for your application”);

function error_handler($errno, $errstr, $errfile, $errline ) {
global $client;
$client->SendError($errno, $errstr, $errfile, $errline);
}

function exception_handler($exception)
{
global $client;
$client->SendException($exception);
}

set_exception_handler(‘exception_handler’);
set_error_handler(“error_handler”);
}

Сначала мы объявляем клиента, используя ключ API для безопасности:

$client = new Raygun4phpRaygunClient(“apikey for your application”);

Затем мы создаем пару функций, которые обрабатывают наши ошибки и исключения:

function error_handler($errno, $errstr, $errfile, $errline ) {
global $client;
$client->SendError($errno, $errstr, $errfile, $errline);
}

function exception_handler($exception)
{
global $client;
$client->SendException($exception);
}

Обратите внимание, что мы вызываем SendError()функцию, передавая некоторые важные сведения о структуре данных ошибки. Это сделает удаленный вызов Raygun.

Наконец, мы подключаем их к среде выполнения PHP, глобально обрабатывая как традиционные ошибки, так и новые исключения:

set_exception_handler(‘exception_handler’);
set_error_handler(“error_handler”);

Вот и все. Имея все это на месте, мы можем получить красиво отформатированный отчет об ошибках, который может выглядеть следующим образом:

Try, throw and catch

To avoid the error from the example above, we need to create the proper code
to handle an exception.

Proper exception code should include:

  1. try – A function using an exception should be in a “try” block. If the exception does not trigger, the code will continue as normal. However if the exception triggers, an exception is “thrown”
  2. throw – This is how you trigger an exception. Each “throw” must have at least one “catch”
  3. catch – A “catch” block retrieves an exception and creates an object containing the exception information

Lets try to trigger an exception with valid code:

//create function with an exception
function checkNum($number) {
  if($number>1) {
    throw new Exception(“Value must be 1 or below”);
  }
  return true;
}
//trigger exception in a “try” block
try {
  checkNum(2);
  //If the exception is thrown, this text will not be shown
  echo ‘If you see this, the number is 1 or below’;
}
//catch exception
catch(Exception $e) {
  echo ‘Message: ‘ .$e->getMessage();
}
?>

The code above will get an error like this:

Message: Value must be 1 or below

Rules for exceptions

  • Code may be surrounded in a try block, to help catch potential exceptions
  • Each try block or “throw” must have at least one corresponding catch block
  • Multiple catch blocks can be used to catch different classes of exceptions
  • Exceptions can be thrown (or re-thrown) in a catch block within a try block

A simple rule: If you throw something, you have to catch it.

❮ Previous
Next ❯

NEW

We just launched
W3Schools videos



Explore now

COLOR PICKER

colorpicker

LIKE US

–>

Get certified
by completing
a course today!

w3schoolsCERTIFIED.2022

Get started

Exercises

HTMLCSSJavaScriptSQLPHPPythonBootstrapjQuery

–>

CODE GAME

Code Game

Play Game

HOW TO

Tabs
Dropdowns
Accordions
Side Navigation
Top Navigation
Modal Boxes
Progress Bars
Parallax
Login Form
HTML Includes
Google Maps
Range Sliders
Tooltips
Slideshow
Sort List

–>

Cathing Errors

You should avoid catching Error objects unless logging them for the future solution. Because Error always points to code problems, not some temporary runtime issues. It is better to fix such problems instead of handling them at runtime. In general, Error objects should be caught for logging and for performing any necessary cleanup.

Генерация исключений

Для генерации исключения используется ключевое слово throw и экземпляр класса Exception. С английского throw переводится как «бросать», что очень точно описывает поведение этого оператора. Он генерирует (бросает) исключение в каком-либо методе (в котором может случиться нестандартная, исключительная ситуация) и останавливает дальнейшее выполнение кода, тем самым предоставляя возможность обработать это исключение в методе (в любом месте приложения), который будет вызывать данный метод с брошенным исключением.

// Класс User
class User
{
private $name;

public function setName($name)
{
if (!$name) throw new InvalidArgumentException(‘Имя не задано!’);
if (strlen($name) < 3) throw new LengthException('Имя должно быть больше 3-х символов!'); $this->name = $name;
}

public function getName(): string
{
return $this->name;
}

// …
}

Basic Use of Exceptions

When an exception is thrown, the code following it will not be executed, and
PHP will try to find the matching “catch” block.

If an exception is not caught, a fatal error will be issued with an “Uncaught
Exception” message.

Lets try to throw an exception without catching it:

//create function with an exception
function checkNum($number) {
  if($number>1) {
    throw new Exception(“Value must be 1 or below”);
  }
  return true;
}
//trigger exception
checkNum(2);
?>

The code above will get an error like this:

Fatal error: Uncaught exception ‘Exception’
with message ‘Value must be 1 or below’ in C:webfoldertest.php:6
Stack trace: #0 C:webfoldertest.php(12):
checkNum(28) #1 {main} thrown in C:webfoldertest.php on line 6

Using Error in Your Code

Users are able to create Error as well as extend Error to create your own hierarchy of Error classes. This poses an important question: what situations should throw an instance of a class extending Exception and what situations should throw an instance of a class extending Error?

Error should be used to represent coding issues that require the attention of a programmer. Error objects thrown from the PHP engine fall into this category, as they generally result from coding errors such as providing a parameter of the wrong type to a function or a parse error in a file. Exception should be used for conditions that can be safely handled at runtime where another action can be taken and execution can continue.

Since Error objects should not be handled at runtime, catching Error objects should be uncommon. In general, Error objects should only be caught for logging, performing any necessary cleanup, and display an error message to the user.

Creating a Custom Exception Class

To create a custom exception handler you must create a special
class with functions that can be called when an exception occurs in PHP. The
class must be an extension of the exception class.

The custom exception class inherits the properties from PHP’s
exception class and you can add custom functions to it.

Lets create an exception class:

class customException extends Exception {
  public function errorMessage() {
    //error message
    $errorMsg = ‘Error on line ‘.$this->getLine().’ in ‘.$this->getFile()
    .’: ‘.$this->getMessage().’ is not a valid E-Mail address’;
    return $errorMsg;
  }
}
$email = “someone@example…com”;
try {
  //check if
  if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) {
    //throw exception if email is not valid
    throw new customException($email);
  }
}
catch (customException $e) {
  //display custom message
  echo $e->errorMessage();
}
?>

The new class is a copy of the old exception class with an addition of the
errorMessage() function. Since it is a copy of the old class, and it inherits
the properties and methods from the old class, we can use the exception class
methods like getLine() and getFile() and getMessage().

Как включить отчеты об ошибках в PHP

Включить отчеты об ошибках в PHP очень просто. Вы просто вызываете функцию в своем скрипте:

Здесь сказано: «Пожалуйста, сообщайте об ошибках всех уровней». Мы рассмотрим, какие уровни есть позже, но считаем это категорией ошибок. По сути, он говорит: «Сообщайте обо всех категориях ошибок». Вы можете отключить отчет об ошибках, установив 0:

Параметр метода в error_reporting()действительности является битовой маской. Вы можете указать в нем различные комбинации уровней ошибок, используя эту маску, как видите:

В нем говорится: «сообщать о фатальных ошибках, предупреждениях и ошибках синтаксического анализатора». Вы можете просто разделить их знаком «|» чтобы добавить больше ошибок. Иногда вам могут потребоваться более расширенные настройки отчетов об ошибках. Вы можете использовать операторы битовой маски для составления отчетов по различным критериям:

Как видите, вы можете гибко определять, о каких ошибках сообщать. Возникает вопрос: о каких типах ошибок и исключений следует сообщать?

Multi-Catch Exception Handling

In PHP7.1 when several different types of exceptions are handled the same way, we can use multi-catch instead of duplication of catch statements:

In PHP7.1 we can use a single catch statement to avoid code duplication:

@ 2021. All rights reserved.

If you’ve got any feedback, comments or just want to chat you can get in
touch via Twitter or email .

Обработка исключений

И так, метод, который вызывает метод, в котором в свою очередь может быть брошено исключение, должен сам его обрабатывать. Обработка исключения производится при помощи операторов try – catch. Блок кода, который может поймать исключение, располагается после try. Блок кода, который обрабатывает исключение, располагается после оператора catch. В переводе с английского try означает «пытаться», что очень точно отражает суть этого оператора, ведь мы пытаемся выполнить блок кода после него, а если не получается то выполняется блок кода после catch. Catch переводится как «ловить». Он фактически «ловит» сгенерированное исключение. В примере ниже мы ловим исключение из метода setName() класса User из примера выше:

// Где-то ловим исключение и обрабатываем его
try {
$user = new User();
$user->setName(‘John’);
// Случится исключение InvalidArgumentException
$user->setName(”);
// Случится исключение LengthException
$user->setName(‘Jo’);
echo $user->getName();
} catch (Exception $e) {
echo “Message: {$e->getMessage()}
Code: {$e->getCode()}
File: {$e->getFile()}
Line: {$e->getLine()}”;
}

Ловим исключение в блоке try:

try {
// …

$config = “config.php”;
if (!file_exists($config)) {
throw new Exception(“Configuration file not found.”);
}

// …
} catch (Exception $e) {
echo $e->getMessage();
die();
}

Но так делать не рекомендуется (try/catch и throw на одном уровне). В этом случае проще написать if!

Оператор catch внешне напоминает объявление метода с уточнением типа его аргумента. Когда генерируется исключение, управление передаётся оператору catch, при этом в качестве аргумента ему передаётся объект типа Exception.

Example explained:

The code above tests if the email-address contains the string “example” in
it, if it does, the exception is re-thrown:

  1. The customException() class is created as an extension of the old exception class. This way it inherits all methods and properties from the old exception class
  2. The errorMessage() function is created. This function returns an error message if an e-mail address is invalid
  3. The $email variable is set to a string that is a valid e-mail address, but contains the string “example”
  4. The “try” block contains another “try” block to make it possible to re-throw the exception
  5. The exception is triggered since the e-mail contains the string “example”
  6. The “catch” block catches the exception and re-throws a “customException”
  7. The “customException” is caught and displays an error message

If the exception is not caught in its current “try” block, it will search for a catch block on “higher levels”.

Set a Top Level Exception Handler

The set_exception_handler() function sets a user-defined function to handle all
uncaught exceptions:

function myException($exception)
{
 
echo “Exception: ” . $exception->getMessage();
}
set_exception_handler(‘myException’);
throw new Exception(‘Uncaught Exception occurred’);
?>

The output of the code above should be something like this:

Exception: Uncaught Exception occurred

In the code above there was no “catch” block. Instead, the top level
exception handler triggered. This function should be used to catch uncaught
exceptions.

Changes for Backward Compatibles

Backward compatibility is an important issue for PHP 7.x. The most important thing to remember is that in PHP 7.x, fatal errors are inherited from the Error class. For code written in previous versions, where set_exception_handler() is used to set custom handlers, catching of fatal errors might slip through! To avoid this, remember to avoid custom handlers on PHP 7.x code and just use Throwable class for custom exception catching and handling

Какие бывают типы ошибок в PHP?

Ошибка PHP — это не одно и то же, но бывает четырех разных типов:

  • синтаксические или синтаксические ошибки
  • фатальные ошибки
  • предупреждения об ошибках
  • замечать ошибки

Ошибки синтаксического анализа или синтаксиса

Первая категория ошибок в PHP — это ошибки синтаксического анализа, также называемые синтаксическими ошибками. Они просто означают, что в вашем скрипте есть один или несколько неправильных символов. Возможно, вы пропустили точку с запятой или неправильно поставили скобку. Взгляните на следующий пример:

= 18 {
echo ‘Of Age’;
} else {
echo ‘Minor’;
}
?>

Запустив приведенный выше сценарий, я получаю следующую ошибку:

Parse error: syntax error, unexpected ‘{‘ in

on line 4

С помощью сообщения об ошибке легко увидеть, что в операторе if отсутствует закрывающая скобка. Давайте исправим это:

= 18) {
echo ‘Of Age’;
} else {
echo ‘Minor’;
}
?>

Фатальные ошибки

Неустранимые ошибки, как следует из их названия, — это те, которые способны убить — или привести к сбою — приложение. Другими словами, фатальные ошибки — это критические ошибки, означающие, что произошло что-то катастрофическое, и приложение не может продолжать работу.

Часто причиной фатальных ошибок является неопределенный класс, функция или другой артефакт. Если сценарий пытается использовать несуществующую функцию, PHP не знает, что делать, и сценарий необходимо остановить.

Рассмотрим следующий сценарий:

Как видите, сценарий определяет функцию с именем add, а затем пытается вызвать ее с неправильным именем. Эта ситуация приводит к фатальной ошибке:

Fatal error: Uncaught Error: Call to undefined function sum() in F:xampphtdocstest.php:7 Stack trace: #0 {main} thrown in

on line 7

Все, что нужно для решения ошибки, — это изменить вызов функции на правильное имя, добавить:

echo ‘2 + 2 is ‘ . add(2, 2);

Предупреждение об ошибках

Предупреждающие ошибки — это ошибки, которые не приводят к завершению работы скрипта. Подобно тому, что происходит на других языках, предупреждение в PHP обычно представляет собой что-то, что еще не является серьезной проблемой — или, по крайней мере, не критичной, — но может стать серьезной проблемой в будущем, поэтому вам лучше сохранить глаз на это.

Читайте также:  10 лучших бесплатных SEO расширений для браузера

Взгляните на следующий код:

После выполнения приведенного выше кода мы получаем следующее предупреждение:

Warning: parse_url() expects at least 1 parameter, 0 given in

on line 2

Предупреждение вызывает тот факт, что мы не предоставили параметр функции parse_url. Давайте исправим это:

Это устраняет предупреждение:

array(2) { [“scheme”]=> string(5) “https” [“host”]=> string(11) “example.com” }

Уведомление об ошибках

Уведомления об ошибках похожи на предупреждения в том, что они также не останавливают выполнение скрипта. Вы также должны думать об ошибках уведомления как о том, что PHP предупреждает вас о том, что может стать проблемой в будущем. Однако уведомления обычно считаются менее важными или менее важными, чем предупреждения.

Рассмотрим следующий фрагмент кода, который представляет собой измененную версию сценария, использованного в предыдущих разделах:

Как видите, сценарий определяет переменную $ numbers, а затем пытается передать переменную с именем $ inteers в функцию explode.

Неопределенные переменные действительно являются одной из основных причин уведомлений в PHP. Чтобы ошибка исчезла, достаточно изменить переменную $ inteers на $ numbers.

Создание подклассов класса Exception

От встроенного класса Exception можно унаследовать классы для своих собственных исключений. Делать это можно для того чтобы расширить его функциональность или создать свой собственный тип ошибок. Создание своих собственных типов ошибок нужно для того, чтобы была возможность по-разному обрабатывать разные исключения. Для этого существует возможность писать несколько операторов catch. Какой именно из них вызовется, будет зависеть от типа сгенерированного исключения, от типа, который уточнён в аргументе и от порядка, в котором расположены операторы catch.

Пример собственного класса исключения:

code}]: {$this->message}n”;
}

public function customFunction() {
echo “Мы можем определять новые методы в наследуемом классеn”;
}
}

Что такое предупреждение PHP?

Выше вы заметили, что одним из уровней ошибок является E_WARNING. Вы также могли заметить, что многие уровни ошибок имеют версии предупреждений. Я хочу немного в этом разобраться. Основное различие между предупреждением и ошибкой в ​​PHP заключается в том, завершает ли оно приложение. В PHP большинство ошибок фактически не останавливают выполнение скрипта.

Вот пример:

Вы все равно будете видеть, $x is 3несмотря на срабатывание предупреждения. Это может быть полезно, если вы хотите собрать список ошибок проверки. Я лично предпочитаю использовать исключения в наши дни, но ваш опыт может отличаться.

Конечно, вы можете настроить отображение предупреждений PHP или нет. Для этого вы должны использовать конфигурацию display_errors, которую вы видели в предыдущем разделе.

Полная иерархия исключений в PHP7

Throwable (интерфейс)
├── Exception (реализует Throwable)
│ ├── LogicException (расширяет Exception)
│ │ ├── BadFunctionCallException (расширяет LogicException)
│ │ │ └── BadMethodCallException (расширяет BadFunctionCallException)
│ │ ├── DomainException (расширяет LogicException)
│ │ ├── InvalidArgumentException (расширяет LogicException)
│ │ ├── LengthException (расширяет LogicException)
│ │ └── OutOfRangeException (расширяет LogicException)
│ └── RuntimeException (расширяет Exception)
│ ├── OutOfBoundsException (расширяет RuntimeException)
│ ├── OverflowException (расширяет RuntimeException)
│ ├── RangeException (расширяет RuntimeException)
│ ├── UnderflowException (расширяет RuntimeException)
│ └── UnexpectedValueException (расширяет RuntimeException)
└── Error (реализует Throwable)
├── AssertionError (расширяет Error)
├── ParseError (расширяет Error)
└── TypeError (расширяет Error)

Throwable

Throwable — это даже не исключение, а интерфейс, который реализуют все остальные рассматриваемые классы. Добавлен в PHP7.

Exception

Базовый класс для исключений. Стандартная библиотека SPL вводит две группы исключений, два надкласса: для исключений в логике: LogicException и исключений времени исполнении RuntimeException.

LogicException

Используется, когда ваш код возвращает значение, которое не должен возвращать. Часто вызывается при разных багах в коде. Потомки этого класса используются в более специализированных ситуациях. Если ни одна из них не подходит под ваш случай, можно использовать LogicException.

BadFunctionCallException

Используется, когда вызываемой функции физически не существует или когда в вызове используется неверное число аргументов. Редко бывает нужно.

BadMethodCallException

Подкласс BadFunctionCallException. Аналогично ему используется для методов, которые не существуют или которым передано неверное число параметров. Всегда используйте внутри __call(), в основном для этого оно и применяется.

Пример использования этих двух исключений:

// Для метода в __call
class Foo
{     
public function __call($method, $args)     
{         
switch ($method) {
        case ‘someExistentClass’: /* do something positive… */ break;
        default:
throw new BadMethodCallException(‘Метод ‘ . $method . ‘ не может быть вызван’);
        }
    }  
}
 
// процедурный подход function
foo($arg1, $arg2)
{
   $func = ‘do’ . $arg2;
   if (!is_callable($func)) {         
throw new BadFunctionCallException(‘Функция ‘ . $func . ‘ не может быть вызвана’);     
}
}

DomainException

Если в коде подразумеваются некие ограничения для значений, то это исключение можно вызывать, когда значение выходит за эти ограничения. Например, у вас дни недели обозначаются числами от 1 до 7, а ваш метод получает внезапно на вход 0 или 9, или, скажем, вы ожидаете число, обозначающее количество зрителей в зале, а получаете отрицательное значени. В таких случаях и вызывается DomainException. Также можно использовать для разных проверок параметров, когда параметры нужных типов, но при этом не проходят проверку на значение. Например:

if ($a > 5)
    throw new DomainException (“Переменная a должна быть меньше 5”);

InvalidArgumentException

Вызываем, когда ожидаемые аргументы в функции/методе некорректно сформированы. Например, ожидается целое число, а на входе строка или ожидается GET, а пришел POST и т.п.

public function foo($number) {
if(!is_numeric($number)) {
throw new InvalidArgumentException(‘На входе ожидалось целое число!’);
}
}

LengthException

Вызываем, если длина чего-то слишком велика или мала. Например, имя файла слишком короткое или длина строки слишком большая.

RuntimeException

Исключения времени выполнения нужно вызывать, когда код самостоятельно не может справиться с некой ситуацией во время своего выполнения. Подклассы этого класса сужают область применения, но, если ни один из них не подходит для вашей ситуации, смело пользуйтесь этим классом. Вот из каких пяти подклассов вам можно выбирать:

OutOfBoundsException

Вызываем, когда обнаружили попытку использования неправильного ключа, например, в ассоциативном массиве или при реализации ArrayAccess. Используется тогда, когда ошибка не может быть обнаружена до прогона кода. То есть, например, какие именно ключи будут легитимными, определяется динамически уже во время выполнения.

Пример использования в реализации ArrayAccess:

public function offsetGet($offset) {
if(!isset($this->objects[$offset])) {
throw new OutOfBoundsException(“Смещение ‘$offset’ вышло из заданного диапазона”);
}

return $this->objects[$offset];
}

OutOfRangeException

Используется, когда встречаем некорректный индекс, но на этот раз ошибка должна быть обнаружена ещё до прогона кода, например, если мы пытаемся адресовать элемент массива, который в принципе не поддерживается. То есть если функция, возвращающая день недели по его индексу от 1 до 7, получает внезапно 9, то это DomainException — ошибка логики, а если у нас есть массив с днями недели с индексами от 1 до 7, а мы пытаемся обратиться к элементу с индексом 9, то это уже OutOfRangeException.

OverflowException

Исключение вызываем, когда есть переполнение. Например, имеется некий класс-контейнер, который может принимать только 5 элементов, а мы туда пытаемся записать шестой.

UnderflowException

Обратная OverflowException ситуация, когда, например, класс-контейнер имеет недостаточно элементов для осуществления операции. Например, когда он пуст, а вы пытаетесь удалить элемент.

RangeException

Вызывается, когда значение выходит за границы некоего диапазона. Похоже на DomainException, но используется при возврате из функции, а не при входе. Если мы не можем вернуть легитимное значение, мы выбрасываем это исключение. То есть, к примеру, функция у вас принимает целочисленный индекс и использует другую функцию, чтоб получить некое значение по этой сущности. Та функция вернула null, но ваша функция не имеет права возвращать Null. В таком случае можно применить это исключение. То есть между ними примерно такая же разница, как между OutOfBoundsException и OutOfRangeException.

UnexpectedValueException

Используется, когда значение выходит из ряда ожидаемых значений. Часто применяется, когда то, что вернулось из вызываемой функции, не соответствует тому, что мы от нее ожидаем в ответе по типу или значению. Сюда не относятся арифметические ошибки или ошибки, связанные с буфером.

Важно, что, в отличие от InvalidArgumentException, здесь мы имеем дело, в основном, с возвращаемыми значениями. Часто мы заранее не можем быть уверены в том, что придет в ответе от функции (особенно сторонней). Скажем, мы используем некую стороннюю функцию, использующую API ВКонтакте, и возвращющую количество постов для пользователя. Она всегда возвращала целое неотрицательное число, и вдруг неожиданно возвращает отрицательное число. Это не соответствует документации. Соответственно, чтобы подстраховаться от таких ситуаций, мы можем проверять результат такого вызова и, если он отличается от ожидаемого, выбрасывать UnexpectedValueException.

Вот пример, когда у нас есть список констант, и функция getValueOfX должна гарантированно возвращать значение одной из них.

const TYPE_FOO = ‘foo’;
const TYPE_BAR = ‘bar’;

public function doSomething($y) {
$x = ModuleUsingSomeExternalAPI::getValueOfX($y);
if($x != self::TYPE_FOO || $x != self::TYPE_BAR) {
throw new UnexpectedValueException(‘Параметр должен быть в виде TYPE_* констант’);
}
}

Error

Добавлено в PHP7 для обработки фатальных ошибок. То есть многие из ошибок, которые раньше приводили к Fatal Error, в PHP7 могут обрабатываться в блоках try/catch. Эти ошибки вызываются самим PHP, нет нужды их вызывать, как Exception. Класс Error имеет три подкласса:

AssertionError

Вызывается, когда условие, заданное методом assert(), не выполняется.

ParseError

Для ошибок парсинга, когда подключаемый по include/require код вызывает ошибку синтаксиса, ошибок функции eval() и т.п.

try {
   require ‘file-with-syntax-error.php’;
} catch (ParseError $e) {
   // обработка ошибки
}

TypeError

Используется для ошибок несоответствия типов данных. В PHP7 введена опциональная строгая типизация. Вот для поддержки ошибок, связанных с ней, и служит этот класс. Например, если функция ожидает на входе аргумент типа int, а вы ее вызываете со строковым аргументом.

if (!is_string($name)) throw new TypeError(‘Имя должно быть стройкой!’);

Источники

  • https://prowebmastering.ru/exception-php.html
  • https://bestprogrammer.ru/izuchenie/polnoe-rukovodstvo-po-otchetam-ob-oshibkah-php-v-2021-godu
  • https://www.codementor.io/@ahmedkhan847/how-php-7-handles-exceptions-class-errors-5k28fku72
  • https://www.w3schools.com/php/php_exception.asp
  • https://sergeyzhuk.me/2016/12/24/php7-errors-and-exceptions/
  • https://trowski.com/2015/06/24/throwable-exceptions-and-errors-in-php7/
[свернуть]
Решите Вашу проблему!


×
Adblock
detector