Отличие исключения от ошибки

Исключение != ошибка

Многие программисты почему-то считают, что исключения и ошибки — это одно и то же. Кто-то постоянно кидает exception, кто-то через errorHandler превращает ошибки в исключения. Некоторые пытаются увеличить производительность, используя исключения. Но, на самом деле, exception и ошибки — это совершенно разные механизмы. Не надо одним механизмом заменять другой. Они созданы для разных целей.

Когда появился php5 с исключениями, а затем ZendFramework, который всегда кидает исключения — я не мог понять: чем же exception лучше моего любимого trigger_error()? Долго думал, обсуждал с коллегами и разобрался в этом вопросе. Теперь я чётко знаю, где использовать trigger_error(), а где throw new Exception().

В чём же принципиальная разница между ними?

Ошибки

Ошибки — это то, что нельзя исправить, об этом можно только сообщить: записать в лог, отправить email разработчику и извинится перед пользователем. Например, если мой движок не может подключиться к БД, то это ошибка. Всё. Точка. Без БД сайт не работает, и я не могу с этим ничего сделать. Поэтому я вызываю ales_kaput() и trigger_error(), а мой errorHandler отправит мне email и покажет посетителю сообщение «Извините, сайт не работает».

Exception

Исключения — это не ошибки, это всего лишь особые ситуации, которые нужно как-то обработать. Например, если в калькуляторе вы попробуете разделить на ноль, то калькулятор не зависнет, не будет отсылать сообщения разработчику и извинятся перед вами. Такие ситуации можно обрабатывать обычным if-ом. Строго говоря, исключения — это конструкция языка позволяющая управлять потоком выполнения. Это конструкция, стоящая в одном ряду с if, for и return. И всё. Этот механизм ничем более не является. Только управление потоком.

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

<?php
a();
function a()
{
	b();
}


function b()
{
	c(99);
}

function c($x)
{
	if ($x === 0) {
		// Некоторая особенная ситуация,
		// которая должна остановить выполнение функций c() и b(),
		// а функция a() должна узнать об этом
	}
	return 100 / $x;
}

Эту задачу можно было бы решить без механизма exception. Например, можно заставить все функции возвращать специальный тип (если ты матёрый пэхапэшник, то должен вспомнить PEAR_Error). Для простоты я обойдусь null-ом:

<?php
a();
function a()
{
	echo 'a-begin';

	$result = b();
	if ($result === null) {
		echo 'Делить на ноль нехорошо';
		return;
	}

	echo 'a-stop';
}

function b()
{
	echo 'b-begin';

	$result = c(0);
	if ($result === null) {
		return null;
	}

	echo 'b-stop';
	return true;
}

function c($x)
{
	echo 'c-begin';

	if ($x === 0) {
		return null;
	}

	echo 'c-stop';
	return 100 / $x;
}

Результат работы:

a-begin
b-begin
c-begin
Делить на ноль нехорошо

Задача выполнена, но, обратите внимание, мне пришлось модифицировать промежуточную функцию b(), чтобы она пробрасывала результат работы нижестоящей функции выше по каскаду. А если у меня каскад из 5 или 10 функций? То мне пришлось бы модифицировать ВСЕ промежуточные функции. А если исключительная ситуация в конструкторе? То мне пришлось бы подставлять костыли.

А теперь решение с использованием Exception:

a();
function a()
{
	echo 'a-begin';

	try {
		b();
		echo 'a-stop';
	} catch (Exception $e) {
		echo $e->getMessage();
	}
}


function b()
{
	echo 'b-begin';
	c(0);
	echo 'b-stop';
}

function c($x)
{
	echo 'c-begin';

	if ($x === 0) {
		throw new Exception('Делить на ноль нехорошо');
	}

	echo 'c-stop';
	return 100 / $x;

}

Результат выполнения будет идентичен. Функция b() осталась в первоначальном виде, не тронутая. Это особенно актуально, если у вас длинные каскады. И ещё объект $e может содержать дополнительную информацию о произошедшей ситуации.

