try...catch | JavaScript

在此页

句法
描述
范例
规范
浏览器兼容性
另请参阅
相关话题

try...catch statement marks a block of statements to try and specifies a response should an exception be thrown.

The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

句法

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

try_statements

catch_statements_1 , catch_statements_2: Statements that are executed if an exception is thrown in the try -block.

exception_var_1 , exception_var_2: An identifier to hold an exception object for the associated catch -block.

condition_1

finally_statements: Statements that are executed after the try statement completes. These statements execute regardless of whether an exception was thrown or caught.

描述

try statement consists of a try -block, which contains one or more statements. {} must always be used, even for single statements. At least one catch -block, or a finally -block, must be present. This gives us three forms for the try statement:

try...catch
try...finally
try...catch...finally

A catch -block contains statements that specify what to do if an exception is thrown in the try -block. If any statement within the try -block (or in a function called from within the try -block) throws an exception, control is immediately shifted to the catch -block. If no exception is thrown in the try -block, the catch -block is skipped.

finally -block will always execute after the try -block and catch -block(s) have finished executing. It always executes, regardless of whether an exception was thrown or caught.

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

You can also use the try statement to handle JavaScript exceptions. See the JavaScript 指南 for more information on JavaScript exceptions.

无条件捕获块

当 catch -block is used, the catch -block is executed when any exception is thrown from within the try -block. For example, when the exception occurs in the following code, control transfers to the catch -block.

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

catch -block specifies an identifier ( e in the example above) that holds the value of the exception; this value is only available in the scope of the catch -block.

有条件捕获块

You can create "Conditional catch -blocks" by combining try...catch blocks with if...else if...else structures, like this:

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
  }
}

A common use case for this is to only catch (and silence) a small subset of expected errors, and then re-throw the error in other cases:

try {
  myRoutine();
} catch (e) {
  if (e instanceof RangeError) {
    // statements to handle this very common expected error
  } else {
    throw e;  // re-throw the error unchanged
  }
}

The exception identifier

When an exception is thrown in the try -block, exception_var (i.e., the e in catch (e) ) holds the exception value. You can use this identifier to get information about the exception that was thrown. This identifier is only available in the catch -block's scope .

function isValidJSON(text) {
  try {
    JSON.parse(text);
    return true;
  } catch {
    return false;
  }
}

The finally-block

finally -block contains statements to execute after the try -block and catch -block(s) execute, but before the statements following the try...catch...finally -block. Note that the finally -block executes regardless of whether an exception is thrown. Also, if an exception is thrown, the statements in the finally -block execute even if no catch -block handles the exception.

The following example shows one use case for the finally -block. The code opens a file and then executes statements that use the file; the finally -block makes sure the file always closes after it is used even if an exception was thrown.

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

范例

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, let's rethrow 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 rethrown. Of course, any new exceptions raised in the "inner" block (because the code in catch -block may do something that throws), will be caught by the "outer" block.

Returning from a finally-block

若 finally -block returns a value, this value becomes the return value of the entire try-catch-finally statement, regardless of any return statements in the try and catch -blocks. This includes exceptions thrown inside of the catch -block:

(function() {
  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.

规范

规范
ECMAScript (ECMA-262) The definition of 'try statement' in that specification.

浏览器兼容性

The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request. 更新 GitHub 上的兼容性数据

	Desktop						Mobile						Server
	Chrome	Edge	Firefox	Internet Explorer	Opera	Safari	Android webview	Chrome for Android	Firefox for Android	Opera for Android	Safari on iOS	Samsung Internet	Node.js
`try...catch`	Chrome 1	Edge 12	Firefox 1	IE 5	Opera 4	Safari 1	WebView Android 1	Chrome Android 18	Firefox Android 4	Opera Android 10.1	Safari iOS 1	Samsung Internet Android 1.0	nodejs 0.1.100
Optional catch binding	Chrome 66	Edge 79	Firefox 58	IE 不支持 No	Opera 53	Safari 11.1	WebView Android 66	Chrome Android 66	Firefox Android 58	Opera Android 47	Safari iOS 11.3	Samsung Internet Android 9.0	nodejs 10.0.0

在此页

句法

描述