Article Categories
- All Categories
-
Data Structure
-
Networking
-
RDBMS
-
Operating System
-
Java
-
MS Excel
-
iOS
-
HTML
-
CSS
-
Android
-
Python
-
C Programming
-
C++
-
C#
-
MongoDB
-
MySQL
-
Javascript
-
PHP
-
Economics & Finance
Selected Reading
Can we re-throw errors in JavaScript? Explain.
Yes, JavaScript allows you to re-throw errors after catching them using the throw statement inside a catch block. This technique is useful for conditional error handling, logging, or passing errors up the call stack.
What is Re-throwing?
Re-throwing means catching an error, performing some operation (like logging or validation), and then throwing the same or a new error to be handled elsewhere.
Basic Syntax
try {
// Code that may throw an error
} catch (error) {
// Handle or log the error
if (shouldRethrow) {
throw error; // Re-throw the original error
}
// Or throw a new error
throw new Error("Custom message");
}
Example 1: Simple Re-throwing
function processValue(value) {
try {
if (value
Caught error: Negative value not allowed
Error handled locally
---
Caught error: Negative value not allowed
Value too negative, re-throwing...
Final catch: Negative value not allowed
Example 2: Conditional Re-throwing with Input Validation
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Re-throw Errors Example</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
.result { margin: 10px 0; padding: 10px; background: #f0f0f0; }
.error { color: red; }
.success { color: green; }
</style>
</head>
<body>
<h1>Re-throw Errors in JavaScript</h1>
<input type="number" id="numberInput" placeholder="Enter a number">
<button onclick="validateNumber()">Validate</button>
<div id="result" class="result"></div>
<script>
function validateNumber() {
const input = document.getElementById('numberInput');
const result = document.getElementById('result');
const value = parseInt(input.value);
try {
checkNumber(value);
result.innerHTML = '<span class="success">? Number is valid!</span>';
} catch (error) {
result.innerHTML = '<span class="error">? ' + error.message + '</span>';
}
}
function checkNumber(num) {
try {
if (isNaN(num)) {
throw new Error("Not a valid number");
}
if (num < 0) {
throw new Error("Number is negative");
}
console.log("Number passed initial validation:", num);
} catch (error) {
console.log("Caught in checkNumber:", error.message);
// Re-throw for critical errors
if (isNaN(num)) {
console.log("Re-throwing: Invalid input");
throw error;
}
// Handle negative numbers locally but re-throw if too negative
if (num < -100) {
console.log("Re-throwing: Extremely negative");
throw new Error("Number too negative: " + num);
}
console.log("Handled locally: Minor negative number");
throw new Error("Negative numbers not allowed");
}
}
</script>
</body>
</html>
Common Use Cases
| Scenario | Action | Example |
|---|---|---|
| Logging errors | Log then re-throw | API calls with error tracking |
| Conditional handling | Handle some, re-throw others | Validation with severity levels |
| Error transformation | Catch and throw new error | Convert technical errors to user-friendly messages |
Key Points
- Use
throw errorto re-throw the original error object - Use
throw new Error(message)to create a new error - Re-throwing allows errors to bubble up the call stack
- Useful for logging errors while still propagating them
- Essential for middleware and error handling layers
Conclusion
Re-throwing errors in JavaScript provides flexible error handling by allowing you to process errors conditionally while still propagating them when necessary. This technique is essential for building robust applications with proper error management.
Updated on: 2026-03-15T23:18:59+05:30
256 Views
Advertisements