현재 번역은 완벽하지 않습니다. 한국어로 문서 번역에 동참해주세요.
The try...catch
statement marks a block of statements to try, and specifies a response, should an exception be thrown.
문법
try { try_statements } [catch (exception_var_1 if condition_1) { // 비표준 catch_statements_1 }] ... [catch (exception_var_2) { catch_statements_2 }] [finally { finally_statements }]
try_statements
- 실행될 선언들
catch_statements_1
,catch_statements_2
- try 블록에서 예외가 발생했을 때 실행될 선언들
exception_var_1
,exception_var_2
- catch 항목과 관련된 예외 객체를 담기 위한 식별자
condition_1
- 조건식
finally_statements
- try 선언이 완료된 이후에 실행된 선언들. 이 선언들은 예외 발생 여부와 상관없이 실행된다.
설명
try 선언의 구성은 하나 혹은 그 이상의 선언을 포함한 try 블록 및 catch 항목이나 finally 항목 중 최소한 하나 혹은 둘 다 포함하여 이루어진다. 즉, try 선언에는 세 가지 형식이 존재한다.
try...catch
try...finally
try...catch...finally
A catch
clause contain statements that specify what to do if an exception is thrown in the try
block. That is, you want the try
block to succeed, and if it does not succeed, you want control to pass to the catch
block. If any statement within the try
block (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 JavaScript Guide for more 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.
Reminder: this functionality is not part of the ECMAScript specification.
try { myroutine(); // may throw three types of 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 }
And here is how to do implement the same "Conditional catch clauses" using only simple JavaScript conforming to the ECMAScript specification (obviously it's more verbose, but works everywhere):
try { myroutine(); // may throw three types of exceptions } catch (e) { if (e instanceof TypeError) { // statements to handle TypeError exceptions } else if (e instanceof RangeError) { // statements to handle RangeError exceptions } else if (e instanceof EvalError) { // statements to handle EvalError exceptions } else { // statements to handle any unspecified exceptions logMyErrors(e); // pass exception object to error handler } }
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. The code in finally
also executes upon explicitly returning from try
or catch
block.
openMyFile() try { // tie up a resource writeMyFile(theData); } finally { closeMyFile(); // always close the resource }
Examples
Nested try-blocks
First let's see what happens with this:
try { try { throw new Error("oops"); } finally { console.log("finally"); } } catch (ex) { console.error("outer", ex.message); } // Output: // "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); } // Output: // "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); } // Output: // "inner" "oops" // "finally" // "outer" "oops"
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 the "inner" block (because code in catch-block may do something that throws), will be caught by the "outer" block.
Returning from a finally block
If the finally
block returns a value, this value becomes the return value of the entire try-catch-finally
production, regardless of any return
statements in the try
and catch
blocks. This includes exceptions thrown inside of the catch block:
try { try { throw new Error("oops"); } catch (ex) { console.error("inner", ex.message); throw ex; } finally { console.log("finally"); return; } } catch (ex) { console.error("outer", ex.message); } // Output: // "inner" "oops" // "finally"
The outer "oops" is not thrown because of the return in the finally block. The same would apply to any value returned from the catch block.
Specifications
Specification | Status | Comment |
---|---|---|
ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.4 |
ECMAScript 5.1 (ECMA-262) The definition of 'try statement' in that specification. |
Standard | |
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'try statement' in that specification. |
Standard | |
ECMAScript 2016 Draft (7th Edition, ECMA-262) The definition of 'try statement' in that specification. |
Draft | Not part of the current ECMA-262 standard: Multiple catch clauses and conditional clauses (SpiderMonkey extension, JavaScript 1.5). |
Browser compatibility
Feature | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Conditional clauses (non-standard) |
Not supported | (Yes) | Not supported | Not supported | Not supported |
Feature | Android | Chrome for Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
---|---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Conditional clauses (non-standard) |
Not supported | Not supported | (Yes) | Not supported | Not supported | Not supported |