catch - try finally javascript

Diferencia entre try-finally y try-catch

Question

Cuál es la diferencia entre

try {
    fooBar();
} finally {
    barFoo();
}

y

try {
  fooBar();
} catch(Throwable throwable) {
    barFoo(throwable); // Does something with throwable, logs it, or handles it.
}

Me gusta más la segunda versión porque me da acceso al Throwable. ¿Hay alguna diferencia lógica o una convención preferida entre las dos variaciones?

Además, ¿hay alguna forma de acceder a la excepción de la cláusula finally?

Answer 1

En My reasearch Finalmente, el bloque siempre se ejecuta y se utiliza principalmente para cerrar las conexiones abiertas y para destruir algo que se ejecuta innecesariamente.

Answer 2

En general, cuando utilizamos recursos como streams, conexiones, etc., tenemos que cerrarlos explícitamente usando finally block. En el programa que se incluye a continuación, estamos leyendo datos de un archivo usando FileReader y lo estamos cerrando usando finally block.

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]){
      FileReader fr=null;       
      try{
         File file=new File("file.txt");
         fr = new FileReader(file);  char [] a = new char[50];
         fr.read(a); // reads the content to the array
         for(char c : a)
         System.out.print(c); //prints the characters one by one
      }catch(IOException e){
          e.printStackTrace();
       }
       finally{ 
          try{
              fr.close();
          }catch(IOException ex){       
               ex.printStackTrace();
           }
       }
    }

}

Quizás otros tipos como yo buscamos algo como esto.

Información de esta página tutpoint

Answer 3

Estas no son variaciones, son fundamentalmente cosas diferentes. finally se ejecuta siempre , catch solo cuando ocurre una excepción.

Answer 4

Estas son dos cosas diferentes:

• El bloque catch se ejecuta solo si se lanza una excepción en el bloque try.
• El bloque finally se ejecuta siempre después del bloque try (-catch), si se lanza una excepción o no.

En su ejemplo, no ha mostrado la tercera construcción posible:

try {
    // try to execute this statements...
}
catch( SpecificException e ) {
    // if a specific exception was thrown, handle it here
}
// ... more catches for specific exceptions can come here
catch( Exception e ) {
    // if a more general exception was thrown, handle it here
}
finally {
    // here you can clean things up afterwards
}

Y, como dice @codeca en su comentario, no hay forma de acceder a la excepción dentro del bloque finally, porque el bloque finally se ejecuta incluso si no hay excepción.

Por supuesto, puede declarar una variable que contiene la excepción fuera de su bloque y asignarle un valor dentro del bloque catch. Luego puedes acceder a esta variable dentro de tu bloque finally.

Throwable throwable = null;
try {
    // do some stuff
}
catch( Throwable e ) {
    throwable = e;
}
finally {
    if( throwable != null ) {
        // handle it
    }
}

Answer 5

Finalmente el bloque siempre se ejecuta. El bloqueo de captura se ejecuta solo cuando se atrapa una excepción que coincide con el parámetro de bloques.

Answer 6

Finalmente, los bloques de captura son bastante diferentes:

Dentro del bloque catch puedes responder a la excepción lanzada. Este bloque se ejecuta solo si hay una excepción no controlada y el tipo coincide con la o con la subclase de la especificada en el parámetro del bloque catch. Finalmente, se ejecutará siempre después de probar y atrapar bloques, ya sea que haya una excepción o no.

Answer 7

Finalmente, los bloques de captura son bastante diferentes:

• Dentro del bloque catch puedes responder a la excepción lanzada. Este bloque se ejecuta solo si hay una excepción no controlada y el tipo coincide con la o con la subclase de la especificada en el parámetro del bloque catch.
• Finalmente, se ejecutará siempre después de probar y atrapar bloques, ya sea que haya una excepción o no.

Asi que

try {
  //some code
}
catch (ExceptionA) {
  // Only gets executed if ExceptionA 
  // was thrown in try block
}
catch (ExceptionB) {
  // Only executed if ExceptionB was thrown in try 
  // and not handled by first catch block
}

difiere de

try {
  //some code
}
finally {
  // Gets executed whether or not 
  // an exception was thrown in try block
}

significativamente.

Si define un bloque try, debe definir

1. uno finalmente bloquea, o
2. uno o más bloques de captura, o
3. uno o más bloques de captura y uno finalmente bloquean

Entonces el siguiente código sería válido también:

try {
  //some code
}
catch (ExceptionA) {
  // Only gets executed if 
  // ExceptionA was thrown in try block
}
catch (ExceptionB) {
  // Only executed if ExceptionB was thrown in 
  // try and not handled by first catch block
}
//even more catch blocks
finally {
  // Gets executed whether or not an 
  // exception was thrown in try block
}

Answer 8

Incluso en el primer formulario, puede iniciar sesión en el método de llamada. Entonces no hay una gran ventaja a menos que quieras hacer un manejo especial allí mismo.

Answer 9

try se usa para ejecutar un método que puede lanzar una excepción

la captura se usa para "atrapar" detener esa excepción

finalmente se usa para cualquier limpieza necesaria para que esa excepción sea atrapada o no

try{
    myObject.riskyMethod(); // run a method that may throw an exception
}
catch(Exception ex){
    myLogger.log(ex.Message); // "catch" stop that exception
}
finally{
    myObject = null; // clean up needed from that exception being caught
}

Answer 10

try {
    statements;
} catch (exceptionType1 e1) {      // one or multiple
    statements;                 
} catch (exceptionType2 e2) {
    statements;
}    
...
} finally {                                 // one or none
    statements;
}

1. Todas las declaraciones try deben incluir una cláusula catch o una cláusula finally
2. Puede tener varias cláusulas catch pero solo una cláusula finally
3. Durante cualquier ejecución, si ocurre algún error, entonces el control se transfiere al bloque de captura apropiado y ejecuta las instrucciones y finalmente se ejecuta el bloque.

No importa qué El bloque Finalmente se ejecuta siempre, Por lo tanto, en general, se utiliza el bloque Finalmente, cuando tiene sesiones, Conexiones de base de datos o Archivos o sockets están abiertos, entonces se colocará el código para cerrar esas conexiones. Esto es solo para asegurarse de que en una aplicación no haya pérdidas de memoria o cualquier otro problema no debería ocurrir.