JavaScript Errors
tryruns code that might fail, andcatchhandles it when it does.
If nothing goes wrong, the catch block never runs.
If something does, execution jumps there immediately.
Example
javascript
let result;
try {
result = JSON.parse("not json");
} catch (error) {
result = "could not parse that";
}
console.log(result);The output is could not parse that.
Code in the try block runs normally.
If it throws, the rest of the block is skipped.
catch receives the error and decides what to do.
Syntax
javascript
try {
risky();
} catch (error) {
handle(error);
}The error parameter can be left out if you do not need it.
Everything after the failing line is abandoned.
Example
javascript
const steps = [];
try {
steps.push("before");
null.length;
steps.push("after");
} catch (error) {
steps.push("caught");
}
console.log(steps.join(" "));The output is before caught.
A large try block hides which line actually failed.
Wrap only the part that can genuinely throw.
Example
javascript
const text = '{"name":"Ada"}';
let user;
try {
user = JSON.parse(text);
} catch (error) {
user = null;
}
console.log(user === null ? "failed" : user.name);The work that cannot fail sits outside the block.
A const or let declared in the try block cannot be seen outside it.
Declare it before the block if you need it afterwards.
Example
javascript
let value;
try {
value = 42;
} catch (error) {
value = 0;
}
console.log(value);Declaring inside the block would put it out of reach.
If you do not need the error, the brackets can be left off entirely.
Example
javascript
let ok;
try {
null.length;
ok = true;
} catch {
ok = false;
}
console.log(ok);The output is false.
An empty catch hides the problem completely.
At minimum, record that something failed.
Example
javascript
let status;
try {
null.length;
} catch (error) {
status = "failed: " + error.name;
}
console.log(status);A silent catch is one of the hardest bugs to track down.
Complete Example
html
<!DOCTYPE html>
<html>
<head>
<title>JavaScript try catch</title>
</head>
<body>
<h1>try catch</h1>
<p id="out"></p>
<script>
const text = "not valid json";
const out = document.getElementById("out");
try {
const data = JSON.parse(text);
out.textContent = "Loaded " + data.name;
} catch (error) {
out.textContent = "Could not read the data: " + error.name;
}
</script>
</body>
</html>Run the above example in the Try It Editor.
Try valid JSON:
Change the text to '{"name":"Ada"}' and see the other branch run.
try runs code that might fail.catch runs only when something throws.try block is skipped on failure.try block as small as possible.catch block completely empty.try catch is how a program survives something going wrong.
A small try block makes the failure easy to locate.
Silently swallowing errors causes far more trouble than it saves.