Обработка ошибок в коде программ РНР
Во-вторых, зарегистрировать ее как финализатор, передав ее имя стандартной функции register_shutdown_function().
int register_shutdown_function(string $func)
Регистрирует функцию с указанным именем с той целью, чтобы она автоматически вызывалась перед возвратом из сценария. Функция будет вызвана как при окончании программы, так и при вызовах exit() или die(), а также при фатальных ошибках, приводящих к завершению сценария — например, при синтаксической ошибке.
Конечно, можно зарегистрировать несколько финальных функций, которые будут вызываться в том же порядке, в котором они регистрировались.
Правда, есть одно "но". Финальная функция вызывается уже после закрытия соединения с браузером клиента. Поэтому все данные, выведенные в ней через echo, теряются (во всяком случае, так происходит в Unix-версии РНР, а под Windows CGI-версия РНР и echo работают прекрасно). Так что лучше не выводить никаких данных в такой функции, а ограничиться работой с файлами и другими вызовами, которые ничего не направляют в браузер.
Последнее обстоятельство, к сожалению, ограничивает функциональность финализаторов: им нельзя поручить, например, вывод окончания страницы, если сценарий по каким-то причинам прервался из-за ошибки. Вообще говоря, надо заметить, что в РНР никак нельзя в случке ошибки в некотором запущенном коде проделать какие-либо разумные действия (кроме, разумеется, мгновенного выхода).
3. ПЕРЕХВАТ ОШИБОК. МЕТОД ИСКЛЮЧЕНИЙ
Механизм обработки исключений или просто "исключения" (exceptions) — это технология, позволяющая писать код восстановления после серьезной ошибки в удобном для программиста виде. С применением исключений перехват и обработка ошибок, наиболее слабая часть в большинстве программных систем, значительно упрощается.
Концепция исключений базируется на общей идее объектно-ориентированного программирования: данные должны обрабатываться в том участке программы, который имеет максимум сведений о том, как это делать. Если в некотором месте еще не до конца известно, какое именно преобразование должно быть выполнено, лучше отложить работу "на потом". С использованием исключений код обработки ошибки явно отделяется от кода, в котором ошибка может возникнуть.
Исключения также позволяют удобно передавать информацию о возникшей ошибке вниз по дереву (стеку) вызовов функций. Таким образом, код восстановления может находиться даже не в текущей процедуре, а в той, что ее вызывает.
3.1 БАЗОВЫЙ СИНТАКСИС
Исключение — это некоторое сообщение об ошибке вида "серьезная". При своей генерации оно автоматически передается в участок программы, который лучше всего "осведомлен", что же следует предпринять в данной конкретной ситуации. Этот участок называется обработчиком исключения.
Любое исключение в программе представляет собой объект некоторого класса, создаваемый, как обычно, оператором new. Этот объект может содержать различную информацию, например, текст диагностического сообщения, а также номер строки и имя файла, в которых произошла генерация исключения. Допустимо добавлять и любые другие параметры.
Прежде чем идти дальше, давайте рассмотрим простейший пример вызова обработчика (листинг 3.1). Заодно получим представление о синтаксисе исключений.
Листинг.3.1. Файл simple.php
<?php ## Простой пример использования исключений.
echo "Начало программы.<br>";
try {
// Код, в котором перехватываются исключения.
echo "Все, что имеет начало...<br>";
// Генерируем ("выбрасываем") исключение.
throw new Exception("Hello!");
echo "...имеет и конец.<br>";
} catch (Exception $e) {
// Код обработчика.
echo " Исключение: {$e->getMessage()}<br>";
}
echo "Конец программы.<br>";
?>
В листинге 3.1 приведен пример базового синтаксиса конструкции try...catch, применяемой для работы с исключениями.
Рассмотрим эту инструкцию подробнее:
● Код обработчика исключения помещается в блок инструкции catch (в переводе с английского — "ловить").
● Блок try (в переводе с английского — "попытаться") используется для того, чтобы указать в программе область перехвата. Любые исключения, сгенерированные внутри нее (и только они), будут переданы соответствующему обработчику.
● Инструкция throw используется для генерации исключения. Генерацию также называют возбуждением или даже выбрасыванием (или "вбрасыванием") исключения (от англ. throw — бросать). Как было замечено ранее, любое исключение представляет собой обычный объект РНР, который мы и создаем в операторе new.
● Обратите внимание на аргумент блока catch. В нем указано, в какую переменную должен быть записан "пойманный" объект-исключение перед запуском кода обработчика. Также обязательно задается тип исключения — имя класса. Обработчик будет вызван только для тех объектов-исключений, которые совместимы с указанным типом (например, для объектов данного типа).
Работа инструкции try...catch заключается в том, что одна часть программы "бросает" (throw) исключение, а другая — его "ловит" (catch).
3.2 ИНСТРУКЦИЯ throw
Инструкция throw не просто генерирует объект-исключение и передает его обработчику блока catch. Она также немедленно завершает работу текущего try-блока. Именно поэтому результат работы сценария из листинга 3.1 выглядит так:
Начало программы.
Все, что имеет начало...
Исключение: Hello!
Конец программы.
Как видите, за счет особенности инструкции throw наша программа подвергает серьезному скепсису тезис "Все, что имеет начало, имеет и конец" — она просто не выводит окончание фразы.
В этом отношении инструкция throw очень похожа на инструкции return, break и continue: они тоже приводят к немедленному завершению работы текущей функции или итерации цикла.
3.3 РАСКРУТКА СТЕКА
Самой важной и полезной особенностью инструкции throw является то, что ее можно использовать не только непосредственно в try-блоке, но и внутри любой функции, которая оттуда вызывается. При этом производится выход не только из функции, содержащей throw, но также и из всех промежуточных процедур. Пример — в листинге 3.2.
Листинг3.2.Файл stack.php
<?php ## Инструкция try во вложенных функциях.
echo "Начало программы.<br>";
try {
echo "Начало try-блока.<br>";
outer();
echo "Конец try-блока.<br>";
} catch (Exception $e) {
echo " Исключение: {$e->getMessage()}<br>";
}
echo "Конец программы.<br>";
function outer() {
echo "Вошли в функцию ".__METHOD__."<br>";
inner();
echo "Вышли из функции ".__METHOD__."<br>";
}
function inner() {
echo "Вошли в функцию ".__METHOD__."<br>";
throw new Exception("Hello!");
echo "Вышли из функции ".__METHOD__."<br>";
}
?>
Результат работы данного кода выглядит так:
Начало программы.
Начало try-блока.
Вошли в функцию outer
Вошли в функцию inner
Исключение: Hello!
Конец программы.
Мы убеждаемся, что ни один из операторов echo, вызываемых после инструкции throw, не "сработал". По сути, программа даже не дошла до них: управление было мгновенно передано в catch-блок, а после этого — в следующую за try...catch строку программы.
Данное поведение инструкции throw называют раскруткой стека вызовов функций, потому что объект-исключение последовательно передается из одной функции в другую, каждый раз приводя к ее завершению — как бы "отматывает" стек.
Можно заметить, что инструкция throw очень похожа на команду return, однако она вызывает "вылет" потока исполнения не только из текущей функции, но также и из тех, которые ее вызвали (до ближайшего соответствующего catch-блока).
3.4 ИСКЛЮЧЕНИЯ И ДЕСТРУКТОРЫ
Деструктор любого объекта вызывается всякий раз, когда последняя ссылка на этот объект оказывается потерянной, например, программа выходит за границу области видимости переменной. Применительно к механизму обработки исключений это дает мощный инструмент — корректное уничтожение всех объектов, созданных до вызова throw. Листинг 3.3 иллюстрирует ситуацию.
Листинг 3.3. Файл destr.php
<?php ## Деструкторы и исключения.
// Класс, комментирующий операции со своим объектом.
class Orator {
private $name;
function __construct($name) {
$this->name = $name;
echo "Создан объект {$this->name}.<br>";
}
function __destruct() {
echo "Уничтожен объект {$this->name}.<br>";
}
}
function outer() {
$obj = new Orator(__METHOD__);
inner();
}
function inner() {
$obj = new Orator(__METHOD__);
echo "Внимание, вбрасывание!<br>";
throw new Exception("Hello!");
}
// Основная программа.
echo "Начало программы.<br>";
try {
echo "Начало try-блока.<br>";
outer();
echo "Конец try-блока.<br>";
} catch (Exception $e) {
echo " Исключение: {$e->getMessage()}<br>";
}
echo "Конец программы.<br>";
?>
Создан специальный класс, который выводит на экран диагностические сообщения в своем конструкторе и деструкторе. Объекты этого класса создаются в первой строке каждой функции.
Результат работы программы выглядит так:
Начало программы.
Начало try-блока.
Создан объект outer.
Создан объект inner.
Внимание, вбрасывание!
Уничтожен объект inner.
Уничтожен объект outer.
Исключение: Hello!
Конец программы.
При вызове throw вначале произошел корректный выход из вложенных функций (с уничтожением всех локальных объектов и вызовом деструкторов), и уж только после этого запустился catch-обработчик. Данное поведение также называют раскруткой стека.
3.5 ИСКЛЮЧЕНИЯ И set_error_handler()
В п.2 рассматривали подход к обработке нефатальных ошибок, а именно установку функции-обработчика посредством вызова функции set_error_handler(). В РНР версии 4 он являлся единственно допустимым методом.
Функция-обработчик имеет один огромный недостаток: в ней неизвестно точно, что же следует предпринять в случае возникновения ошибки.
Сравним явно механизм обработки исключений и метод перехвата ошибок. Рассмотрим пример, похожий на скрипт из листинга 3.1, иллюстрирующий суть проблемы (листинг 3.4).
Листинг 3.4. Файл seh.php
<?php ## Недостатки set_error_handler().
echo "Начало программы.<br>";
set_error_handler("handler");
{
// Код, в котором перехватываются исключения.
echo "Все, что имеет начало...<br>";
// Генерируем ("выбрасываем") исключение.
trigger_error("Hello!");
echo "...имеет и конец.<br>";
}
echo "Конец программы.<br>";
// Функция-обработчик.
function handler($num, $str) {
// Код обработчика.
echo "Ошибка: $str<br>";
// exit();
}
?>
Первое, что бросается в глаза, — это излишняя многословность кода. Но давайте пойдем дальше и посмотрим, какой результат выдает данная программа:
Начало программы.
Все, что имеет начало...
Ошибка: Hello!
За счет использования exit () в функции handler()новая программа не только подвергает сомнению известный тезис (см. операторы echo), но также и утверждает, что любая, даже малейшая, ошибка является фатальной.
Что ж, раз проблема в команде exit(), попробуем ее убрать из скрипта и увидим следующий результат:
Начало программы.
Все, что имеет начало...
Ошибка: Hello!
...имеет и конец.
Конец программы.
И снова мы получили не то, что нужно: ошибка теперь уже не является "чересчур фатальной", как раньше, у нее противоположная проблема: она, наоборот, недостаточно фатальна.
Мы-то хотели разрушать идиому о конечности всего, что имеет начало, а получили — просто робкое замечание, произнесенное шепотом из-за кулис.
3.6 КЛАССИФИКАЦИЯ И НАСЛЕДОВАНИЕ
Обычно все серьезные ошибки в программе (и внутренние, и пользовательские) поддаются некоторой классификации. Механизм обработки исключений, помимо основного своего достоинства — возможности отделения кода обработки ошибки от кода ее генерации — имеет и еще один плюс. Он заключается в возможности перехвата исключений по их видовой принадлежности на основе иерархии классов. При этом каждое исключение может принадлежать одновременно нескольким видам, и перехватываться с учетом совпадения своего (или родительского) вида.
Листинг 3.5 иллюстрирует тот факт, что при перехвате исключений используется информация о наследовании классов-исключений.
Листинг 3.5. Файл inherit.php
<?php ## Наследование исключений.
// Исключение - ошибка файловых операций.
class FilesystemException extends Exception {
private $name;
public function __construct($name) {
parent::__construct($name);
$this->name = $name;
}
public function getName() { return $this->name; }
}
// Исключение - файл не найден.
class FileNotFoundException extends FilesystemException {}
// Исключение - Ошибка записи в файл.
class FileWriteException extends FilesystemException {}
try {
// Генерируем исключение типа FileNotFoundException.
if (!file_exists("spoon"))
throw new FileNotFoundException("spoon");
} catch (FilesystemException $e) {
// Ловим ЛЮБОЕ файловое исключение!
echo "Ошибка при работе с файлом '{$e->getName()}'.<br>";
} catch (Exception $e) {
// Ловим все остальные исключения, которые еще не поймали.
echo "Другое исключение: {$e->getDirName()}.<br>";
}
?>
В программе мы генерируем ошибку типа FileNotFoundException, однако, ниже перехватываем исключение не прямо этого класса, а его "родителя" — FilesystemException. Так как любой объект типа FileNotFoundException является также и объектом класса FilesystemException, блок catch "срабатывает" для него. Кроме того, на всякий случай мы используем блок "поимки" объектов класса Exception — "родоначальника" всех исключений. Если вдруг в программе произойдет исключение другого типа (обязательно производного от Exception), оно также будет обработано.
К сожалению, в современной версии РНР реализация исключениями интерфейсов (а следовательно, и множественная классификация) не поддерживается. Точнее, можно создать класс-исключение, наследующий некоторый интерфейс, но попытка перехватить сгенерированное исключение по имени его интерфейса (а не по имени класса) не даст результата. Есть основания надеяться, что в будущих версиях РНР данное неудобство будет устранено.
3.7 БАЗОВЫЙ КЛАСС Exception
РНР последних версий не допускает использования объектов произвольного типа в качестве исключений. Если вы создаете свой собственный класс-исключение, то должны унаследовать его от встроенного типа Exception.
До сих пор мы пользовались только стандартным классом Exception, не определяя от него производных. Дело в том, что данный класс уже содержит довольно много полезных методов (например, getMessage ()), которые можно применять в программе.
Итак, каждый класс-исключение в листинге 3.5 наследует встроенный в РНР тип Exception. В этом типе есть много полезных методов и свойств, которые мы сейчас перечислим (приведен интерфейс класса):
class Exception {
protected $message; // текстовое сообщение
protected $code; // числовой код
protected $file; // имя файла, где создано исключение
protected $line; // номер строки, где создан объект
private $trace; // стек вызовов
public function__construct([string $message] [,int $code]);
public final function getMessageО; // возвращает $this->message
public final function getCode{); // возвращает $this->code
public final function getFileO; // возвращает $this->file
public final function getLine(); // возвращает $this->line
public final function getTrace();
public final function getTraceAsStringO;
public function __toStringO;
}
Как видите, каждый объект-исключение хранит в себе довольно много разных данных, блокированных для прямого доступа (protected и private). Впрочем, их все можно получить при помощи соответствующих методов.
Мы не будем подробно рассматривать все методы класса Exception, потому что большинство из них выполняют вполне очевидные действия, следующие из их названий. Остановимся только на некоторых. Обратите внимание, что большинство методов определены как final, а значит, их нельзя переопределять в производных классах.
Конструктор класса принимает два необязательных аргумента, которые он записывает в соответствующие свойства объекта. Он также заполняет свойства $fiie, $line и $trace, соответственно, именем файла, номером строки и результатом вызова функции debug_backtrace() (информацию о функциях, вызвавших данную, см. в п. 2).
Стек вызовов, сохраненный в свойстве $trace, представляет собой список с именами функций (и информацией о них), которые вызвали текущую процедуру перед генерацией исключения. Данная информация полезна при отладке скрипта и может быть получена при помощи метода getTrace(). Дополнительный метод getTraceAsString() возвращает то же самое, но в строковом представлении.
Оператор преобразования в строку _toString() выдает всю информацию, сохраненную в объекте-исключении. При этом используются все свойства объекта, а также вызывается getTraceAsString() для преобразования стека вызовов в строку. Результат, который генерирует метод, довольно интересен (листинг.3.6).
Листинг 3.6. Файл tostring.php
<?php ## Вывод сведений об исключении.
function test($n) {
$e = new Exception("bang-bang #$n!");
echo "<pre>", $e, "</pre>";
}
function outer() { test(101); }
outer();
?>
Выводимый текст будет примерно следующим:
exception 'Exception' with message 'bang-bang #101!' in tostring.php:3
Stack trace:
#0 tostring.php(6): test(101)
#1 tostring.php{7): outer()
#2 (main)
3.8 ИСПОЛЬЗОВАНИЕ ИНТЕРФЕЙСОВ
В РНР поддерживается только одиночное наследование классов: у одного и того же типа не может быть сразу двух "предков". Применение интерфейсов дает возможность реализовать множественную классификацию — отнести некоторый класс не к одному, а сразу к нескольким возможным типам.
Множественная классификация оказывается как нельзя кстати при работе с исключениями. С использованием интерфейсов вы можете создавать новые классы-исключения, указывая им не одного, а сразу нескольких "предков" (и, таким образом, классифицируя их по типам).
Использование интерфейсов вместе с исключениями возможно, начиная с РНР 5.0.1.
Предположим, у нас в программе могут возникать серьезные ошибки следующих основных видов:
● внутренние: детальная информация в браузере не отображается, но записывается в файл журнала. Внутренние ошибки дополнительно подразделяются на:
• файловые (ошибка открытия, чтения или записи в файл);
• сетевые (например, невозможность соединения с сервером);
● пользовательские: сообщения выдаются прямо в браузер.
Для классификации сущностей в программе удобно использовать интерфейсы. Давайте так и поступим по отношению к объектам-исключениям (листинг 3.7).
Листинг 3.7. Файл iface/interfaces.php
<?php ## Классификация исключений.
interface IException {}
interface IInternalException extends IException {}
interface IFileException extends IInternalException {}
interface INetException extends IInternalException {}
interface IUserException extends IException {}
?>
Обратите внимание, что интерфейсы не содержат ни одного метода и свойства, а используются только для построения дерева классификации.
Теперь, если в программе имеется некоторый объект-исключение, чей класс реализует интерфейс INetException, мы также сможем убедиться, что он реализует и интерфейс IInternalException:
if ($obj instanceof IlnternalException) echo "Это внутренняя ошибка.";
Кроме того, если мы будем использовать конструкцию catch (InternalException ...), то сможем перехватить любое из исключений, реализующих интерфейсы IFileException и INetException.
Мы также "на всякий случай" задаем одного общего предка у всех интерфейсов — lException. Вообще говоря, это делать не обязательно.
Интерфейсы, конечно, не могут существовать сами по себе, и мы не можем создавать объекты типов IFileException (к примеру) напрямую. Необходимо определить классы, которые будут реализовывать наши интерфейсы (листинг 3.8).
Листинг 3.8. Файл iface/exceptions.php
<?php ## Классы-исключения.
require_once "interfaces.php";
// Ошибка: файл не найден.
class FileNotFoundException extends Exception
implements IFileException {}
// Ошибка: ошибка доступа к сокету.
class SocketException extends Exception
implements INetException {}
// Ошибка: неправильный пароль пользователя.
class WrongPassException extends Exception
implements IUserException {}
// Ошибка: невозможно записать данные на сетевой принтер.
class NetPrinterWriteException extends Exception
implements IFileException, INetException {}
// Ошибка: невозможно соединиться с SQL-сервером.
class SqlConnectException extends Exception
implements IInternalException, IUserException {}
?>
Обратите внимание на то, что исключение типа NetPrinterWriteException реализует сразу два интерфейса. Таким образом, оно может одновременно трактоваться и как файловое, и как сетевое исключение, и перехватываться как конструкцией catch (IFileException ...), так и catch (InetException ...).
За счет того, что все классы-исключения обязательно должны наследовать базовый тип Exception, мы можем, как обычно, проверить, является ли переменная объектом-исключением, или она имеет какой-то другой тип:
if ($obj instanceof Exception) echo "Это объект-исключение.";
Рассмотрим теперь пример кода, который использует приведенные выше классы (листинг3.9).
Листинг 3.9. Файл iface/test.php
<?php ## Использование иерархии исключений.
require_once "exceptions.php";
try {
printDocument();
} catch (IFileException $e) {
// Перехватываем только файловые исключения.
echo "Файловая ошибка: {$e->getMessage()}.<br>";
} catch (Exception $e) {
// Перехват всех остальных исключений.
echo "Неизвестное исключение: <pre>", $e, "</pre>";
}
function printDocument() {
$printer = "//./printer";
// Генерируем исключение типов IFileException и INetException.
if (!file_exists($printer))
throw new NetPrinterWriteException($printer);
}
?>
Результатом работы этой программы (в случае ошибки) будет строчка:
Ошибка записи в файл //./printer.
3.9 БЛОКИ-ФИНАЛИЗАТОРЫ
Как мы знаем, инструкция throw заставляет программу немедленно покинуть охватывающий try-блок, даже если при этом будет необходимо выйти из нескольких промежуточных функций (и даже вложенных try-блоков, если они есть). Такой "неожиданный" выход иногда оказывается нежелательным, и программист хочет написать код — финализатор, который бы выполнялся, например, при завершении функции в любом случае — независимо от того, как именно был осуществлен выход из блока.
3.9.1 Неподдерживаемая конструкция try...finally
В языках программирования Java и Delphi для реализации кода-финализатора имеется очень удобная конструкция try...finally, призванная гарантировать выполнение некоторых действий в случае возникновения исключения или внезапного завершения функции по return. На РНР это можно было бы записать так:
function eatThis() { throw new Exception("bang-bang!"); } function hello() {
echo "Все, что имеет начало, ";
try {
eatThis () ;
} finally {
echo "имеет и конец.";
}
echo "this never prints!"; }
// Вызываем функцию, hello() ;
Семантика инструкции try...finally должна быть ясна: она гарантирует выполнение finally-блока, даже если внезапно будет осуществлен выход из try-блока.
К сожалению, Zend Engine 2, на которой построен РНР 5, пока не поддерживает конструкцию try...finally, так что приведенный выше код, скорее всего, откажется работать. Почему "скорее всего"? Да потому, что есть все основания полагать, что рано или поздно инструкция finally в РНР появится, поскольку она очень удобна. Возможно, что инструкция finally уже появилась.
3.9.2 "Выделение ресурса есть инициализация"
Как же быть в случае, если нам нужно написать код, который будет обязательно выполнен при завершении работы функции? Единственная на данный момент возможность добиться этого — помещение такого кода в деструктор некоторого класса и создание объекта этого класса непосредственно в функции. Мы знаем, что при выходе из процедуры РНР автоматически уничтожает все переменные-ссылки, созданные внутри тела процедуры. Соответственно, если ссылка на объект будет единственной, то вызовется деструктор его класса. В листинге 3.3 мы уже рассматривали такой подход.
В соответствии с терминологией Страуструпа данный подход называют "выделение ресурса есть инициализация". Это объясняется вот чем: обычно в finally-блоках программы производится "освобождение" некоторых объектов-ресурсов, "выделенных" до момента возникновения исключения. Вызов конструктора объекта — это его инициализация.
Если работу с любыми ресурсами в программе реализовать через объекты, то необходимость в finally-блоках просто не возникнет. В самом деле, программа будет сама следить, когда нужно освободить тот или иной ресурс (вызвать деструктор соответствующего объекта), и нам не придется задумываться о явном написании кода освобождения.
3.9.3 Перехват всех исключений
Поскольку любой класс-исключение произволен от класса Exception, мы можем написать один-единственный блок-обработчик для всех возможных исключений в программе:
echo "Начало программы.<br>";
try {
eatThis ();
}
catch (Exception $e)
{
echo "Неперехваченное исключение: ", $e;
}
echo "Конец программы.<br>";
Таким образом, если в функции eatThis() возникнет любая исключительная ситуация, и объект-исключение "выйдет" за ее пределы (т. е. не будет перехвачен внутри самой процедуры), сработает наш универсальный код восстановления (оператор echo).
Перехват всех исключений при помощи конструкции catch (Exception ...) позволяет нам обезопаситься от неожиданного завершения работы функции (или блока) и гарантировать выполнение некоторого кода в случае возникновения исключения. В этом отношении конструкция очень похожа на инструкцию finally, которой в РНР на данный момент нет.
К сожалению, неожиданные вызовы return в функции при этом не обрабатываются, и отследить их пока нельзя.
Рассмотрим пример функции, которую мы пытались написать выше с использованием try...finally. Фактически, листинг 3.10 иллюстрирует, как можно проэмулировать finally в программе на РНР.
Листинг 3.10. Файл catchall.php
<?php ## Перехват всех исключений.
// Пользовательское исключение.
class HeadshotException extends Exception {}
// Функция, генерирующая исключение.
function eatThis() { throw new HeadshotException("bang-bang!"); }
// Функция с кодом-финализатором.
function action() {
echo "Все, что имеет начало, ";
try {
// Внимание, опасный момент!
eatThis();
} catch (Exception $e) {
// Ловим ЛЮБОЕ исключение, выводим текст...
echo "имеет и конец.<br>";
// ...а потом передаем это исключение дальше.
throw $e;
}
}
try {
// Вызываем функцию.
action();
} catch (HeadshotException $e) {
echo "Извините, вы застрелились: {$e->getMessage()}";
}
?>
В результате работы программы в браузере будет выведен следующий текст:
Все, что имеет начало, имеет и конец.
Извините, вы застрелились: bang-bang!
Как видите, код-финализатор в функции action() срабатывает "прозрачно" для вызывающей программы: исключение типа HeadsnotException не теряется, а выходит за пределы функции за счет повторного использования throw внутри catch-блока.
Такая техника вложенного вызова throw называется повторной генерацией исключения. Обычно ее применяют в случае, когда внутренний обработчик не может полностью обработать исключение, и его нужно передать дальше, чтобы ошибка была проанализирована в более подходящем месте.
3.10 ТРАНСФОРМАЦИЯ ОШИБОК
Мы разделили все ошибки на два вида:
● "несерьезные" - диагностические сообщения; перехватываются при помощи set_error_handier();
● "серьезные" - невозможно продолжить нормальный ход работы кода, представлены исключениями.
Мы также отмечали, что, эти два вида ошибок не пересекаются и в идеале должны обрабатываться независимыми механизмами (ибо имеют различные подходы к написанию кода восстановления).
Известно, что в программировании любая ошибка может быть усилена, по крайней мере, без ухудшения качества кода. Например, если заставить РНР немедленно завершать работу скрипта не только при обнаружении ошибок класса E_ERROR и E_PARSE (перехват которых вообще невозможен), но также и при возникновении E_WARNING и даже E_NOTICE, программа станет более "хрупкой" к неточностям во входных данных. Но зато программист будет просто вынужден волей-неволей писать более качественный код, проверяющий каждую мелочь при своей работе. Таким образом, качество написания кода при "ужесточении" реакции на ошибку способно только возрасти, а это обычно является большим достоинством.
3.10.1 Серьезность "несерьезных" ошибок
Что касается увеличения "хрупкости" при ужесточении реакции на ошибки, то это слишком неопределенная формулировка. Часто даже нельзя заранее предсказать, насколько тот или иной участок кода чувствителен к неожиданным ситуациям.
Для примера рассмотрим сообщение класса E_WARNING, возникающее при ошибке открытия файла. Является ли оно фатальным, и возможно ли дальнейшее выполнение программы при его возникновении без каких-либо ветвлений? Однозначного ответа на этот вопрос дать нельзя.
Вот две крайние ситуации.
● Невозможность открытия файла крайне фатальна. Например, пусть скрипт открывает какой-нибудь файл, содержащий программный код, который необходимо выполнить (такие ситуации встречаются при модульной организации сценариев). При невозможности запуска этого кода вся дальнейшая работа программы может стать попросту бессмысленной.
● Невозможность открытия файла практически ни на что не влияет. К примеру, программа может записывать в этот файл информацию о том, когда она была запущена. Или даже более простой пример: скрипт просто проверяет, существует ли нужный файл, а если его нет, то создает новый пустой.
Рассмотрим теперь самое "слабое" сообщение, класса E_NOTICE, которое генерируется РНР, например, при использовании неинициализированной переменной. Часто такие ошибки считают настолько незначительными, что даже отключают реакцию на них в файле php.ini (error_reporting=E_ALL~E_NOTICE). Более того, именно такое значение error_reporting выставляется по умолчанию в дистрибутиве PHP.
Нетрудно опять привести два примера крайних ситуаций, когда E_NOTICE играет очень важную роль и, наоборот, ни на что не влияет (на примере использования переменной или ячейки массива, которой ранее не было присвоено значение).
Предположим, вы исполняете SQL-запрос для добавления новой записи в таблицу MySQL:
INSERT INTO table (id, parent_id, text)
VALUES (NULL, '$pid', 'Have you ever had a dream, that you were so sure was real?')
В переменной $pid хранится некоторый идентификатор, который должен быть обязательно числовым. Если эта переменная окажется неинициализированной (например, где-то в программе выше произошла опечатка), будет сгенерирована ошибка E_NOTICE, а вместо $pid подставится пустая строка. SQL-запрос же все равно останется синтаксически корректным. В результате в базе данных появится запись с полем parent_id, равным нулю (пустая строка '' без всяких предупреждений трактуется MySQL как 0). Это значение может быть недопустимым для поля