Синтаксис обработки исключений - Exception handling syntax

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

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

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

Ада

Объявления исключений

Some_Error : исключение;

Вызов исключений

поднимать Some_Error;поднимать Some_Error с "Недостаточно памяти"; - специальное диагностическое сообщение

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

с Ada.Exceptions, Ада.Text_IO;процедура Фу является  Some_Error : исключение;начинать  Do_Something_Interesting;исключение - Запуск обработчиков исключений  когда Constraint_Error =>    ... - Обработка ошибки ограничения  когда Storage_Error =>    - Распространить Storage_Error как другое исключение с полезным сообщением    поднимать Some_Error с "Недостаточно памяти";  когда Ошибка : другие =>     - Справиться со всеми остальными    Ада.Text_IO.Положить("Исключение: ");    Ада.Text_IO.Put_Line(Ада.Исключения.Exception_Name(Ошибка));    Ада.Text_IO.Put_Line(Ада.Исключения.Exception_Message(Ошибка));конец Фу;

язык ассемблера

Большинство языков ассемблера будут иметь макрос-инструкцию или адрес прерывания, доступный для конкретной системы, чтобы перехватывать такие события, как недопустимые коды операций, проверка программы, ошибки данных, переполнение, деление на ноль и другие подобные. Мэйнфреймы IBM и Univac имели STXIT макрос. Корпорация цифрового оборудования RT11 системы имели векторы ловушек для программных ошибок, прерываний ввода-вывода и т. д. ДОС имеет определенные адреса прерывания. Майкрософт Виндоус имеет специальные вызовы модулей для перехвата программных ошибок.

Баш

#! / usr / bin / env bash#set -e предоставляет другой механизм ошибокprint_error(){	эхо "Там была ошибка"}ловушка print_error выход # список сигналов для перехватавременный файл=`mktemp`ловушка "пм $ tempfile" выход./other.sh || эхо предупреждение: другое не удалосьэхо ой)эхо никогда не печатал

Можно установить ловушку для нескольких ошибок, отвечая на любой сигнал синтаксисом типа:

ловушка 'ошибка эха в строке $ {LINENO}' ERR

БАЗОВЫЙ

An При ошибке goto / gosub структура используется в BASIC и сильно отличается от современной обработки исключений; в BASIC есть только один глобальный обработчик, тогда как в современной обработке исключений обработчики исключений складываются.

ПО ОШИБКЕИДТИ КобработчикОТКРЫТО"Somefile.txt"ЗАВХОДВ КАЧЕСТВЕ#1ЗАКРЫТЬ#1РАСПЕЧАТАТЬ"Файл успешно открыт"КОНЕЦобработчик:РАСПЕЧАТАТЬ"Файл не существует"КОНЕЦВместо этого можно использовать RESUME, который возвращает управление в исходное положение.

C

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

В любом случае возможный способ реализовать обработку исключений в стандарте C - использовать setjmp / longjmp функции:

#включают <setjmp.h>#включают <stdio.h>#включают <stdlib.h>перечислить { SOME_EXCEPTION = 1 } исключение;jmp_buf государственный;int главный(пустота){  если (!setjmp(государственный))                      // пытаться  {    если (/* что-то случилось */)    {      исключение = SOME_EXCEPTION;      longjmp(государственный, 0);                  // выбросить SOME_EXCEPTION    }  }   еще выключатель(исключение)  {                 дело SOME_EXCEPTION:                  // поймать SOME_EXCEPTION      ставит("SOME_EXCEPTION поймано");      перемена;    дефолт:                              // ловить ...      ставит(«Какое-то странное исключение»);  }  возвращаться EXIT_SUCCESS;}

Для Microsoft

Существуют два типа:

Структурированная обработка исключений (SEH)
Векторная обработка исключений (VEH, представленная в Windows XP )

Пример SEH на языке программирования C:

int filterExpression (EXCEPTION_POINTERS* ep) {   ep->ContextRecord->Eip += 8; // инструкция деления может быть закодирована от 2 до 8 байтов   возвращаться EXCEPTION_CONTINUE_EXECUTION;}int главный(пустота) {   статический int нуль;   __пытаться {       нуль = 1/нуль;       __как м {         нет         нет         нет         нет         нет         нет         нет       }       printf ("Прошлое исключение.");   } __Кроме (filterExpression (GetExceptionInformation())) {       printf ("Хэндлер позвонил.");   }   возвращаться 0;}

C #

А пытаться блок должен иметь хотя бы один ловить или же наконец-то пункт и не более одного наконец-то пункт.

общественный статический пустота Главный(){    пытаться    {        // Код, который может вызвать исключение.    }    ловить (HttpException бывший)    {        // Обрабатывает исключение HttpException. Объект исключения хранится в ex.    }    ловить (Исключение)    {        // Обрабатывает любое исключение CLR, которое не является HttpException.        // Поскольку исключению не был присвоен идентификатор, на него нельзя ссылаться.    }    ловить    {        // Обрабатывает все, что может быть сгенерировано, включая исключения, не относящиеся к среде CLR.    }    наконец-то    {        // Всегда запускать при выходе из блока try (включая предложения catch), независимо от того, были ли выданы какие-либо исключения или они были обработаны.        // Часто используется для очистки и закрытия ресурсов, обрабатываемых таким файлом.        // Не может быть запущен при вызове Environment.FailFast () и в других общесистемных исключительных условиях (например, потеря мощности) или когда процесс завершается сбоем из-за исключения в другом потоке.    }}

C ++

#включают <exception>int главный() {   пытаться {       // что-то делаем (может вызвать исключение)   }   ловить (const стандартное::исключение& е) {        // обрабатываем исключение e   }   ловить (...) {        // перехватывает все исключения, еще не перехваченные блоком catch перед        // может использоваться для перехвата исключения неизвестного или нерелевантного типа   }}

В C ++ получение ресурсов - это инициализация Технику можно использовать для очистки ресурсов в исключительных ситуациях. C ++ намеренно не поддерживает наконец-то.^[1] Внешние скобки для метода не являются обязательными.

Язык разметки ColdFusion (CFML)

Синтаксис скрипта

<cfscript>пытаться {	// бросаем CF9 +	бросать(тип="TypeOfException", сообщение="Ой", деталь="xyz");	// альтернативный синтаксис броска:	бросать "Ой"; // это эквивалент значению "message" в приведенном выше примере} ловить (любой е) {	writeOutput("Ошибка: " & е.сообщение);	перебросить; // CF9 +} наконец-то { // CF9 +	writeOutput(«Бегу, даже если без ошибок»);}</ cfscript>

Документация Adobe ColdFusion^[2]

Синтаксис тега

<cftry>     код, который может вызвать исключение  ...>         <cftry>             Первый уровень кода обработки исключений  ...>                 Второй уровень кода обработки исключений </cfcatch>            <cffinally>                     окончательный код </cffinally>         </cftry>     </cfcatch> </cftry>

Документация Adobe ColdFusion^[3]

Специфический синтаксис Railo-Lucee

Добавленные к стандартному синтаксису выше, диалекты CFML Railo и Люси позволить повторить попытку утверждение.^[4]

Этот оператор возвращает обработку к началу предыдущего пытаться блокировать.

Пример CFScript:

пытаться {	// код, который может привести к исключению } ловить (любой е){	повторить попытку;}

Пример синтаксиса тега:

<cftry>	<!--- code which could result in an exception --->	<cfcatch>		<паршивость>	</cfcatch></cftry>

D

импорт стандартное.stdio; // для writefln ()int главный() {  пытаться {      // делаем что-то, что может вызвать исключение  }  ловить (FooException е) {       // обрабатываем исключения типа FooException  }  ловить (Объект о) {       // обрабатываем любые другие исключения       writefln("Необработанное исключение: ", о);       возвращаться 1;  }  возвращаться 0;}

В D a наконец-то пункт или получение ресурсов - это инициализация технику можно использовать для очистки ресурсов в исключительных ситуациях.

Delphi

Объявления исключений

тип ECustom = учебный класс(Исключение) // Исключения являются дочерними по отношению к классу Exception.  частный    FCustomData: SomeType;      // Исключения могут иметь собственные расширения.  общественный    конструктор CreateCustom(Данные: SomeType); // Требуется реализация    свойство CustomData: SomeType читать FCustomData;  конец;

Вызов исключений

поднимать Исключение.Создавать('Сообщение');поднимать Исключение.CreateFmt('Сообщение со значениями:% d,% d',[значение1, значение2]); // См. Параметры в SysUtils.Format (). поднимать ECustom.CreateCustom(Икс);

Обработка и распространение исключений^[5]

пытаться // Для finally.  пытаться // За исключением.    ... // Код, который может вызвать исключение.  Кроме    на C:ECustom делать      начинать        ... // Обрабатываем ECustom.        ... если Предикат(C.CustomData) тогда ...      конец;    на S:ESomeOtherException делать      начинать        // Распространение как другое исключение.        поднимать EYetAnotherException.Создавать(S.Сообщение);       конец;    на E:Исключение делать      начинать        ... // Обработка других исключений.        поднимать; // Распространение.      конец;  конец; наконец-то  // Код для выполнения независимо от того, возникло ли исключение (например, код очистки).конец;

Erlang

пытаться  % какой-то опасный кодловить  бросать:{someError, Икс} -> Ok;    % обрабатывает исключение  ошибка:Икс -> Ok;                 % обрабатывает другое исключение  _:_ -> Ok                      % обрабатывать все исключенияпосле  % очиститьконец

F #

В дополнение к основанному на OCaml попробуй ... с, F # также имеет отдельный попробуй ... наконец конструкция, которая имеет то же поведение, что и блок try с наконец-то предложение на других языках .NET.

Для сравнения это перевод пример C # выше.

пытаться    пытаться        () (* Код, который может вызвать исключение. *)    с    | :? Система.Сеть.WebException в качестве бывший -> () (* Обрабатывает WebException. Объект исключения хранится в "бывший". *)    | :? exn -> () (* Обрабатывает любое исключение CLR. Поскольку исключению не был присвоен идентификатор, на него нельзя ссылаться. *)    | _ -> () (* Обрабатывает все, что может быть сгенерировано, включая исключения, не относящиеся к среде CLR. *)наконец-то    ()     (*       Всегда запускать при выходе из блока try, независимо от того, были ли выброшены исключения или обработаны ли они.       Часто используется для очистки и закрытия ресурсов, с которыми работает такой файл.       Не может быть запущен при вызове Environment.FailFast () и в других общесистемных исключительных условиях (например, при потере питания) или при сбое процесса из-за исключения в другом потоке.    *)

Для сравнения это перевод пример OCaml ниже.

исключение MyException из нить * int (* исключения могут иметь значение *)позволять _ =  пытаться    поднимать (MyException ("недостаточно еды", 2));    printfn "Не достигнуто"  с  | MyException (s, я) ->       printf "MyException:% s,% d" s я  | е ->  (* поймать все исключения *)     eprintf «Неожиданное исключение:% O» е;     eprintf "% O" е.Трассировки стека

Haskell

В Haskell нет специального синтаксиса для исключений. Вместо этого пытаться/ловить/наконец-то/так далее. Интерфейс предоставляется функциями.

импорт Прелюдия прячется(ловить)импорт Control.Exceptionпример Исключение Intпример Исключение Двойнойглавный = делать  ловить    (ловить      (бросать (42::Int))      (е-> Распечатать (0,е::Двойной)))    (е-> Распечатать (1,е::Int))

отпечатки

(1,42)

по аналогии с этим C ++

#включают <iostream>с помощью пространство имен стандартное;int главный(){  пытаться    {бросать (int)42;}  ловить(двойной е)    {cout << "(0," << е << ")" << конец;}  ловить(int е)    {cout << "(1," << е << ")" << конец;}}

Другой пример

делать {  - Заявления, в которых могут быть выданы ошибки} `ловить` бывший -> делать {  - Операторы, которые выполняются в случае исключения, с привязкой ex к исключению}

В чисто функциональном коде, если существует только одно условие ошибки, Может быть type может быть достаточным и является экземпляром Haskell's Монада учебный класс по умолчанию. Более сложное распространение ошибок может быть достигнуто с помощью Ошибка или же ОшибкаT монады, для которых аналогичная функциональность (с использованием `ловить`) поддерживается.

Ява

А пытаться блок должен иметь хотя бы один ловить или же наконец-то пункт и не более одного наконец-то пункт.

пытаться {    // Обычный путь выполнения.    бросать новый EmptyStackException();} ловить (ExampleException ее) {    // Обработка исключения ExampleException.} наконец-то {    // Всегда запускать при выходе из блока try (включая предложения finally), независимо от того, были ли выданы какие-либо исключения или они были обработаны.    // Часто используется для очистки и закрытия ресурсов, обрабатываемых таким файлом.    // Не может быть запущен при вызове System.exit () и в других общесистемных исключительных условиях (например, при потере питания).}

JavaScript

Дизайн JavaScript очень редко допускает громкие / серьезные ошибки. Мягкие / тихие ошибки гораздо более распространены. Серьезные ошибки распространяются до ближайшего пытаться заявление, за которым должен следовать либо один ловить пункт, единый наконец-то пункт или и то, и другое.

пытаться {  // Заявления, в которых могут быть выброшены исключения  бросать новый Ошибка("ошибка");} ловить(ошибка) {  // Операторы, которые выполняются в случае исключения} наконец-то {  // Операторы, которые выполняются позже в любом случае}

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

setInterval(функция() {  бросать новый Ошибка(«Пример ошибки с интервалом в 4 секунды».);}, 4000);

Еще одна интересная особенность - полиморфизм: JavaScript может выдавать примитивные значения как ошибки.

пытаться {  бросать 12345; // примитивное число} ловить(ошибка) {  консоль.бревно(ошибка); // выводит 12345 в консоль как примитивное число}

Обратите внимание, что ловить Предложение - это универсальный вариант, который позволяет отловить все типы ошибок. Нет синтаксической возможности назначать разные обработчики для разных типов ошибок, кроме экспериментальных и удаленных в настоящее время расширений Gecko много лет назад. Вместо этого можно либо распространить ошибку, используя бросать заявление внутри ловить выражение или используйте несколько условных случаев. Давайте сравним пример на Java и его приблизительные эквиваленты на JavaScript.

// Пример на Javaпытаться {  Целое число я = ноль;  я.intValue(); // выдает исключение NullPointerException} ловить(Исключение нулевого указателя ошибка) {  // Переменная может быть нулевой} ловить(ArithmeticException ошибка) {  // Решаем проблемы с числами}

// Приближение №1 в JavaScriptпытаться {  // Заявления, в которых могут быть выброшены исключения  вар пример = ноль;  пример.нанизывать();} ловить(ошибка) {  если (ошибка.тип === "TypeError") {    // Переменная может быть нулевой  } еще если (ошибка.тип === "RangeError") {    // Решаем проблемы с числами  }}

// Приближение №2 в JavaScriptпытаться {  пытаться {    // Заявления, в которых могут быть выброшены исключения    вар пример = ноль;    пример.нанизывать();  } ловить(ошибка) {    если (ошибка.тип !== "TypeError") бросать ошибка;    // Переменная может быть нулевой  }} ловить(ошибка) {  если (ошибка.тип !== "RangeError") бросать ошибка;  // Решаем проблемы с числами}

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

новый Обещать(функция() {	бросать новый Ошибка("Пример ошибки!");}).ловить(функция(ошибаться) {	консоль.бревно("Пойманный ", ошибаться);});

Также обратите внимание, как обработчики событий могут быть связаны с обещаниями.

addEventListener("необработанный отказ", функция(мероприятие) {  консоль.бревно(мероприятие.причина);  мероприятие.preventDefault(); // предотвращаем запись ошибки через console.error в консоль - поведение по умолчанию});новый Обещать(функция() {  бросать новый Ошибка("Пример ошибки!");});

Наконец, обратите внимание, что, поскольку JavaScript использует сборку мусора mark-and-sweep, никогда не происходит утечки памяти из-за операторов throw, поскольку браузер автоматически очищает мертвые объекты - даже с циклическими ссылками.

пытаться {  // Заявления, в которых могут быть выброшены исключения  const объект = {};  объект.selfPropExample = объект; // круговая ссылка  бросать объект;} ловить(ошибка) {  // Операторы, которые выполняются в случае исключения}

Лисп

Common Lisp

(игнорировать ошибки (/ 1 0))(чемоданчик    (прогноз      (Распечатать "введите выражение")      (оценка (читать)))  (ошибка (е) (Распечатать е)))(расслабиться-защитить    (прогноз       (Распечатать "введите выражение")       (оценка (читать)))  (Распечатать «Эта печать всегда будет выполняться, как и finally».))

Lua

Lua использует pcall и xpcall функции, с xpcall взять на себя функцию действовать как ловить блокировать.

Предопределенная функция

функция фу(Икс)  если Икс тогда     возвращаться Икс  еще    ошибка «Не истинное значение»  конецконецфункция пытаться(аргумент)  успех, ценить = pcall(фу, аргумент)  если нет успех тогда     Распечатать("Ошибка: " .. нанизывать(ценить))  еще    Распечатать("Возвращено:" .. нанизывать(ценить))  конецконецпытаться("Привет")  - Вернулся: приветпытаться(ноль)  - Ошибка: stdin: 5: неверное значениепытаться({})  - Возвращено: таблица: 00809308    если фу(42) тогда Распечатать "Успех" конец  -- Успех

Анонимная функция

если pcall(  функция()    - Сделайте что-нибудь, что может вызвать ошибку.  конец) тогда  Распечатать «Ошибок нет»  - Выполняется, если защищенный вызов был успешным.еще  Распечатать «Произошла ошибка»  - Выполняется, если защищенный вызов не удался.конецРаспечатать "Выполнено"  - Всегда будет выполняться

Оболочка нового поколения

Определение настраиваемого типа исключения

тип MyError(Ошибка)

Вызов исключений

бросать MyError("это произошло")

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

пытаться {  # что нибудь} ловить(е:MyError) {  сторожить е.вал = 7  # ...} ловить(е:MyError) {  # ...} ловить(е:Ошибка) {  # ...}

Игнорирование исключений - попробуйте без уловки

пытаться 1/0  # оценивается как null

Игнорирование исключений - оператор "tor"

"tor" - это оператор try-or. В случае какого-либо исключения при оценке аргумента слева оценивается аргумент справа.

1/0 тор 20  # оценивается как 20

"блок" - возможность использовать исключения для возврата значения

my_result = блокировать мой блок {  # "block" перехватывает исключение, генерируемое возвратом ниже  # сделать расчет  если расчет_финшен() {    мой блок.возвращаться(42)  # выдает исключение  }}

Цель-C

Объявления исключений

NSException *исключение = [NSException exceptionWithName:@ "myException"                           причина:@"что бы ни"  userInfo:ноль];

Вызов исключений

@бросать исключение;

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

@пытаться {    ...}@ловить (SomeException *se) {    // Обработка определенного типа исключения.    ...}@ловить (NSException *ne) {    // Обработка общих исключений.    ...    // Распространение исключения так, чтобы оно обрабатывалось на более высоком уровне.    @бросать;}@ловить (я бы уэ) {    // Ловить все брошенные предметы.    ...}@наконец-то {    // Выполняем очистку независимо от того, произошло исключение или нет.    ...}

OCaml

исключение MyException из нить * int (* исключения могут иметь значение *)позволять _ =  пытаться    поднимать (MyException ("недостаточно еды", 2));    print_endline "Не достигнуто"  с  | MyException (s, я) ->       Printf.printf "MyException:% s,% d" s я  | е ->  (* поймать все исключения *)     Printf.eprintf «Неожиданное исключение:% s» (Printexc.нанизывать е);     (* При использовании Ocaml> = 3.11 можно также распечатать обратную трассировку: *)     Printexc.print_backtrace stderr;       (* Необходимо заранее включить запись обратной трассировки с           Printexc.record_backtrace true         или установив переменную окружения OCAMLRUNPARAM = "b1" *)

Perl 5

В Perl механизм обработки исключений использует умереть генерировать исключение, когда оно заключено в оценка { ... }; блокировать. После оценка, специальная переменная $@ содержит значение, переданное из умереть. Однако проблемы с областью видимости могут сделать это правильно довольно некрасивым:

мой ($ ошибка, $ не удалось);{    местный $@;    $ не удалось = нет оценка {        # Код, который может вызвать исключение (с помощью 'die')        открыто(ФАЙЛ, $ файл) || умереть "Не удалось открыть файл: $!";        пока (<FILE>) {            process_line($_);        }        Закрыть(ФАЙЛ) || умереть "Не удалось закрыть $ file: $!";        возвращаться 1;    };    $ ошибка = $@;}если ($ не удалось) {    предупреждать "есть ошибка: $ error";}

Perl 5.005 добавил возможность бросать как объекты, так и строки. Это позволяет лучше анализировать и обрабатывать типы исключений.

оценка {    открыто(ФАЙЛ, $ файл) || умереть MyException :: Файл->новый($!);    пока (<FILE>) {        process_line($_);    }    Закрыть(ФАЙЛ) || умереть MyException :: Файл->новый($!);};если ($@) {    # Объект исключения находится в $ @    если ($@->это('MyException :: File')) {        # Обработка исключения файла    } еще {        # Общая обработка исключений        # или повторно бросить с помощью 'die $ @'    }}

В __УМЕРЕТЬ__ псевдосигнал может быть перехвачен для обработки вызовов умереть. Это не подходит для обработки исключений, поскольку является глобальным. Однако его можно использовать для преобразования исключений на основе строк из сторонних пакетов в объекты.

местный $ SIG{__УМЕРЕТЬ__} = суб {    мой $ err = сдвиг;    если ($ err->это('MyException')) {        умереть $ err; # перебросить    } еще {        # В противном случае создайте MyException с $ err в виде строки        умереть MyException :: По умолчанию->новый($ err);    }};

Формы, показанные выше, иногда могут не работать, если глобальная переменная $@ изменяется между возникновением исключения и его проверкой в если ($@) утверждение. Это может происходить в многопоточных средах или даже в однопоточных средах, когда другой код (обычно вызываемый при уничтожении какого-либо объекта) сбрасывает глобальную переменную перед кодом проверки. В следующем примере показан способ избежать этой проблемы (см. [1]^{[мертвая ссылка ]} или же [2]; ср. [3] ). Но ценой невозможности использовать возвращаемые значения:

оценка {    # Код, который может вызвать исключение (с использованием 'die'), но НЕ использует оператор return;    1;} или же делать {    # Здесь обрабатывается исключение. Строка исключения находится в $ @};

Несколько модулей в Комплексной сети архивов Perl (CPAN ) разверните основной механизм:

Ошибка предоставляет набор классов исключений и позволяет использовать синтаксис try / throw / catch / finally.
Попробуй поймать и Пытаться::Крошечный оба позволяют использовать синтаксис try / catch / finally вместо стандартного для правильной обработки исключений.
Исключение::Учебный класс является базовым классом и создателем классов для производных классов исключений. Он обеспечивает полностью структурированный трассировки стека в $@->след и $@->след->as_string.
Фатальный перегружает ранее определенные функции, которые возвращают истину / ложь, например, открыто, Закрыть, читать, записыватьи т. д. Это позволяет использовать встроенные функции и другие функции, как если бы они вызывали исключения.

PHP

// Обработка исключений доступна только в PHP версии 5 и выше.пытаться {    // Код, который может вызвать исключение    бросать новый Исключение('Неверный URL.');} ловить (FirstExceptionClass $ исключение) {    // Код, обрабатывающий это исключение} ловить (SecondExceptionClass $ исключение) {    // Код, обрабатывающий другое исключение} наконец-то {    // Выполняем очистку независимо от того, произошло исключение или нет.}

PowerBuilder

Обработка исключений доступна в PowerBuilder версии 8.0 и выше.

TRY // Нормальный путь выполнения CATCH (ExampleException ee) // Работа с ExampleException FINALLY // Эта необязательная секция выполняется после завершения любого из блоков try или catch вышеEND TRY

PowerShell

Версия 1.0

ловушка [Исключение]{    # Операторы, которые выполняются в случае исключения}# Заявления, в которых могут быть выброшены исключения

Версия 2.0

Пытаться {    Импорт-модуль ActiveDirectory    }Ловить [Exception1] {  # Операторы, которые выполняются в случае исключения, соответствующего исключению    }Ловить [Exception2], [Exception3etc] {  # Операторы, которые выполняются в случае исключения, совпадающего с любым из исключений    }Ловить {  # Операторы, которые выполняются в случае исключения, не обрабатываются более конкретно    }

Python

ж = Никтопытаться:    ж = открыто("aFileName", "ш")    ж.записывать(could_make_error())Кроме IOError:    Распечатать("Невозможно открыть файл")Кроме:  # поймать все исключения    Распечатать("Непредвиденная ошибка")еще:  # выполняется, если не возникают исключения    Распечатать(«Запись файла успешно завершена»)наконец-то:  # действия по очистке, всегда выполняемые    если ж:        ж.Закрыть()

р

попробуй поймать({   остановка(«Здесь сигнализируется ошибка»)   # S3-класс по умолчанию - simpleError подкласс ошибки   Кот(«Эта и следующие строки не выполняются, потому что ошибка перехвачена раньше»)   остановка( структура(simpleError("mySpecialError message"),учебный класс=c("specialError","ошибка","условие")) )},specialError=функция(е){    Кот("ловит ошибки класса specialError")},ошибка=функция(е){    Кот("ловит ошибку по умолчанию")},наконец-то={ Кот("сделать некоторую очистку (например, setwd)") })

Ребол

REBOL [    Заголовок: «Примеры обработки исключений и ошибок»]; ПОПРОБУЙТЕ блок; захват ошибки! и преобразование в объект!если ошибка? исключение: пытаться [1 / 0][зонд разоружить исключение]; ATTEMPT приводит к значению блока или к значению none при ошибкеРаспечатать пытаться [разделять 1 0]; Пользовательские исключения могут иметь любой тип данных!пример: func [«Функция, генерирующая исключение»][    бросать «Я струна! Исключение»]ловить [пример]; Пользовательские исключения также могут быть названы,; и функции могут включать дополнительные атрибуты времени выполнения сложный: func [«Функция для выдачи именованного исключения ошибки»    [ловить]][    бросать/имя делать ошибка! «Я ошибка! Исключение» прозвище]ловить/имя [сложный] прозвище

Rexx

сигналнаостановка;делатьа=1	 сказатьа	 делать100000/* задержка */	 конецконецостановка:сказать«Программа остановлена пользователем»выход

Рубин

начинать  # Сделай что-нибудь отличное  поднимать SomeError, "Это сообщение об ошибке!"  # Ой-ой!спасать SomeError  # Это выполняется, когда возникает исключение SomeError  # Поднялсяспасать AnotherError => ошибка  # Здесь ссылка на объект исключения из  # переменная `error 'спасать  # Это перехватывает все исключения, производные от StandardError  повторить попытку # Это снова выполняет начальную секциюеще  # Выполняется только в том случае, если не возникло никаких исключенийгарантировать  # Это всегда выполняется, исключение или нетконец

Сленг

 попробуйте {% код, который может вызвать исключение} catch SomeError: {% код, который обрабатывает это исключение} catch SomeOtherError: {% код, который обрабатывает это исключение} наконец% необязательный блок {% Этот код всегда будет выполняться}

Новые исключения могут быть созданы с помощью new_exception функция, например,

 new_exception («MyIOError», IOError, «Моя ошибка ввода-вывода»);

создаст исключение под названием MyIOError как подкласс IOError. Исключения могут быть созданы с помощью оператора throw, который может вызывать произвольные Сленг объекты.

Болтовня

  [ "код, который может вызвать исключение" ]     на: ExceptionClass      делать: [:бывший | "код, обрабатывающий исключение" ].

Общий механизм представлен сообщением на:делать:.^[6] Исключения - это обычные объекты, подклассы Ошибка, вы бросаете один, создавая экземпляр и отправляя ему #signal сообщение, например, MyException новый сигнал. Механизм обработки (#on: do:) снова является обычным сообщением, реализованным БлокЗакрытие. Выброшенное исключение передается в качестве параметра для закрытия блока обработки и может быть запрошено, а также может быть отправлено #продолжить к нему, чтобы продолжить выполнение потока.

Быстрый

Обработка исключений поддерживается начиная со Swift 2.

перечислить MyException : ErrorType {  дело Фу(Нить, Int)}func someFunc() бросает {  бросать MyException.Фу("недостаточно еды", 2)}делать {  пытаться someFunc()  Распечатать("Не достигнуто")} ловить MyException.Фу(позволять s, позволять я) {  Распечатать(«MyException: (s), (я)")} ловить {  Распечатать(«Неожиданное исключение: (ошибка)")}

Tcl

если { [ ловить {    фу} ошибаться ] } {    ставит "Ошибка: $ err"}

Начиная с Tcl 8.6, есть также команда try:

пытаться {    someCommandWithExceptions} в порядке {res выбрать} {    # обрабатывать нормальный регистр.} ловушка ListPattern1 {ошибаться выбрать} {    # обрабатывать исключения с кодом ошибки, совпадающим со ListPattern1} ловушка ListPattern2 {ошибаться выбрать} {    # ...} по ошибке {ошибаться выбрать} {    # обрабатывать все остальное.} наконец-то {    # запускаем все команды, которые должны выполняться после блока try.}

VBScript

С Новый Пытаться: На Ошибка Продолжить Следующий    'do Something (рекомендуется только одно утверждение).Ловить: На Ошибка Идти к 0: Выбирать Дело .Число    Дело 0 'эта строка требуется при использовании предложения' Case Else 'из-за отсутствия ключевого слова «Is» в операторе Case VBScript        'без исключения    Дело НОМЕР ОШИБКИ        'Обработка исключений    Дело Еще        'неизвестное исключениеКонец Выбирать: Конец С'*** Попробуйте класс ***Учебный класс Пытаться    Частный mstrDescription    Частный mlngHelpContext    Частный mstrHelpFile    Частный mlngNumber    Частный mstrSource    Общественные Sub Ловить()        mstrDescription = Err.Описание        mlngHelpContext = Err.HelpContext        mstrHelpFile = Err.HelpFile        mlngNumber = Err.Число        mstrSource = Err.Источник    Конец Sub    Общественные Свойство Получать Источник()        Источник = mstrSource    Конец Свойство        Общественные Свойство Получать Число()        Число = mlngNumber    Конец Свойство    Общественные Свойство Получать HelpFile()        HelpFile = mstrHelpFile    Конец Свойство        Общественные Свойство Получать HelpContext()        HelpContext = mlngHelpContext    Конец Свойство        Общественные Свойство Получать Описание()        Описание = mstrDescription    Конец СвойствоКонец Учебный класс

^[7]

Visual Basic 6

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

На Ошибка Идти к HandlerLabel 'При возникновении ошибки переходит к HandlerLabel, который определен в любом месте внутри Function или Sub'или жеНа Ошибка Идти к 0 'отключить обработку ошибок. Ошибка вызывает фатальную ошибку времени выполнения и останавливает приложение'или жеНа Ошибка Продолжить Следующий 'Ошибка объекта установлена, но выполнение продолжается по следующей команде. Вы все еще можете использовать объект Err для проверки состояния ошибки.'...Err.Поднимать 6   'Создать ошибку «Переполнение» с помощью встроенного объекта Err. Если обработчика ошибок нет, вызывающая процедура может перехватить исключение с тем же синтаксисом.'...LastLabel: 'просто общий ярлык внутри процедуры (неофициальная эмуляция раздела finally с других языков)    'код очистки, всегда выполняетсяВыход Sub 'выходы процедура'поскольку мы находимся после оператора Exit Sub, следующий код скрыт для выполнения без ошибокHandlerLabel: 'определяет общую метку, которая здесь используется для обработки исключений.Если Err.Число = 6 потом 'Оператор Select Case обычно является лучшим решением    Продолжить LastLabel 'Продолжить исполнение по определенной этикетке. Обычно что-то со значением "Наконец-то" на других языках    'или же    Продолжить Следующий 'продолжить выполнение оператора рядом с "Err.Raise 6"    'или же    Продолжить 'продолжить выполнение (повторения) оператора "Err.Raise 6"Конец ЕслиMsgBox Err.Число & " " & Err.Источник & " " & Эрл & " " & Err.Описание & " " & Err.LastDllError 'показать окно сообщения с важными свойствами ошибки    'Erl - это глобальная переменная номера строки встроенного VB6 (если используется). Обычно используется какая-то надстройка IDE, которая помечает каждую строку кода номером перед компиляцией.Продолжить LastLabel

Пример конкретной (неофициальной) реализации обработки исключений, использующей объект класса «Try».

С Новый Пытаться: На Ошибка Продолжить Следующий 'Создайте новый объект класса "Try" и используйте его. Затем установите этот объект по умолчанию. Может быть "Dim T As New Try": ... ... T.Catch    'do Something (рекомендуется только одно утверждение).Ловить: На Ошибка Идти к 0: Выбирать Дело .Число 'Вызвать процедуру Try.Catch (). Затем отключите обработку ошибок. Затем используйте «switch-like» оператор для результата свойства Try.Number (значение свойства Err.Number встроенного объекта Err)    Дело НОМЕР ОШИБКИ        'Обработка исключений    Дело Является <> 0 'Когда Err.Number равен нулю, ошибок не было        'неизвестное исключениеКонец Выбирать: Конец С'*** Попробуйте класс ***Частный mstrDescription  В качестве НитьЧастный mlngHelpContext  В качестве ДлинныйЧастный mstrHelpFile     В качестве НитьЧастный mlngLastDllError В качестве ДлинныйЧастный mlngNumber       В качестве ДлинныйЧастный mstrSource       В качестве НитьОбщественные Sub Ловить()    mstrDescription = Err.Описание    mlngHelpContext = Err.HelpContext    mstrHelpFile = Err.HelpFile    mlngLastDllError = Err.LastDllError    mlngNumber = Err.Число    mstrSource = Err.ИсточникКонец SubОбщественные Свойство Получать Источник() В качестве Нить    Источник = mstrSourceКонец СвойствоОбщественные Свойство Получать Число() В качестве Длинный    Число = mlngNumberКонец СвойствоОбщественные Свойство Получать LastDllError() В качестве Длинный    LastDllError = mlngLastDllErrorКонец СвойствоОбщественные Свойство Получать HelpFile() В качестве Нить    HelpFile = mstrHelpFileКонец СвойствоОбщественные Свойство Получать HelpContext() В качестве Длинный    HelpContext = mlngHelpContextКонец СвойствоОбщественные Свойство Получать Описание() В качестве Нить    Описание = mstrDescriptionКонец Свойство