Таким образом, получается, что ошибки и исключения — это совершенно разные инструменты для решения совершенно разных задач:
ошибка — не поправимая ситуация;
исключение – позволяет прервать выполнение каскада функций и пробросить некоторую информацию. Что-то вроде глобального оператора return. Если у Вас нет каскада, то вам достаточно использовать if или return.

Ошибки не всегда являются ошибками

Некоторые могут мне возразить: «Посмотри в Zend Framework — там всегда кидают исключения. Это best practics, и надо делать также. Даже если не удалось подключиться к БД, надо кидать исключение».

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

Например, в вашем проекте может быть несколько MySQL серверов и вы можете переключаться между ними при падении одного из них. По этому, Zend_Db, как универсальная библиотека, кидает исключение, а что с ним делать — решайте сами. Exception это гибко — вы сами решаете на каком уровне и какой тип ситуаций ловить. Вы можете вывести сообщение об ошибке или попытаться исправить возникшую ситуацию, если знаете как. При написании универсальных библиотек необходимо всегда кидать исключения. Это делает библиотеку более гибкой.

В итоге, могу сказать, что у обоих механизмов есть свои особенности и, самое главное, что у них есть своё предназначение и эти предназначения нисколько не пересекаются.

Ошибки != исключения

. Не надо использовать исключения для улучшения быстродействия или сообщения об ошибках. Не надо в классе My_Custom_Exception реализовывать какую-либо логику исправления ситуации. Этот класс должен быть пустым, он создаётся только что бы определить тип ситуации и поймать только то, что надо. Название класса ‘My_Custom_Exception’ это такой древовидный аналог линейному списку констант E_*** (E_NOTICE, E_WARNING, …).

В php давно был разработан механизм обработки ошибок, и он отлично работает. Я им отлично пользуюсь там, где это надо.

Исключения и ошибки являются подклассами Throwable. Однако это не одно и то же.

У них очень разные причины и следствия. Люди могут часто путать эти два термина и использовать их взаимозаменяемо.

Однако с точки зрения компьютера они обозначают разные ситуации. Кроме того, они требуют разного обращения.

В результате необходимо признать и осознать точки различия между ними.

Основные выводы

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

Ошибка против исключения

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

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

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

Ошибка — это сигнал, который отображается пользователю.

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

Слово «исключение» является сокращением от «чрезвычайный инцидент». Хотя есть и другие, ошибка является формой непроверенное исключение.

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

Непроверенные исключения — это незапланированные события. Компьютер не оценивает эти незапланированные события во время компиляции.

Сравнительная таблица

Параметры сравнения	Ошибка	Исключение
Тип	Это классифицированное исключение. Но он относится к категории непроверенных.	Он подразделяется на проверенные и непроверенные типы.
Упаковка	Java.lang.error — это пакет, содержащий класс ошибок.	Java.lang.exception — это пакет, содержащий класс исключений.
Восстановление	Это не может быть восстановлено, так что это необратимо. Это является причиной возникновения ошибок.	Его можно восстановить и обработать. Следовательно, он подлежит восстановлению. Таким образом, эти ситуации могут быть исправлены.
Вхождение	Это не может произойти во время компиляции, в отличие от исключения.	Это происходит как во время выполнения, так и во время компиляции, в отличие от ошибок.
Примеры	Некоторые примеры этого: OutOfMemoryError, IOError.	Некоторые примеры этого — NullPointerException, SqlException.

Что такое ошибка?

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

Каждая из этих ошибок имеет сотни вариаций.

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

Например, имя документа, тип проблемы и адрес памяти могут быть указаны в сообщении об ошибке на синем экране в Windows. Эти данные вводятся в поисковую систему для поиска решения проблемы. Если вы не видите сообщения об ошибке, найдите свой симптом. Если ваш компьютер внезапно выключается без предупреждения, скорее всего, это аппаратная проблема, а не программная.

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

