--PAGE_BREAK--log_errors
● Возможные значения: on или off.
● Где устанавливается: php.ini, .htaccess, iniseto.
Если директива display_errors установлена в значение on, все сообщения об ошибках и предупреждения выводятся в браузер пользователя, запустившего скрипт.
Если же установлен параметр log_errors, то сообщения дополнительно попадают и в файл журнала (см. ниже директиву error_log).
При отладке скриптов рекомендуется устанавливать display_errors в значение on, потому что это сильно упрощает работу. И наоборот, если скрипт работает на хостинге, сообщения об ошибках нежелательны — лучше их выключить, а вместо этого включить log_errors.
1.3.3 ДИРЕКТИВА error_log error_log
● Возможные значения: абсолютный путь к файлу (по умолчанию — не задан).
● Где устанавливается: php.ini, .htaccess, ini_set().
В PHP существуют два метода вывода сообщений об ошибках: печать ошибок в браузер и запись их в файл журнала (log-файл). Директива error_log задает путь к журналу.
1.4 УСТАНОВКА РЕЖИМА ВЫВОДА ОШИБОК Для установки режима вывода ошибок во время работы программы служит функция error_reporting().
int error_reporting([int $level])
Эта функция устанавливает «уровень строгости» для системы контроля ошибок РНР, т. е. величину параметра error_reporting в конфигурации РНР.
Рекомендуется первой строкой сценария ставить вызов:
error_reporting(E_ALL);
При этом могут раздражать «мелкие» сообщения типа «использование неинициализированной переменной». Практика показывает, что эти предупреждения свидетельствуют (чаще всего) о возможной логической ошибке в программе, и что при их отключении может возникнуть ситуация, когда программу будет очень трудно отладить.
1.5 ОПЕРАТОР ОТКЛЮЧЕНИЯ ОШИБОК Есть и еще один аргумент в пользу того, чтобы всегда включать полный контроль ошибок. Это — существование в РНР оператора @. Если этот оператор поставить перед любым выражением, то все ошибки, которые там возникнут, будут проигнорированы.
Если в выражении используется результат работы функции, из которой вызывается другая функция и т. д., то предупреждения будут заблокированы для каждой из них. Поэтому осторожно применяйте @.
Например:
if (!@filemtime(«notextst.txt») )
echo «Файл не существует!»;
Попробуйте убрать оператор @ — тут же получите сообщение: «Файл не найден», а только после этого — вывод оператора echo. Однако с оператором @ предупреждение будет подавлено, что и требовалось.
В приведенном примере, возможно, несколько логичнее было бы воспользоваться функцией file_exists(), которая как раз и предназначена для определения факта существования файла, но в некоторых ситуациях это не подойдет. Например:
//Обновить файл, если он не существует или очень старый
if (! file_exists($fname) | | filemtime ($fname)
myFunctionForUpdateFile($fname);
Сравните со следующим фрагментом:
// Обновить файл, если он не существует или очень старый
if (@filemtime($fname)
myFunctionForUpdateFile($fname);
Всегда помните об операторе @. Он удобен. Рекомендуется не рисковать, задавая слабый контроль ошибок при помощи функции error_reporting(), если такой контроль и так можно локально установить при помощи оператора @?
Оператор отключения ошибок @ ценен еще и тем, что он блокирует не только вывод ошибок в браузер, но также и в log-файл. Пример из листинга 1.1 иллюстрирует ситуацию.
Листинг 1.1. Файл er.php
error_reporting(E_ALL);
ini_set(«error_log», «log.txt»);
ini_set(«log_errors», true);
@filemtime(«spoon»);
?>
Запустив приведенный скрипт, вы заметите, что файл журнала log.txt даже не создался. Попробуйте теперь убрать оператор @ — вы- получите предупреждение «stat failed for spoon», и оно же запишется в log.txt.
1.5.1 ПРИМЕР ИСПОЛЬЗОВАНИЯ ОПЕРАТОРА @ Пусть имеется форма с submit-кнопкой, и нужно в сценарии определить, нажата ли она. Можно сделать это так:
if (!empty($submit)) echo «Кнопка нажата!»;
…
?>
Согласитесь, код листинга 1.2 элегантнее.
Листинг 1.2. Файл submit.php
if (@$_REQUEST['submit']) echo «Кнопка нажата!»
?>
">
1.5.2 ПРЕДОСТЕРИЖЕНИЯ ПО ПРИМЕНЕНИЮ ОПЕРАТОРА ОТКЛЮЧЕНИЯ ОШИБОК @ Оператор @ следует применять с осторожностью. Например, следующий код никуда не годится — постарайтесь не повторять его в своих программах.
// Не подавляйте сообщения об ошибках во включаемых файлах — иначе
// отладка превратится в кромешный ад!
@include «mistake.php»;
//Не используйте оператор @ перед функциями, написанными на РНР,
// если только нет 100%-й уверенности в том, что они работают
// корректно в любой ситуации!
@myOwnBigFunction();
Рекомендации, в каких случаях применение оператора подавления ошибок оправдано и относительно безопасно:
● в конструкциях if (@$_REQUEST[' key' ]) для проверки существования (и ненулевого значения) элемента массива;
● перед стандартными функциями РНР вроде fopen(), filemtime(), mysql_connect() и т. д., если далее идет проверка кода возврата и вывод сообщения об ошибке;
● в HTML-файлах со вставками PHP-кода, если очень лень писать много кавычек: (такой вызов не породит ошибок, несмотря на отсутствие кавычек).
Во всех остальных случаях лучше несколько раз подумать, прежде чем применять оператор @. Чем меньше область кода, в которой он будет действовать, тем более надежной окажется программа. Поэтому не рекомендуется использовать @ перед include — это заблокирует проверку ошибок для очень большого фрагмента программы.
2. ПЕРЕХВАТ ОШИБОК. МЕТОД РЕГИСТРАЦИИ ОБРАБОТЧИКА ОШИБОК В РНР версии 5 существуют два метода перехвата ошибок во время выполнения программы:
● регистрация обработчика ошибки.
● исключений;
РНР поддерживает средства, позволяющие «перехватывать» момент возникновения той или иной ошибки (или предупреждения) и вызывать при этом функцию, написанную пользователем.
Метод перехвата ошибок при помощи пользовательских функций далек от совершенства. Сделать с сообщением что-либо разумное, кроме как записать его куда-нибудь и завершить программу (при необходимости), не представляется возможным.
Метод исключений, который рассмотрен в п. 3, лишен этого недостатка, он достаточно сложен и практически не реализован на уровне стандартных функций РНР.
Пример использования обработчика ошибок приведен в листинге 2.1.
Листинг 2.1. Файл handler1.php
// Определяем новую функцию-обработчик.
function myErrorHandler($errno, $msg, $file, $line) {
// Если используется @, ничего не делать.
if (error_reporting() == 0) return;
// Иначе — выводим сообщение.
echo '';
echo «Произошла ошибка с кодом $errno!»;
echo «Файл: $file, строка $line.»;
echo «Текст ошибки: $msg»;
echo "";
}
// Регистрируем ее для всех типов ошибок.
set_error_handler(«myErrorHandler», E_ALL);
// Вызываем функцию для несуществующего файла, чтобы
// сгенерировать предупреждение, которое будет перехвачено.
filemtime(«spoon»);
?>
Что бы ни произошло, программа всегда продолжает свою работу — просто в момент возникновения ошибочной ситуации вызывается функция-обработчик, а затем выполнение идет дальше. Именно по этой причине обработчик нельзя назвать кодом восстановления.
2.1 ФУНКЦИЯ set_error_handler Функция
string set_error_handler(string $runcName [, int $errorTypes])
регистрирует пользовательский обработчик ошибок — функцию, которая будет вызвана при возникновении сообщений, указанных в $errorTypes типов (битовая маска, например, E_ALL ~ E_NOTICE).
Сообщения, не соответствующие маске $errorTypes, будут в любом случае обрабатываться встроенными средствами РНР, а не предыдущей установленной функцией-перехватчиком. Имя пользовательской функции передается в параметре $runcName. Если до этого был установлен какой-то другой обработчик, функция вернет его имя — с тем, чтобы его можно было позже восстановить. Пользовательский обработчик должен задаваться так, как показано в листинге 2.2.
Листинг 2.2. Файл handler0.php
// Определяем новую функцию-обработчик.
function myErrorHandler($errno, $msg, $file, $line) {
echo '';
echo «Произошла ошибка с кодом $errno!»;
echo «Файл: $file, строка $line.»;
echo «Текст ошибки: $msg»;
echo "";
}
// Регистрируем ее для всех типов ошибок.
set_error_handler(«myErrorHandler», E_ALL);
// Вызываем функцию для несуществующего файла, чтобы
// сгенерировать предупреждение, которое будет перехвачено.
filemtime(«spoon»);
?>
Теперь при возникновении любой ошибки или даже предупреждения в программе будет вызвана функция myErrorHandier(). Ее аргументы получат значения, соответственно, номера ошибки, текста ошибки, имени файла и номера строки, в которой было сгенерировано сообщение.
К сожалению, не все типы ошибок могут быть перехвачены таким образом. Например, ошибки трансляции во внутреннее представление E_PARSE, а также E_ERROR немедленно завершают работу программы. Вызовы функции die()также не перехватываются.
Назначить функцию реакции на E_PARSE и E_ERROR все же можно. Дело в том, что перехватчик выходного потока скрипта, устанавливаемый функцией ob__start(), обязательно вызывается при завершении работы программы, в том числе в случае фатальной ошибки. Конечно, ему не передается сообщение об ошибке и ее код; он должен сам получить эти данные из «хвоста» выходного потока (например, используя функции для работы с регулярными выражениями).
В случае если пользовательский обработчик возвращает значение false (и только его!), считается, что ошибка не была обработана, и управление передается стандартному обработчику РНР (обычно он выводит текст ошибки в браузер). Все остальные возвращаемые значения (включая даже null или, что то же самое, в случае, если оператора return вообще нет), приводят к подавлению запуска стандартной процедуры обработки ошибок.
2.2 ФУНКЦИЯ restore_error_handler() void restore_error_handler()
Когда вызывается функция set_error_handler(), предыдущее имя пользовательской функции запоминается в специальном внутреннем стеке РНР. Чтобы извлечь это имя и тут же его установить в качестве обработчика, применяется функция restore_error_handler().Пример:
// Регистрируем обработчик для всех типов ошибок.
set_error_handler(«myErrorHandler», E_ALL);
// Включаем подозрительный файл.
include «suspicious_file.php»;
// Восстанавливаем предыдущий обработчик.
restore_error_handler();
Необходимо следить, чтобы количество вызовов restore_error_handler() было в точности равно числу вызовов set_error_handler().Нельзя восстановить то, чего нет.
2.3 ПРОБЛЕМЫ С ОПЕРАТОРОМ @ Пользовательская функция перехвата ошибок вызывается вне зависимости от того, был ли использован оператор подавления ошибок в момент генерации предупреждения. Это очень неудобно: поставив оператор @ перед вызовом filemtime(), мы увидим, что результат работы скрипта нисколько не изменился: текст предупреждения по-прежнему выводится в браузер.
Для того чтобы решить проблему, воспользуемся полезным свойством оператора @: на время своего выполнения он устанавливает error_reporting, равным нулю. Значит, мы можем определить, был ли вызван оператор @ в момент «срабатывания» обработчика, по нулевому значению функции error_reporting() (при вызове без параметров она возвращает текущий уровень ошибок) — листинг 2.3.
Листинг 2.3. Файл handler.php
// Определяем новую функцию-обработчик.
function myErrorHandler($errno, $msg, $file, $line) {
// Если используется @, ничего не делать.
if (error_reporting() == 0) return;
// Иначе — выводим сообщение.
echo '';
echo «Произошла ошибка с кодом $errno!»;
echo «Файл: $file, строка $line.»;
echo «Текст ошибки: $msg»;
echo "";
}
// Регистрируем ее для всех типов ошибок.
set_error_handler(«myErrorHandler», E_ALL);
// Вызываем функцию для несуществующего файла, чтобы
// сгенерировать предупреждение, которое будет перехвачено.
@filemtime(«spoon»);
?>
Теперь все работает корректно: предупреждение не отображается в браузере, т. к. применен оператор @.
2.4 ГЕНЕРАЦИЯ ОШИБОК Функция
void trigger_error(string $message [, int $type])
предназначена для искусственной генерации сообщения об ошибки с указанным типом. В РНР существует несколько констант, чьи имена начинаются с E_USER_, которые можно использовать наравне с E_ERROR, E_WARNING и т. д., но только для персональных нужд. Именно с функцией trigger_error() они чаще всего и применяются. Вот эти константы:
E_ERROR
E_WARNING
E_USER_NOTICE
Как их использовать — целиком зависит от программиста: никаких ограничений не налагается.
int error_log(string $msg [,int $type=O] [,string $dest] [, string $extra_headers])
Выше мы рассматривали директивы log_errors и error_log, которые заставляют РНР записывать диагностические сообщения в файл, а не только выводить их в браузер. Функция error_log по своему смыслу похожа на trigger_error(), однако, она заставляет интерпретатор записать некоторый текст ($msg) в файл журнала (при нулевом $type и по умолчанию), заданный в директиве error_log. Основные значения аргумента $type, которые может принимать функция, перечислены ниже:
● $type = = 0
Записывает сообщение в системный файл журнала или в файл, заданный в директиве error_log.
● $type = = 1
Отправляет сообщение по почте адресату, чей адрес указан в $dest. При этом $extra_headers используется в качестве дополнительных почтовых заголовков.
● $type == 3
Сообщение добавляется в конец файла с именем $dest.
2.5 СТЕК ВЫЗОВОВ ФУНКЦИЙ В РНР версии 4.3.0 и старше существует возможность проследить всю цепочку вызовов функций, начиная от главной программы и заканчивая текущей выполняемой процедурой.
Функция
list debug_backtrace()
возвращает большой список, в котором содержится информация о «родительских» функциях и их аргументах. Результат работы листинга 2.4 говорит сам за себя.
Листинг2.4. Файл trace.php
function inner($a) {
// Внутренняя функция.
echo ""; print_r(debug_backtrace()); echo "";
}
function outer($x) {
// Родительская функция.
inner($x*$x);
}
// Главная программа.
outer(3);
?>
После запуска этого скрипта будет напечатан примерно следующий результат (его чуть сжали):
Array (
[0] => Array (
[file] => z:\home\book\original\src\interdivter\trace.php
[line] => 6
[function] => inner
[args] => Array ([0] => 9)
)
[1] => Array (
[file] => z:\home\book\original\src\interdivter\trace.php
[line] => 8
[function] => outer
[args] => Array ([0] => 3)
)
)
Как видите, в массиве оказалась все информация о промежуточных вызовах функций.
Функцию удобно применять, например, в пользовательском обработчике ошибок. Тогда можно сразу же определить, в каком месте было сгенерировано сообщение и какие вызовы к этому привели, В крупных программах уровень вложенности функций может достигать нескольких десятков, поэтому, наверное, вместо print_r() стоит написать свой собственный код для вывода дерева вызовов в более компактной форме.
2.6 ПРИНУДИТЕЛЬНОЕ ЗАВЕРШЕНИЕ ПРОГРАММЫ Функция
продолжение
--PAGE_BREAK--void exit ()
немедленно завершает работу сценария. Из нее никогда не происходит возврата. Перед окончанием программы вызываются функции-финализаторы.
void die(string $message)
Функция делает почти то же самое, что и exit (), только перед завершением работы выводит строку, заданную в параметре $message). Чаще всего ее применяют, если нужно напечатать сообщение об ошибке и аварийно завершить программу.
Полезным примером использования die () может служить такой код:
$filename = '/path/to/data-file';
$file = @fopen($filename, 'r')
or die(«не могу открыть файл $ filename!»);
Здесь мы ориентируемся на специфику оператора or — «выполнять» второй операнд только тогда, когда первый «ложен». Заметьте, что оператор || здесь применять нельзя — он имеет более высокий приоритет, чем =.
С использованием || последний пример нужно было бы переписать следующим образом:
$filename = '/path/to/data-file';
($file = fopen($filename, 'r'))
|| die(«не могу открыть файл $filename!»);
Согласитесь, громоздкость последнего примера практически полностью исключает возможность применения || в подобных конструкциях.
2.7 ФИНАЛИЗАТОРЫ Разработчики РНР предусмотрели возможность указать в программе функцию-финализатор, которая будет автоматически вызвана, как только работа сценария завершится — неважно, из-за ошибки или легально. В такой функции мы можем, например, записать информацию в кэш или обновить какой-нибудь файл журнала работы программы. Что же нужно для этого сделать?
Во-первых, написать саму функцию и дать ей любое имя. Желательно также, чтобы она была небольшой и в ней не было ошибок, потому что сама функция, вполне возможно, будет вызываться перед завершением сценария из-за ошибки.
Во-вторых, зарегистрировать ее как финализатор, передав ее имя стандартной функции 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
echo «Начало программы.»;
try {
// Код, в котором перехватываются исключения.
echo «Все, что имеет начало...»;
// Генерируем («выбрасываем») исключение.
throw new Exception(«Hello!»);
echo "… имеет и конец.";
} catch (Exception $e) {
// Код обработчика.
echo " Исключение: {$e->getMessage()}";
}
echo «Конец программы.»;
?>
В листинге 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
echo «Начало программы.»;
try {
echo «Начало try-блока.»;
outer();
echo «Конец try-блока.»;
} catch (Exception $e) {
echo " Исключение: {$e->getMessage()}";
}
echo «Конец программы.»;
function outer() {
echo «Вошли в функцию ».__METHOD__."";
inner();
echo «Вышли из функции ».__METHOD__."";
}
function inner() {
echo «Вошли в функцию ».__METHOD__."";
throw new Exception(«Hello!»);
echo «Вышли из функции ».__METHOD__."";
}
?>
Результат работы данного кода выглядит так:
Начало программы.
Начало try-блока.
Вошли в функцию outer
Вошли в функцию inner
Исключение: Hello!
Конец программы.
Мы убеждаемся, что ни один из операторов echo, вызываемых после инструкции throw, не «сработал». По сути, программа даже не дошла до них: управление было мгновенно передано в catch-блок, а после этого — в следующую за try...catch строку программы.
Данное поведение инструкции throw называют раскруткой стека вызовов функций, потому что объект-исключение последовательно передается из одной функции в другую, каждый раз приводя к ее завершению — как бы «отматывает» стек.
Можно заметить, что инструкция throw очень похожа на команду return, однако она вызывает «вылет» потока исполнения не только из текущей функции, но также и из тех, которые ее вызвали (до ближайшего соответствующего catch-блока).
3.4 ИСКЛЮЧЕНИЯ И ДЕСТРУКТОРЫ Деструктор любого объекта вызывается всякий раз, когда последняя ссылка на этот объект оказывается потерянной, например, программа выходит за границу области видимости переменной. Применительно к механизму обработки исключений это дает мощный инструмент — корректное уничтожение всех объектов, созданных до вызова throw. Листинг 3.3 иллюстрирует ситуацию.
Листинг 3.3. Файл destr.php
// Класс, комментирующий операции со своим объектом.
class Orator {
private $name;
function __construct($name) {
$this->name = $name;
echo «Создан объект {$this->name}.»;
}
function __destruct() {
echo «Уничтожен объект {$this->name}.»;
}
}
function outer() {
$obj = new Orator(__METHOD__);
inner();
}
function inner() {
$obj = new Orator(__METHOD__);
echo «Внимание, вбрасывание!»;
throw new Exception(«Hello!»);
}
// Основная программа.
echo «Начало программы.»;
try {
echo «Начало try-блока.»;
outer();
echo «Конец try-блока.»;
} catch (Exception $e) {
echo " Исключение: {$e->getMessage()}";
}
echo «Конец программы.»;
?>
Создан специальный класс, который выводит на экран диагностические сообщения в своем конструкторе и деструкторе. Объекты этого класса создаются в первой строке каждой функции.
Результат работы программы выглядит так:
Начало программы.
Начало 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
echo «Начало программы.»;
set_error_handler(«handler»);
{
// Код, в котором перехватываются исключения.
echo «Все, что имеет начало...»;
// Генерируем («выбрасываем») исключение.
trigger_error(«Hello!»);
echo "… имеет и конец.";
}
echo «Конец программы.»;
// Функция-обработчик.
function handler($num, $str) {
// Код обработчика.
echo «Ошибка: $str»;
// exit();
}
?>
Первое, что бросается в глаза, — это излишняя многословность кода. Но давайте пойдем дальше и посмотрим, какой результат выдает данная программа:
Начало программы.
Все, что имеет начало…
Ошибка: Hello!
За счет использования exit () в функции handler()новая программа не только подвергает сомнению известный тезис (см. операторы echo), но также и утверждает, что любая, даже малейшая, ошибка является фатальной.
Что ж, раз проблема в команде exit(), попробуем ее убрать из скрипта и увидим следующий результат:
Начало программы.
Все, что имеет начало…
Ошибка: Hello!
… имеет и конец.
Конец программы.
И снова мы получили не то, что нужно: ошибка теперь уже не является «чересчур фатальной», как раньше, у нее противоположная проблема: она, наоборот, недостаточно фатальна.
Мы-то хотели разрушать идиому о конечности всего, что имеет начало, а получили — просто робкое замечание, произнесенное шепотом из-за кулис.
3.6 КЛАССИФИКАЦИЯ И НАСЛЕДОВАНИЕ Обычно все серьезные ошибки в программе (и внутренние, и пользовательские) поддаются некоторой классификации. Механизм обработки исключений, помимо основного своего достоинства — возможности отделения кода обработки ошибки от кода ее генерации — имеет и еще один плюс. Он заключается в возможности перехвата исключений по их видовой принадлежности на основе иерархии классов. При этом каждое исключение может принадлежать одновременно нескольким видам, и перехватываться с учетом совпадения своего (или родительского) вида.
Листинг 3.5 иллюстрирует тот факт, что при перехвате исключений используется информация о наследовании классов-исключений.
Листинг 3.5. Файл inherit.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()}'.»;
} catch (Exception $e) {
// Ловим все остальные исключения, которые еще не поймали.
echo «Другое исключение: {$e->getDirName()}.»;
}
?>
В программе мы генерируем ошибку типа FileNotFoundException, однако, ниже перехватываем исключение не прямо этого класса, а его «родителя» — FilesystemException. Так как любой объект типа FileNotFoundException является также и объектом класса FilesystemException, блок catch «срабатывает» для него. Кроме того, на всякий случай мы используем блок «поимки» объектов класса Exception — «родоначальника» всех исключений. Если вдруг в программе произойдет исключение другого типа (обязательно производного от Exception), оно также будет обработано.
К сожалению, в современной версии РНР реализация исключениями интерфейсов (а следовательно, и множественная классификация) не поддерживается. Точнее, можно создать класс-исключение, наследующий некоторый интерфейс, но попытка перехватить сгенерированное исключение по имени его интерфейса (а не по имени класса) не даст результата. Есть основания надеяться, что в будущих версиях РНР данное неудобство будет устранено.
продолжение
--PAGE_BREAK--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
function test($n) {
$e = new Exception(«bang-bang #$n!»);
echo "", $e, "";
}
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
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
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
require_once «exceptions.php»;
try {
printDocument();
} catch (IFileException $e) {
// Перехватываем только файловые исключения.
echo «Файловая ошибка: {$e->getMessage()}.»;
} catch (Exception $e) {
// Перехват всех остальных исключений.
echo «Неизвестное исключение: », $e, "";
}
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 «Начало программы.»;
try {
eatThis ();
}
catch (Exception $e)
{
echo «Неперехваченное исключение: », $e;
}
echo «Конец программы.»;
Таким образом, если в функции eatThis() возникнет любая исключительная ситуация, и объект-исключение «выйдет» за ее пределы (т. е. не будет перехвачен внутри самой процедуры), сработает наш универсальный код восстановления (оператор echo).
Перехват всех исключений при помощи конструкции catch (Exception ...) позволяет нам обезопаситься от неожиданного завершения работы функции (или блока) и гарантировать выполнение некоторого кода в случае возникновения исключения. В этом отношении конструкция очень похожа на инструкцию finally, которой в РНР на данный момент нет.
К сожалению, неожиданные вызовы return в функции при этом не обрабатываются, и отследить их пока нельзя.
Рассмотрим пример функции, которую мы пытались написать выше с использованием try...finally. Фактически, листинг 3.10 иллюстрирует, как можно проэмулировать finally в программе на РНР.
Листинг 3.10. Файл catchall.php
// Пользовательское исключение.
class HeadshotException extends Exception {}
// Функция, генерирующая исключение.
function eatThis() { throw new HeadshotException(«bang-bang!»); }
// Функция с кодом-финализатором.
function action() {
echo «Все, что имеет начало, »;
try {
// Внимание, опасный момент!
eatThis();
} catch (Exception $e) {
// Ловим ЛЮБОЕ исключение, выводим текст…
echo «имеет и конец.»;
//… а потом передаем это исключение дальше.
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.
продолжение
--PAGE_BREAK--