La sintaxis de manejo de excepciones es el conjunto de palabras clave y / o estructuras proporcionadas por un lenguaje de programación de computadora para permitir el manejo de excepciones , que separa el manejo de errores que surgen durante la operación de un programa de sus procesos ordinarios. La sintaxis para el manejo de excepciones varía entre los lenguajes de programación , en parte para cubrir las diferencias semánticas, pero en gran parte para encajar en la estructura sintáctica general de cada lenguaje . Algunos lenguajes no llaman al concepto relevante " manejo de excepciones "; otros pueden no tener facilidades directas para ello, pero aun así pueden proporcionar los medios para implementarlo.
Más comúnmente, el manejo de errores usa un try...[catch...][finally...]
bloque y los errores se crean a través de una throw
declaración, pero existe una variación significativa en el nombre y la sintaxis.
Catálogo de sintaxis de manejo de excepciones
Ada
- Declaraciones de excepciones
Some_Error : excepción ;
- Generando excepciones
plantear Some_Error ;generar Some_Error con "Sin memoria" ; - mensaje de diagnóstico específico
- Manejo y propagación de excepciones
con Ada.Exceptions , Ada . Text_IO ;procedimiento Foo es Some_Error : excepción ; comenzar Do_Something_Interesting ; excepción - Inicio de controladores de excepciones cuando Constraint_Error => ... - error de identificador restricción cuando Storage_Error => - Propagar Storage_Error como una excepción diferente con un mensaje útil aumento Some_Error con "Fuera de la memoria" ; cuando Error : otros => - Manejar todos los demás Ada . Text_IO . Put ( "Excepción:" ); Ada . Text_IO . Put_Line ( Ada . Excepciones . Exception_Name ( Error )); Ada . Text_IO . Put_Line ( Ada . Excepciones . Exception_Message ( Error )); end Foo ;
Lenguaje ensamblador
La mayoría de los lenguajes ensambladores tendrán una macroinstrucción o una dirección de interrupción disponible para que el sistema en particular intercepte eventos como códigos de operación ilegales, verificación de programa, errores de datos, desbordamiento, división por cero y otros. Los mainframes IBM y Univac tenían la macro STXIT . Los sistemas RT11 de Digital Equipment Corporation tenían vectores de trampa para errores de programa, interrupciones de E / S , etc. DOS tiene ciertas direcciones de interrupción. Microsoft Windows tiene llamadas de módulo específicas para atrapar errores de programa.
Intento
#! / usr / bin / env fiesta #set -e proporciona otro mecanismo de error
print_error () { echo "hubo un error" } trampa print_error salida de señales #list para atrapar tempfile = ` mktemp ` trampa "rm $ archivo temporal " de salida
. /other.sh || advertencia de eco : otro eco fallido oops ) eco nunca impreso
Se puede establecer una trampa para múltiples errores, respondiendo a cualquier señal con una sintaxis como:
trap 'echo Error at line ${LINENO}' ERR
BÁSICO
Una estructura On Error goto / gosub se usa en BASIC y es bastante diferente del manejo de excepciones moderno; en BASIC solo hay un manejador global mientras que en el manejo de excepciones moderno, los manejadores de excepciones están apilados.
ON ERROR GOTO manejador ABIERTO "Unarchivo.txt" DE ENTRADA COMO # 1 CLOSE # 1 IMPRIMIR "Archivo abierto con éxito" FIN handler: PRINT "El archivo no existe" END 'RESUME se puede usar en su lugar, lo que devuelve el control a la posición original.
C
C no proporciona soporte directo para el manejo de excepciones: es responsabilidad del programador evitar errores en primer lugar y probar los valores de retorno de las funciones.
En cualquier caso, una forma posible de implementar el manejo de excepciones en el estándar C es usar las funciones setjmp / longjmp :
#include #include #include enum { SOME_EXCEPTION = 1 } excepción ; estado jmp_buf ;int main ( void ) { if ( ! setjmp ( state )) // try { if ( / * algo sucedió * / ) { excepción = ALGUNA_EXCEPCIÓN ; longjmp ( estado , 0 ); // SOME_EXCEPTION tiro } } demás interruptor ( excepción ) { caso SOME_EXCEPTION : // captura SOME_EXCEPTION pone ( "SOME_EXCEPTION atrapado" ); romper ; predeterminado : // captura ... pone ( "Alguna extraña excepción" ); } return EXIT_SUCCESS ; }
Específico de Microsoft
Existen dos tipos:
- Manejo estructurado de excepciones (SEH)
- Manejo de excepciones vectoriales (VEH, introducido en Windows XP )
Ejemplo de SEH en lenguaje de programación C:
int filterExpression ( EXCEPTION_POINTERS * ep ) { ep -> ContextRecord -> Eip + = 8 ; // la instrucción de división se puede codificar de 2 a 8 bytes return EXCEPTION_CONTINUE_EXECUTION ; } int main ( void ) { static int zero ; __intentar { cero = 1 / cero ; __asm { nop nop nop nop nop nop nop } printf ( "Pasada la excepción. \ n " ); } __except ( filterExpression ( GetExceptionInformation ())) { printf ( "Handler llamado. \ n " ); } return 0 ; }
C#
Un try
bloque debe tener al menos una cláusula catch
o finally
y como máximo una finally
cláusula.
public static void Main () { try { // Código que podría generar una excepción. } catch ( HttpException ex ) { // Maneja una HttpException. El objeto de excepción se almacena en "ex". } catch ( Exception ) { // Maneja cualquier excepción CLR que no sea una HttpException. // Dado que a la excepción no se le ha asignado un identificador, no se puede hacer referencia a ella. } catch { // Maneja todo lo que pueda lanzarse, incluidas las excepciones que no son de CLR. } finalmente { // Ejecutar siempre al salir del bloque try (incluidas las cláusulas catch), independientemente de si se lanzaron excepciones o si se manejaron. // A menudo se usa para limpiar y cerrar recursos como los manejadores de archivos. // No se puede ejecutar cuando se llama a Environment.FailFast () y en otras condiciones excepcionales de todo el sistema (por ejemplo, pérdida de energía), o cuando el proceso falla debido a una excepción en otro hilo. } }
C ++
#include ón>int main () { try { // hacer algo (podría lanzar una excepción) } catch ( const std :: exception & e ) { // manejar la excepción e } catch (...) { // captura todas las excepciones, no ya capturado por un bloque de captura antes de que // pueda usarse para detectar una excepción de tipo desconocido o irrelevante } }
En C ++, una técnica de inicialización de adquisición de recursos se puede utilizar para limpiar recursos en situaciones excepcionales. C ++ intencionalmente no admite finally
. [1] Los tirantes exteriores del método son opcionales.
Lenguaje de marcado ColdFusion (CFML)
Sintaxis de la secuencia de comandos
< cfscript > try { // throw CF9 + throw ( type = "TypeOfException" , message = "Oops" , detail = "xyz" ); // sintaxis de lanzamiento alternativa: throw "Oops" ; // este equivalente al valor "mensaje" en el ejemplo anterior } catch ( any e ) { writeOutput ( "Error:" & e . mensaje ); volver a lanzar ; // CF9 + } finalmente { // CF9 + writeOutput ( " Ejecuto incluso si no hay error" ); } < / cfscript>
Documentación de Adobe ColdFusion [2]
Sintaxis de la etiqueta
código que puede causar una excepción ... > Primer nivel de código de manejo de excepciones ... > Segundo nivel de código de manejo de excepciones < cffinally > código final cffinally >
Documentación de Adobe ColdFusion [3]
Sintaxis específica de Railo-Lucee
Añadido a la sintaxis estándar anterior, dialectos CFML de Railo y Lucee permiten un retry
comunicado. [4]
Esta declaración devuelve el procesamiento al inicio del try
bloque anterior .
Ejemplo de CFScript:
intente { // código que podría resultar en una excepción} atrapar ( cualquier e ) { reintentar ; }
Ejemplo de sintaxis de etiqueta:
< cfretry >
D
import std . stdio ; // para writefln () int main () { try { // hacer algo que pueda generar una excepción } catch ( FooException e ) { // manejar excepciones de tipo FooException } catch ( Object o ) { // manejar cualquier otra excepción writefln ( "Excepción no controlada:" , o ); return 1 ; } return 0 ; }
En D, se puede utilizar una finally
cláusula o la técnica de inicialización de adquisición de recursos para limpiar recursos en situaciones excepcionales.
Delphi
- Declaraciones de excepciones
type ECustom = class ( Exception ) // Las excepciones son elementos secundarios de la clase Exception. privadas FCustomData : SomeType ; // Las excepciones pueden tener extensiones personalizadas. constructor público CreateCustom ( Data : SomeType ) ; // necesita una aplicación propiedad CustomData : SomeType leer FCustomData ; terminar ;
- Generando excepciones
plantear Excepción . Crear ( 'Mensaje' ) ;plantear Excepción . CreateFmt ( 'Mensaje con valores:% d,% d' , [ valor1 , valor2 ]) ; // Consulte SysUtils.Format () para conocer los parámetros.plantear ECustom . CreateCustom ( X ) ;
- Manejo y propagación de excepciones [5]
intente // Por fin. intente // Para excepto. ... // Código que puede generar una excepción. excepto en C : ECustom do begin ... // Handle ECustom. ... si predicado ( C . CustomData ) entonces ... final ; en S : ESomeOtherException hacer comenzará // Propagar como otra excepción. plantear EYetAnotherException . Crear ( S . Mensaje ) ; terminar ; on E : Exception do begin ... // Maneja otras excepciones. plantear ; // Propagar. terminar ; terminar ; finalmente // Código para ejecutar independientemente de que se genere una excepción (por ejemplo, código de limpieza). terminar ;
Erlang
tratar % alguna peligrosa código de captura tiro : { someError , X } -> OK ; % manejar un error de excepción : X -> ok ; % manejar otra excepción _: _ -> ok % manejar todas las excepciones después de % limpiar al final
F#
Además del basado en OCaml try...with
, F # también tiene la try...finally
construcción separada , que tiene el mismo comportamiento que un bloque try con una finally
cláusula en otros lenguajes .NET.
A modo de comparación, esta es una traducción del ejemplo de C # anterior .
intente try () (* Código que podría generar una excepción. *) con | :? Sistema . Net . WebException como ex -> () (* Maneja una WebException. El objeto de excepción se almacena en "ex" . *) | :? exn -> () (* Maneja cualquier excepción CLR. Dado que no se le ha asignado un identificador a la excepción, no se puede hacer referencia a ella. *) | _ -> () (* Maneja cualquier cosa que pueda lanzarse, incluidas las excepciones que no son de CLR. *) Finalmente () (* Ejecutar siempre al salir del bloque try, independientemente de si se lanzaron excepciones o si se manejaron. Se usa con frecuencia para limpiar y cerrar recursos tales como manejadores de archivos. No se puede ejecutar cuando se llama a Environment.FailFast () y en otras condiciones excepcionales de todo el sistema (por ejemplo, pérdida de energía), o cuando el proceso falla debido a una excepción en otro hilo. *)
A modo de comparación, esta es la traducción del ejemplo de OCaml a continuación .
excepción MyException de la cadena * int (* las excepciones pueden tener un valor *) let _ = try raise ( MyException ( "no hay suficiente comida" , 2 )); printfn "No alcanzado" con | MyException ( s , i ) -> printf "MyException:% s,% d \ n " s i | e -> (* captura todas las excepciones *) eprintf " Excepción inesperada:% O" e ; eprintf "% O" e . StackTrace
Haskell
Haskell no tiene una sintaxis especial para excepciones. En cambio, un try
/ catch
/ finally
/ etc
. La interfaz es proporcionada por funciones.
importar Preludio ocultar ( capturar ) importar Control.Excepción instancia Excepción Int instancia Excepción Doble main = do catch ( catch ( throw ( 42 :: Int )) ( \ e -> print ( 0 , e :: Double ))) ( \ e -> imprimir ( 1 , e :: Int ))
huellas dactilares
(1,42)
en analogía con este C ++
#include usando el espacio de nombres std ; int main () { try { throw ( int ) 42 ;} catch ( double e ) { cout << "(0," << e << ")" << endl ;} catch ( int e ) { cout << "(1," << e << ")" << endl ;} }
Otro ejemplo es
hacer { - Declaraciones en las que pueda arrojar errores } ` captura ' \ ex -> hacer { - sentencias que se ejecutan en el caso de una excepción, con 'ex' con destino a la excepción }
En código puramente funcional, si solo existe una condición de error, el Maybe
tipo puede ser suficiente y es una instancia de la Monad
clase de Haskell por defecto. Se puede lograr una propagación de errores más compleja usando las mónadas Error
o ErrorT
, para las cuales se admite una funcionalidad similar (uso ).`catch`
Java
Un try
bloque debe tener al menos una cláusula catch
o finally
y como máximo una finally
cláusula.
try { // Ruta de ejecución normal. lanzar nueva EmptyStackException (); } catch ( ExampleException ee ) { // Tratar con ExampleException. } finalmente { // Ejecutar siempre al salir del bloque try (incluidas las cláusulas finalmente), independientemente de si se lanzaron excepciones o si se manejaron. // A menudo se usa para limpiar y cerrar recursos como los manejadores de archivos. // No se puede ejecutar cuando se llama a System.exit () y en otras condiciones excepcionales de todo el sistema (por ejemplo, pérdida de energía). }
JavaScript
El diseño de JavaScript hace que los errores fuertes / fuertes sean muy poco comunes. Los errores suaves / silenciosos son mucho más frecuentes. Los errores graves se propagan a la try
declaración más cercana , que debe ir seguida de una sola catch
cláusula, una sola finally
cláusula o ambas.
try { // Declaraciones en las que se pueden lanzar excepciones throw new Error ( "error" ); } catch ( error ) { // Declaraciones que se ejecutan en caso de una excepción } finalmente { // Declaraciones que se ejecutan después de cualquier manera }
Si no hay ninguna try
declaración, la página web no se bloquea. Por el contrario, se registra un error en la consola y se borra la pila. Sin embargo, JavaScript tiene la peculiaridad de los puntos de entrada asincrónicos invocados externamente. Mientras que, en la mayoría de los otros lenguajes, siempre hay una parte del código ejecutándose en todo momento, JavaScript no tiene que ejecutarse linealmente de principio a fin. Por ejemplo, los detectores de eventos, las promesas y los temporizadores pueden ser invocados por el navegador en un momento posterior y ejecutarse en un contexto aislado pero compartido con el resto del código. Observe cómo el código a continuación arrojará un nuevo error cada 4 segundos durante un período de tiempo indefinido o hasta que se cierre el navegador / pestaña / computadora.
setInterval ( function () { throw new Error ( "Ejemplo de un error arrojado en un intervalo de 4 segundos." ); }, 4000 );
Otra peculiaridad interesante es el polimorfismo: JavaScript puede arrojar valores primitivos como errores.
intente { lanzar 12345 ; // número primitivo } captura ( error ) { consola . log ( error ); // registra 12345 como un número primitivo en la consola }
Tenga en cuenta que la catch
cláusula es un catch-all, que detecta todo tipo de error. No hay capacidad sintáctica para asignar diferentes manejadores a diferentes tipos de errores, aparte de las extensiones de Gecko experimentales y actualmente eliminadas de hace muchos años. En cambio, uno puede propagar el error usando una throw
declaración dentro de la catch
declaración o usar múltiples casos condicionales. Comparemos un ejemplo en Java y sus equivalentes aproximados en JavaScript.
// Ejemplo en Java try { Integer i = null ; yo . intValue (); // arroja una NullPointerException } catch ( NullPointerException error ) { // La variable podría ser nula } catch ( ArithmeticException error ) { // Manejar problemas con números }
// Aproximación # 1 en JavaScript try { // Declaraciones en las que se pueden lanzar excepciones var example = null ; ejemplo . toString (); } catch ( error ) { if ( error . type === "TypeError" ) { // La variable podría ser nula } else if ( error . type === "RangeError" ) { // Manejar problemas con números } }
// Aproximación # 2 en JavaScript try { try { // Declaraciones en las que se pueden lanzar excepciones var example = null ; ejemplo . toString (); } catch ( error ) { if ( error . type ! == "TypeError" ) throw error ; // La variable puede ser nula } } catch ( error ) { if ( error . Type ! == "RangeError" ) throw error ; // Manejar problemas con números }
Otro aspecto de las excepciones son las promesas, que manejan la excepción de forma asincrónica. El manejo de la excepción de forma asincrónica tiene la ventaja de que los errores dentro del controlador de errores no se propagan más hacia afuera.
new Promise ( function () { lanzar nuevo Error ( "¡Ejemplo de error!" ); }). catch ( función ( err ) { consola . log ( "Atrapado" , err ); });
También observe cómo los controladores de eventos también pueden vincularse con las promesas.
addEventListener ( "unhandledrejection" , function ( evento ) { console . log ( evento . motivo ); event . preventDefault (); // evitar registrar el error a través de console.error en la consola - el comportamiento predeterminado });new Promise ( function () { lanzar nuevo Error ( "¡Ejemplo de error!" ); });
Por último, tenga en cuenta que, dado que JavaScript utiliza la recolección de basura de marca y barrido, nunca hay pérdida de memoria de las declaraciones de lanzamiento porque el navegador limpia automáticamente los objetos muertos, incluso con referencias circulares.
try { // Declaraciones en las que se pueden lanzar excepciones const obj = {}; obj . selfPropExample = obj ; // lanzamiento de referencia circular obj ; } catch ( error ) { // Declaraciones que se ejecutan en caso de una excepción }
Ceceo
Lisp común
( ignorar-errores ( / 1 0 ))( handler-case ( progn ( print "ingresa una expresión" ) ( eval ( read ))) ( error ( e ) ( print e )))( desenrollar-proteger ( progn ( imprimir "ingresar una expresión" ) ( eval ( leer ))) ( imprimir "Esta impresión siempre se ejecutará, similar a finalmente" ))
Lua
Lua usa las funciones pcall
y xpcall
, xpcall
tomando una función para que actúe como un catch
bloque.
- Función predefinida
función foo ( x ) si x entonces devuelve x de lo contrario error "No es un valor verdadero" end endfunción intento ( arg ) éxito , valor = pcall ( foo , arg ) si no tiene éxito entonces print ( "Error:" .. tostring ( valor )) else print ( "Devuelto:" .. tostring ( valor )) end endintento ( "hola" ) - Devuelto: holaintento ( nulo ) - Error: stdin: 5: No es un valor verdaderointento ({}) - Devuelto: tabla: 00809308 si foo ( 42 ) entonces imprime "Éxito" final - Éxito
- Función anónima
if pcall ( function () - Hacer algo que pueda arrojar un error. end ) luego imprime "Sin errores" - Se ejecuta si la llamada protegida fue exitosa. si no imprime "Error encontrado" : se ejecuta si la llamada protegida falló. finalimprimir "Listo" : siempre se ejecutará
Shell de próxima generación
- Definición de tipo de excepción personalizada
escriba MyError ( Error )
- Generando excepciones
lanzar MyError ( "esto sucedió" )
- Manejo y propagación de excepciones
intente { # algo } catch ( e : MyError ) { guard e . val = 7 # ... } catch ( e : MyError ) { # ... } catch ( e : Error ) { # ... }
- Ignorando las excepciones: intente sin capturas
tratar 1 / 0 # evalúa a nula
- Ignorar excepciones: operador "tor"
"tor" es un operador de prueba. En caso de alguna excepción al evaluar el argumento de la izquierda, evalúa el argumento de la derecha.
1 / 0 tor 20 # evalúa a 20
- "bloquear" - facilidad para usar excepciones para devolver un valor
my_result = bloque my_block { # capturas "bloquear" excepción lanzada por el retorno a continuación # hacer cálculos si calculation_finished () { my_block . return ( 42 ) # lanza una excepción } }
C objetivo
- Declaraciones de excepciones
NSException * exception = [ NSException exceptionWithName : @ "myException" motivo : @ "lo que sea" userInfo : nil ];
- Generando excepciones
@throw excepción ;
- Manejo y propagación de excepciones
@try { ... } @catch ( SomeException * se ) { // Maneja un tipo de excepción específico. ... } @catch ( NSException * ne ) { // Maneja las excepciones generales. ... // Propaga la excepción para que se maneje a un nivel superior. @throw ; } @catch ( id ue ) { // Atrapa todos los objetos lanzados. ... } @finally { // Realice la limpieza, haya ocurrido una excepción o no. ... }
OCaml
excepción MyException de la cadena * int (* las excepciones pueden tener un valor *) let _ = try raise ( MyException ( "no hay suficiente comida" , 2 )); print_endline "No alcanzado" con | MyException ( s , i ) -> Printf . printf "MiExcepción:% s,% d \ n " s i | e -> (* captura todas las excepciones *) Printf . eprintf " Excepción inesperada:% s" ( Printexc . to_string e ); (* Si usa Ocaml> = 3.11, también es posible imprimir un retroceso: *) Printexc . print_backtrace stderr ; (* Necesita habilitar de antemano la grabación de backtrace con Printexc.record_backtrace verdadero o estableciendo la variable de entorno OCAMLRUNPARAM = "b1" *)
Perl 5
El mecanismo de Perl para el manejo de excepciones utiliza die
para lanzar una excepción cuando se envuelve dentro de un bloque. Después de , la variable especial contiene el valor pasado . Sin embargo, los problemas de alcance pueden hacer que hacer esto correctamente sea bastante desagradable:eval { ... };
eval
$@
die
my ( $ error , $ falló ); { local $ @ ; $ fallido = no eval { # Código que podría lanzar una excepción (usando 'morir') abrir ( ARCHIVO , $ archivo ) || die "No se pudo abrir el archivo: $!" ; while ( ) { process_line ( $ _ ); } cerrar ( ARCHIVO ) || die "¡No se pudo cerrar $ file: $!" ; return 1 ; }; $ error = $ @ ; }if ( $ falló ) { warn "obtuvo error: $ error" ; }
Perl 5.005 agregó la capacidad de lanzar objetos y cuerdas. Esto permite una mejor introspección y manejo de tipos de excepciones.
eval { open ( ARCHIVO , $ archivo ) || die MyException :: Archivo -> nuevo ( $! ); while ( ) { process_line ( $ _ ); } cerrar ( ARCHIVO ) || die MyException :: Archivo -> nuevo ( $! ); }; if ( $ @ ) { # El objeto de excepción está en $ @ if ( $ @ -> isa ( 'MyException :: File' )) { # Manejar excepción de archivo } else { # Manejo de excepciones genéricas # o volver a lanzar con 'die $ @ ' } }
La __DIE__
pseudo-señal se puede atrapar para manejar llamadas a die
. Esto no es adecuado para el manejo de excepciones ya que es global. Sin embargo, se puede utilizar para convertir excepciones basadas en cadenas de paquetes de terceros en objetos.
local $ SIG { __DIE__ } = sub { my $ err = shift ; if ( $ err -> isa ( 'MyException' )) { die $ err ; # re-throw } else { # De lo contrario, construya una MyException con $ err como cadena die MyException :: Default -> new ( $ err ); } };
Los formularios que se muestran arriba a veces pueden fallar si la variable global $@
se cambia entre el momento en que se lanza la excepción y el momento en que se marca en la declaración. Esto puede suceder en entornos de múltiples subprocesos, o incluso en entornos de un solo subproceso cuando otro código (normalmente llamado en la destrucción de algún objeto) restablece la variable global antes del código de verificación. El siguiente ejemplo muestra una forma de evitar este problema (véase [1] [ enlace muerto ] o [2] ; cf . [3] ). Pero a costa de no poder utilizar valores devueltos:if ($@)
eval { # Código que podría lanzar una excepción (usando 'morir') pero NO usa la declaración de retorno; 1 ; } o haz { # Manejar la excepción aquí. La cadena de excepción está en $ @ };
Varios módulos de Comprehensive Perl Archive Network ( CPAN ) amplían el mecanismo básico:
Error
proporciona un conjunto de clases de excepción y permite el uso de la sintaxis try / throw / catch /.TryCatch
y ambos permiten el uso de la sintaxis try / catch / finalmente en lugar de repetitivo para manejar las excepciones correctamente.Try::Tiny
Exception::Class
es una clase base y un creador de clases para clases de excepción derivadas. Proporciona un seguimiento de pila estructurado completo en y .$@->trace
$@->trace->as_string
Fatal
sobrecargas funciones que devuelven verdadero / falso, por ejemplo, definidos previamenteopen
,close
,read
,write
, etc. Esto permite funciones incorporadas y otros para ser utilizado como si arrojaron excepciones.
PHP
// El manejo de excepciones solo está disponible en las versiones 5 y posteriores de PHP. try { // Código que podría generar una excepción throw new Exception ( 'URL no válida.' ); } catch ( FirstExceptionClass $ exception ) { // Código que maneja esta excepción } catch ( SecondExceptionClass $ exception ) { // Código que maneja una excepción diferente } finalmente { // Realizar limpieza, haya ocurrido una excepción o no. }
PowerBuilder
El manejo de excepciones está disponible en las versiones 8.0 y posteriores de PowerBuilder.
INTENTAR // Ruta de ejecución normalCATCH (ExampleException ee) // lidiar con la ExampleExceptionFINALMENTE // Esta sección opcional se ejecuta al finalizar cualquiera de los bloques try o catch anterioresFIN DE PRUEBA
Potencia Shell
Versión 1.0
trap [Excepción] { # Declaraciones que se ejecutan en caso de una excepción } # Declaraciones en las que se pueden lanzar excepciones
Versión 2.0
Pruebe { Import-Module ActiveDirectory } Catch [Exception1] { # Sentencias que se ejecutan en caso de una excepción, que coinciden con la excepción } Catch [Exception2], [Exception3etc] { # Sentencias que se ejecutan en caso de una excepción, que coinciden con cualquiera de las excepciones } Catch { # declaraciones que se ejecutan en caso de una excepción, no manejadas de manera más específica }
Pitón
f = Ninguno intente : f = open ( "aFileName" , "w" ) f . escritura ( could_make_error ()) a excepción IOError : print ( "No se puede abrir el archivo" ) , excepto : # capturar todas las excepciones imprimir ( "error inesperado" ) otra cosa : # ejecutan si no hay excepciones son criados de impresión ( "escritura de archivos completada con éxito" ) , finalmente, : # acciones de limpieza, siempre ejecutadas si f : f . cerrar ()
R
tryCatch ({ stop ( "Aquí se indica un error" ) # la clase S3 predeterminada es simpleError una subclase de error cat ( "Esta y las siguientes líneas no se ejecutan porque el error está atrapado antes de \ n" ) stop ( structure ( simpleError ( "mySpecialError message" ), class = c ( "specialError" , "error" , "condition" )) ) } , specialError = function ( e ) { cat ( "detecta errores de la clase specialError \ n" ) } , error = function ( e ) { cat ( "detecta el error predeterminado \ n" ) } , finalmente = { cat ( "hacer algo de limpieza (p. ej., setwd) \ n" ) } )
Rebol
REBOL [ Título: "Ejemplos de manejo de errores y excepciones" ]; PRUEBA un bloque; capturando un error! y convertir en objeto! si error? excepción: try [ 1 / 0 ] [ sonda de desarmado excepción ]; INTENTO da como resultado el valor del bloque o el valor ninguno en el intento de impresión de error [ dividir 1 0 ] ; Las excepciones generadas por el usuario pueden ser de cualquier tipo de datos. ejemplo: func [ "Una función para lanzar una excepción" ] [ lanzar "¡Soy una cadena! Excepción" ] atrapar [ ejemplo ]; Las excepciones generadas por el usuario también se pueden nombrar ; y las funciones pueden incluir atributos de tiempo de ejecución adicionales sofisticados: func [ "Una función para lanzar una excepción de error con nombre" [ catch ] ] [ throw / name make error! "¡Soy un error! Excepción" 'apodo ] captura / nombre [ sofisticado ] ' apodo
Rexx
señal de alto ; hacer a = 1 decir un hacer 100000 / * un retraso * / final final detener : decir "El programa fue detenido por el usuario" Salida
Rubí
begin # Haz algo ingenioso plantea SomeError , "¡Este es el mensaje de error!" # ¡UH oh! rescate SomeError # Esto se ejecuta cuando una excepción SomeError # se eleva rescate AnotherError => Error # Aquí, el objeto de excepción se hace referencia desde el # `error' variable de rescate # Este capturas de todas las excepciones derivadas de StandardError reintento # Esto ejecuta la sección comienzan de nuevo else # Esto se ejecuta solo si no se generaron excepciones asegúrese # Esto siempre se ejecuta, excepción o no final
Jerga
intentar { % código que podría generar una excepción } atrapar SomeError: { % código que maneja esta excepción } atrapar SomeOtherError: { % código que maneja esta excepción } finalmente% bloque opcional { % Este código siempre se ejecutará }
Se pueden crear nuevas excepciones usando la new_exception
función, por ejemplo,
new_exception ("MyIOError", IOError, "My I / O Error");
creará una excepción llamada MyIOError
como subclase de IOError
. Se pueden generar excepciones utilizando la instrucción throw, que puede lanzar objetos S-Lang arbitrarios .
Charla
[ "código que podría generar una excepción" ] en: ExceptionClass hacer: [ : ex | "código que maneja la excepción" ] .
El mecanismo general lo proporciona el mensaje . [6] Las excepciones son sólo objetos normales que subclase , se lanza mediante la creación de una instancia y el envío de un mensaje, por ejemplo, . El mecanismo de manejo ( ) es nuevamente un mensaje normal implementado por . La excepción lanzada se pasa como un parámetro al cierre del bloque de manejo y se puede consultar, así como potencialmente enviarle , para permitir que continúe el flujo de ejecución.on:do:
Error
#signal
MyException new signal
#on:do:
BlockClosure
#resume
Rápido
El manejo de excepciones es compatible desde Swift 2.
enumeración MiExcepción : ErrorType { caso Foo ( Cadena , Int ) } func someFunc () lanza { tiro MiExcepción . Foo ( "no hay suficiente comida" , 2 ) } no { prueba someFunc () print ( "No alcanzado" ) } captura MyException . Foo ( let s , let i ) { print ( "MyException: \ ( s ) , \ ( i ) " ) } catch { print ( "Excepción inesperada: \ ( error ) " ) }
Tcl
if { [ catch { foo } err ] } { pone "Error: $ err" }
Desde Tcl 8.6, también hay un comando try:
intente { someCommandWithExceptions } en ok { res opt } { # manejar caso normal. } trap ListPattern1 { err opt } { # manejar excepciones con un código de error que coincida con ListPattern1 } trap ListPattern2 { err opt } { # ... } en error { err opt } { # manejar todo lo demás. } finalmente { # ejecutar cualquier comando que deba ejecutarse después del bloque try. }
VBScript
Con nuevo intento : en caso de error, reanudar a continuación 'hacer algo (solo se recomienda una declaración) . Capturar : en caso de error Ir a 0 : seleccionar caso . Número Caso 0 'esta línea es necesaria cuando se usa la cláusula' Caso Else 'debido a la falta de la palabra clave "Es" en VBScript Declaración del caso ' sin excepción Caso SOME_ERRORNUMBER 'manejo de excepciones Caso Else ' excepción desconocida Fin Seleccionar : Finalizar con'*** Probar clase *** Clase Probar privado mstrDescription Privado mlngHelpContext Privado mstrHelpFile Privado mlngNumber Privado mstrSource Captura secundaria pública () mstrDescription = Err . Descripción mlngHelpContext = Err . HelpContext mstrHelpFile = Err . HelpFile mlngNumber = Err . Número mstrSource = Err . Fuente End Sub Propiedad pública Obtener fuente () Fuente = mstrSource Propiedad final Propiedad pública Obtener número () Número = mlngNumber Propiedad final Propiedad pública Get HelpFile () HelpFile = mstrHelpFile End Property Propiedad pública Get HelpContext () HelpContext = mlngHelpContext End Propiedad Público Propiedad Obtener Descripción () Descripción = mstrDescription Fin Propiedad End Class
Visual Basic 6
La sintaxis de manejo de excepciones es muy similar a Basic. El manejo de errores es local en cada procedimiento.
On Error GoTo HandlerLabel 'Cuando se ha producido un error, salta a HandlerLabel, que se define en cualquier lugar dentro de Function o Sub ' o On Error GoTo 0 ', desactive el manejo de errores. El error causa un error fatal en tiempo de ejecución y detiene la aplicación 'o en caso de error, reanudar siguiente ' Objeto Err está establecido, pero la ejecución continúa en el siguiente comando. Aún puede usar el objeto Err para verificar el estado de error. '... Err . Levantar 6 'Genera un error de "desbordamiento" usando el objeto incorporado Err. Si no hay un controlador de errores, el procedimiento de llamada puede detectar la excepción con la misma sintaxis '...FinalmenteLabel : 'solo etiqueta común dentro del procedimiento (emulación no oficial de la sección Finalmente de otros idiomas) ' código de limpieza, siempre ejecutado Exit Sub ' sale del procedimiento'debido a que estamos detrás de la instrucción Exit Sub, el siguiente código está oculto para una ejecución sin errores HandlerLabel : ' define una etiqueta común, aquí utilizada para el manejo de excepciones. Si Err . Número = 6 Entonces, 'La instrucción Select Case suele ser una mejor solución. Reanudar por últimoLabel ' continúe la ejecución en una etiqueta específica. Por lo general, algo con el significado de "Finalmente" en otros idiomas 'o Continuar siguiente ' continuar la ejecución en la declaración junto a "Err.Raise 6" 'o Resume ' continuar la ejecución en (repetir) la declaración "Err.Raise 6" End IfMsgBox Err . Número & "" & Err . Fuente & "" & Erl & "" & Err . Descripción & "" & Err . LastDllError 'muestra el cuadro de mensaje con propiedades de error importantes ' Erl es la variable global de número de línea incorporada de VB6 (si se usa). Normalmente se utiliza algún tipo de IDE de complementos, que las etiquetas de cada línea de código con el número antes de la compilación Reanudar FinallyLabel
Ejemplo de implementación específica (no oficial) del manejo de excepciones, que usa el objeto de la clase "Try".
Con New Try : En caso de error Continuar Siguiente 'Crear un nuevo objeto de la clase "Try" y usarlo. Luego, establezca este objeto como predeterminado. Puede ser "Dim T As New Try: ... ... T.Catch 'do Something (solo se recomienda una declaración) . Catch : On Error GoTo 0 : Select Case . Number ' Llame al procedimiento Try.Catch (). Luego cambie Desactivar el manejo de errores. Luego use la instrucción "similar a un interruptor" en el resultado de la propiedad Try.Number (valor de la propiedad Err.Number del objeto Err incorporado ) Case SOME_ERRORNUMBER 'manejo de excepciones Case Is <> 0 ' When Err.Number es cero , no ha ocurrido ningún error 'excepción desconocida End Select : End With'*** Clase de prueba *** Private mstrDescription como cadena Private mlngHelpContext As Long Private mstrHelpFile As String Private mlngLastDllError As Long Private mlngNumber As Long Private mstrSource como cadena Captura secundaria pública () mstrDescription = Err . Descripción mlngHelpContext = Err . HelpContext mstrHelpFile = Err . HelpFile mlngLastDllError = Err . LastDllError mlngNumber = Err . Número mstrSource = Err . Fuente End Sub Público Propiedad Obtener Fuente ) ( Como Cadena Fuente = mstrSource Fin Propiedad Propiedad pública Obtener número () como número largo = mlngNumber Propiedad final Propiedad pública Obtener LastDllError () como largo LastDllError = mlngLastDllError End Property Propiedad pública Obtener HelpFile () como cadena HelpFile = mstrHelpFile End Property Propiedad pública Get HelpContext () As Long HelpContext = mlngHelpContext End Property Propiedad pública Obtener descripción () como descripción de cadena = mstrDescription Propiedad final
Visual Basic .NET
Un Try
bloque debe tener al menos una cláusula Catch
o Finally
cláusula y como máximo una Finally
cláusula.
Intente ejecutar el código aquí Catch ex As Exception When condition 'Manejar la excepción cuando una condición específica es verdadera. El objeto de excepción se almacena en "ex". Catch ex As ExceptionType 'Maneja la excepción de un tipo específico (es decir, DivideByZeroException, OverflowException, etc.) Catch ex As Exception ' Maneja la excepción (captura todas las excepciones de un tipo no especificado previamente) Catch 'Maneja cualquier cosa que pueda ser lanzada, incluyendo no Excepciones CLR. Finalmente 'Ejecutar siempre al salir del bloque try (incluidas las cláusulas catch), independientemente de si se lanzaron excepciones o si se manejaron. 'A menudo se usa para limpiar y cerrar recursos como manejadores de archivos. 'No se puede ejecutar cuando se llama a Environment.FailFast () y en otras condiciones excepcionales de todo el sistema (por ejemplo, pérdida de energía), o cuando el proceso falla debido a una excepción en otro hilo. Finalizar intento
Prólogo visual
http://wiki.visual-prolog.com/index.php?title=Language_Reference/Terms#Try-catch-finally
intente % Block para proteger catch TraceId haga % Code para ejecutar en caso de una excepción; Traceid da acceso a la información de excepción , finalmente regardles se ejecutará% Código sin embargo las otras partes se comportan final intento
X ++
public static void Main ( Args _args ) { try { // Código que podría generar una excepción. } catch ( Exception :: Error ) // O cualquier otro tipo de excepción. { // Procesar el error. } catch { // Procesar cualquier otro tipo de excepción que no se haya manejado previamente. } // El código aquí se ejecutará siempre que se detecte alguna excepción. }
Referencias
- ^ Preguntas frecuentes de Bjarne Stroustrup
- ^ "Manejo de excepciones" . Archivado desde el original el 2 de enero de 2014 . Consultado el 1 de enero de 2014 .
- ^ "Etiquetas de manejo de excepciones" . Archivado desde el original el 2 de enero de 2014 . Consultado el 1 de enero de 2014 .
- ^ https://issues.jboss.org/browse/RAILO-2176 # Boleto de seguimiento de problemas de la comunidad JBoss para agregar
retry
- ^ Borland, Delphi versión 7.0, ayuda en línea
- ^ "Pharo por ejemplo" . Archivado desde el original el 21 de octubre de 2009 . Consultado el 20 de marzo de 2010 .
- ^ a b Try-Catch para VB
Ver también
- Manejo de excepciones para la semántica del manejo de excepciones
- Sintaxis para la definición de sintaxis en informática