Он в первую очередь классифицируется как непроверенное исключение. Java.lang.error — это пакет, содержащий класс ошибок. Его нельзя восстановить. Так что это необратимо. Эта причина является причиной возникновения ошибок.

Что такое Исключение?

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

Исключения составляют класс на Java называется java.lang.

Два основных подкласса Exception — это IOException и RuntimeException. Когда компьютер компилирует программу, возникают проверенные исключения; по большей части программа должна быть способна от них отыгрываться.

К ним относятся такие исключения, как FileNotFoundException и InvalidInputException. Чтобы решить эту проблему, можно создать код обработки исключений, позволяющий продолжить работу программы.

Непроверенные исключения — это незапланированные события, которые компьютер не оценивает во время компиляции; они возникают во время выполнения программы. Обычно они не обработаны.

A терминал исключение — это непроверенное исключение, которое не может быть разрешено приложением и требует, чтобы операционная система закрыла программу и, возможно, выключила всю систему.

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

Нельзя исправить ошибку. Следовательно, это необратимо.

Эта причина является причиной возникновения ошибок. Таким образом, эти ситуации можно исправить.

Это происходит как во время выполнения, так и во время компиляции, в отличие от ошибок. Некоторыми примерами этого являются NullPointerException и SqlException.

Основные различия между ошибкой и исключением

1. Ошибка классифицируется как непроверенное исключение, в то время как исключение классифицируется как проверенное, так и непроверенное.
2. Java.lang.error — это пакет, содержащий класс ошибки, тогда как java.lang. Исключением является пакет, содержащий класс исключения.
3. Ошибку нельзя исправить, поэтому она неисправима. Это является причиной возникновения ошибок. С другой стороны, исключения можно восстановить и обработать. Следовательно, он подлежит восстановлению. Таким образом, эти ситуации могут быть исправлены.
4. Ошибка не может возникнуть во время компиляции, в отличие от исключения, которое возникает как во время выполнения, так и во время компиляции.
5. Некоторыми экземплярами ошибок являются OutOfMemoryError и IOError. Некоторыми экземплярами исключений являются NullPointerException и SqlException.

Рекомендации

1. https://academic.oup.com/cercor/article-abstract/22/2/260/333894
2. https://ieeexplore.ieee.org/abstract/document/6009257/

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

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

Механизм обработки исключений существует в большинстве языков программирования. Он может быть реализован немного по-разному, но общая суть схожа: это всегда какие-то особые случаи, которые надо обработать отдельно. Мы при описании будем отталкиваться от особенностей исключений в Java, но встретить их можно и в других языках: JavaScript, PHP, Python, C++ и так далее.

Зачем нужны исключения

Механизм обработки исключений может понадобиться любому разработчику. Если не отслеживать исключительные ситуации, может возникнуть незаметная ошибка, которая нарушит работу всего кода, или программа может «зависнуть» либо «упасть» — потому что сложный момент не был обработан как надо.

Исключения нужны, чтобы программа продолжала относительно корректно работать, даже если что-то пошло не так.

Какими бывают исключения

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

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

Как происходит работа с исключениями

• Разработчик пишет код и понимает, что в какой-то момент в том или ином месте может возникнуть нештатная ситуация. Бывает, что исключения добавляют в уже написанный код — например, нештатную ситуацию обнаружили при тестировании.
• В этом месте пишется особый блок кода — обработчик. Он говорит программе: здесь может возникнуть особая ситуация, если она случится, выполни вот это.
• Внутри обработчика — функция, которая выполнится, если программа столкнется с описанной ситуацией. Она или исправит ситуацию, или скорректирует дальнейшее выполнение программы.

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

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

Существуют разные виды обработки: структурная и неструктурная, с возвратом и без возврата. Они различаются механизмом действия, но общая суть одна: это функция, которая запускается, если в коде случилась та или иная исключительная ситуация. Тут можно использовать условный оператор if или специальные синтаксические конструкции.

