Apply your JS skills to key Mozilla projects as an MDN Fellow! http://mzl.la/MDNFellowship

mozilla
Os seus resultados da pesquisa

    try...catch

    Esta tradução está incompleta. Ajude atraduzir este artigo.

    Sumário

    Marca um bloco de  declarações para testar (try),  e especificar uma resposta, should an exception be thrown.

    Informações de Versão

    Statement
    Implementado em: JavaScript 1.4

    JavaScript 1.5, NES 6.0: Added multiple catch clauses and conditional clauses (Netscape extension).

    ECMA Version: ECMA-262, Edition 3

    Sintaxe

    try {
       try_statements
    }
    [catch (exception_var_1 if condition_1) {
       catch_statements_1
    }]
    ...
    [catch (exception_var_2) {
       catch_statements_2
    }]
    [finally {
       finally_statements
    }]
    

    Parâmetros

    try_statements
    Declarações(statements) a serem executadas.
    catch_statements_1, catch_statements_2
    Declarações que são executadas se uma exceção é lançada no bloco try.
    exception_var_1, exception_var_2
    Um indentificador que leva um objeto exceção para uma clásula catch  associada.
    condition_1
    Uma expressão condicional.
    finally_statements
    Declarações que são executadas depois que a declaração try é completada. Essas declarações Essas declarações são executadas independetemente se uma exceção foi ou não lançada (thrown) ou capturada (caught).

    Descrição

    A declaração try consiste  em um bloco try, que contém uma ou mais declarações, e ao menos uma clásula catch  ou uma clásula finally,  ou ambas. Ou seja, há 3 formas de declarações try :

    1. try...catch
    2. try...finally
    3. try...catch...finally

    Uma cláusula catch contém declarações que especificam o que fazer se uma exceção é lançada(thrown) no bloco try. é isso, se você quer que o bloco try block tenha êxito, e não tem,  você vai querer controlar para passar para o bloco catch. Se nenhuma declaração com o bloco try  (or in a function called from within the try block) throws an exception, control immediately shifts to the catch clause. If no exception is thrown in the try block, the catch clause is skipped.

    The finally clause executes after the try block and catch clause(s) execute but before the statements following the try statement. It always executes, regardless of whether or not an exception was thrown or caught.

    You can nest one or more try statements. If an inner try statement does not have a catch clause, the enclosing try statement's catch clause is entered.

    You also use the try statement to handle JavaScript exceptions. See the Core JavaScript 1.5 Guide for information on JavaScript exceptions.

    Unconditional catch clause

    When a single, unconditional catch clause is used, the catch block is entered when any exception is thrown. For example, when the exception occurs in the following code, control transfers to the catch clause.

    try {
       throw "myException"; // generates an exception
    }
    catch (e) {
       // statements to handle any exceptions
       logMyErrors(e); // pass exception object to error handler
    }
    

    Conditional catch clauses

    Non-standard
    This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

    You can also use one or more conditional catch clauses to handle specific exceptions. In this case, the appropriate catch clause is entered when the specified exception is thrown. In the following example, code in the try block can potentially throw three exceptions: TypeError, RangeError, and EvalError. When an exception occurs, control transfers to the appropriate catch clause. If the exception is not one of the specified exceptions and an unconditional catch clause is found, control transfers to that catch clause.

    If you use an unconditional catch clause with one or more conditional catch clauses, the unconditional catch clause must be specified last. Otherwise, the unconditional catch clause will intercept all types of exception before they can reach the conditional ones.

    try {
       myroutine(); // may throw three exceptions
    } catch (e if e instanceof TypeError) {
       // statements to handle TypeError exceptions
    } catch (e if e instanceof RangeError) {
       // statements to handle RangeError exceptions
    } catch (e if e instanceof EvalError) {
       // statements to handle EvalError exceptions
    } catch (e) {
       // statements to handle any unspecified exceptions
       logMyErrors(e); // pass exception object to error handler
    }
    

    Note: This functionality is not part of the ECMAScript specification.

    The exception identifier

    When an exception is thrown in the try block, exception_var (e.g. the e in catch (e)) holds the value specified by the throw statement. You can use this identifier to get information about the exception that was thrown.

    This identifier is local to the catch clause. That is, it is created when the catch clause is entered, and after the catch clause finishes executing, the identifier is no longer available.

    The finally clause

    The finally clause contains statements to execute after the try block and catch clause(s) execute but before the statements following the try statement. The finally clause executes regardless of whether or not an exception is thrown. If an exception is thrown, the statements in the finally clause execute even if no catch clause handles the exception.

    You can use the finally clause to make your script fail gracefully when an exception occurs; for example, you may need to release a resource that your script has tied up. The following example opens a file and then executes statements that use the file (server-side JavaScript allows you to access files). If an exception is thrown while the file is open, the finally clause closes the file before the script fails.

    openMyFile()
    try {
       // tie up a resource
       writeMyFile(theData);
    }
    finally {
       closeMyFile(); // always close the resource
    }
    

    Nested try-blocks

    First lets see what happens with this:

    try {
      try {
        throw new Error("oops");
      }
      finally {
        console.log("finally");
      }
    }
    catch (ex) {
      console.error("outer", ex.message);
    }

    Result

    "finally"
    "outer" "oops"

    Now, if we already caught the exception in the inner try-block by adding a catch block

    try {
      try {
        throw new Error("oops");
      }
      catch (ex) {
        console.error("inner", ex.message);
      }
      finally {
        console.log("finally");
      }
    }
    catch (ex) {
      console.error("outer", ex.message);
    }

    Result

    "inner" "oops"
    "finally"

    And now, lets re-throw the error.

    try {
      try {
        throw new Error("oops");
      }
      catch (ex) {
        console.error("inner", ex.message);
        throw ex;
      }
      finally {
        console.log("finally");
      }
    }
    catch (ex) {
      console.error("outer", ex.message);
    }

    Result

    "inner" "oops"
    "finally"
    "outer" "oops"

    So there you have it. Any given exception will be caught only once, by the nearest enclosing catch-block, unless it is re-thrown. Of course any new exceptions raised in "inner" block (because code in catch-block way do something that throws ;) will be caught by the "outer" block.

    Examples

    See the examples for throw.

    See also

    Etiquetas do documento e colaboradores

    Contribuíram para esta página: xhximenes
    Última atualização por: xhximenes,