Learn how JavaScript finally block works with try and catch to ensure reliable error handling. This beginner’s guide covers how to use finally correctly, avoid common mistakes, and write cleaner JavaScript code.
Introduction
When writing JavaScript code, errors are inevitable, maybe a file didn’t load, a user entered the wrong input, or a network request failed. These issues can stop your program from running smoothly. Thankfully, JavaScript provides a powerful way to deal with them using error handling.
You might already know about try and catch, but there’s one more piece to complete the puzzle, the finally block. It ensures your code runs no matter what happens, making your program more stable and predictable.
What You’ll Learn
By the end of this guide, you’ll understand:
- What the finallyblock does in JavaScript
- How try...catch...finallyworks together
- Why you should use finallyin real-life situations
- Common mistakes to avoid when using it
- Simple examples to help you practice
Understanding the Finally Block in JavaScript
Before we dive deep, let’s quickly revisit how try and catch work.
- The tryblock is where you put code that might throw an error.
- The catchblock handles that error if it happens.
Now, the finally block runs after both, no matter what. It’s like saying:
“Even if something goes wrong, finish this last step.”
Example:
try {
  console.log("Starting process...");
  throw new Error("Something went wrong!");
} catch (error) {
  console.log("Error caught:", error.message);
} finally {
  console.log("Process finished, cleaning up!");
}
Output:
Starting process...
Error caught: Something went wrong!
Process finished, cleaning up!
Even though an error occurred, the
finallyblock still executed. That’s what makes it so reliable.
Why Use the Finally Block
Now that you’ve seen how it works, let’s talk about why it’s useful.
The finally block is great for clean-up actions, code that should run no matter what. 
Examples include:
- Closing a file or database connection
- Stopping a timer or animation
- Logging completion messages
- Freeing up system resources
Let’s look at a real-world example:
function fetchUserData() {
  try {
    console.log("Fetching user data...");
    throw new Error("Network error!");
  } catch (error) {
    console.log("Error:", error.message);
  } finally {
    console.log("Closing connection...");
  }
}
fetchUserData();
Even though the network request failed, the finally block still runs to close the connection, just like shutting the door, even if something went wrong inside.
How Finally Works with Return Statements
Even when your code has a return inside try or catch, the finally block always runs before the function ends.
Example:
function checkNumber(num) {
  try {
    if (num > 0) return "Positive number";
    throw new Error("Not positive");
  } catch (error) {
    console.log("Caught error:", error.message);
  } finally {
    console.log("Check complete.");
  }
}
console.log(checkNumber(-5));
Output:
Caught error: Not positive
Check complete.
undefined
The
finallyblock runs right before the function exits, ensuring all final steps are completed.
Common Mistakes When Using Finally
Now that you understand how finally works, let’s look at some common mistakes beginners often make and how to avoid them.
1. Returning Values Inside Finally
Many developers try to use return inside a finally block. That’s a bad idea because it overrides previous return values or errors, which can make debugging difficult.
Wrong:
function test() {
  try {
    return "From try";
  } finally {
    return "From finally"; // Overrides try return
  }
}
console.log(test()); // Output: "From finally"
Tip: Avoid returning from finally. Let it finish the cleanup work only.
2. Ignoring Errors Inside Finally
If an error happens inside finallyIt can hide other errors that occurred earlier.
Wrong:
try {
  throw new Error("Original error");
} finally {
  undefinedFunction(); // Throws another error
}
The new error from finally replaces the original one, making debugging confusing.
Tip: Keep your
finallyblock simple and safe.
3. Doing Too Much Work in Finally
Finally blocks should be light; avoid putting complex logic or new asynchronous code there. It should mainly clean up, not do more processing.
Right Approach:
try {
  // Main code
} catch (error) {
  console.log("Error:", error.message);
} finally {
  console.log("Cleanup done."); // Keep it short
}
Conclusion
The finally block in JavaScript is a small but powerful feature that ensures your code finishes essential steps, even when things go wrong.
By combining it with try and catch, you can handle errors gracefully, clean up properly, and write code that’s both safe and reliable.
Remember: keep your finally block light, avoid returning values inside it, and use it for necessary cleanup only. With this simple approach, you’ll be writing JavaScript like a professional developer, one reliable line at a time.
You can reach out to me via LinkedIn
 
 
              
 
    
Top comments (0)