В примере с делением на ноль обработчик может отменить попытку деления и сказать пользователю, что на ноль делить нельзя, — но это самый простой пример. В реальности все сложнее.

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

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

Обработка без возврата — вид обработки, когда проблема не ликвидируется, а участок кода, который не получается выполнить, пропускается. В примере со скриптами обработка «переключила» бы выполнение кода на момент, где уже не понадобится незаработавший скрипт.

Структурная и неструктурная обработка. Это два способа подключить обработчики. В первом случае они встраиваются в код, а когда генерируется исключение, для него выбирается тот или иной обработчик в зависимости от ситуации. Во втором случае обработчики существуют отдельно и «подключаются» к конкретным видам исключений с помощью специальных команд. Способ выбирается в зависимости от вида исключения, особенностей кода и языка.

Обычно асинхронные исключения обрабатывают неструктурно, а синхронные — структурно.

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

Исключения и ошибки: разница

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

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

Это действительно похожие понятия. В Java, например, сущности исключений и ошибок наследуются от общего предка — интерфейса Throwable. Но ошибка — это явление, когда что-то сделать принципиально не получается. А исключение — ситуация, когда программа просто не знает, что делать, если не указать на это дополнительно.

Можно провести аналогию. Мама послала дочь в магазин за покупками и сказала ей купить батон хлеба. Если хлеба в магазине не оказалось, девочка не сможет его купить. Это ошибка. А если в магазине есть три вида батонов, или все батоны вчерашние, а девочка не знает, нужен ли маме только свежий хлеб, или батон есть, но только из ржаной муки, — это исключения.

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

Когда пользоваться исключениями, а когда — ошибками

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

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

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

Как начать пользоваться исключениями

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

I intend to give you a most unusual discussion of error control.

I built a very good error handler into a language years ago, and though some of the names have changed, the principles of error processing are the same today. I had a custom built multi-tasking OS and had to be able to recover from data errors at all levels with no memory leaks, stack growth or crashes. So what follows is my understanding of how errors and exceptions must operate and how they differ. I will just say I do not have an understanding of how the internals of try catch works, so am guessing to some measure.

The first thing that happens under the covers for error processing is jumping from one program state to another. How is that done? I’ll get to that.

Historically, errors are older and simpler, and exceptions are newer and a bit more complex and capable. Errors work fine until you need to bubble them up, which is the equivalent of handing a difficult problem to your supervisor.

Errors can be numbers, like error numbers, and sometimes with one or more associated strings. For example if a file-read error occurs you might be able to report what it is and possibly gracefully fail. (Hay, it’s a step up from just crashing like in the old days.)

What is not often said about exceptions is that exceptions are objects layered on a special exception stack. It’s like a return stack for program flow, but it holds a return state just for error trys and catches. (I used to call them ePush and ePop, and ?Abort was a conditional throw which would ePop and recover to that level, while Abort was a full die or exit.)

On the bottom of the stack is the information about the initial caller, the object that knows about the state when the outer try was started, which is often when your program was started. On top that, or the next layer on the stack, with up being the children, and down being the parents, is the exception object of the next inner try/catch block.

If you put a try inside a try you are stacking the inner try on top of the outer try. When an error occurs in the inner try and either the inner catch can’t handle it or the error is thrown to the outer try, then control is passed to the outer catch block (object) to see if it can handle the error, i.e. your supervisor.

So what this error stack really does is to be able to mark and restore program flow and system state, in other words, it allows a program to not crash the return stack and mess up things for others (data) when things go wrong. So it also saves the state of any other resources like memory allocation pools and so it can clean them up when catch is done. In general this can be a very complicated thing, and that is why exception handling is often slow. In general quite a bit of state needs to go into these exception blocks.

So a try/catch block sort of sets a state to be able to return to if all else gets messed up. It’s like a parent. When our lives get messed up we can fall back into our parent’s lap and they will make it all right again.

Hope I didn’t disappoint you.