unnecessaryCatches

Reports catch clauses that only rethrow the caught error without modification.

✅ This rule is included in the ts logical and logicalStrict presets.

A catch clause that only rethrows the caught error without any modification or additional logic serves no purpose. It adds unnecessary code complexity and performance overhead without providing any benefit. Errors will propagate naturally without the catch clause, making it redundant.

async function 
function fetchData(): Promise<Response>
fetchData() {
  try {
    return await 
function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
fetch("/api/data");
  } catch (
function (local var) error: unknown
error) {
    throw 
function (local var) error: unknown
error;
  }
}

function 
function processFile(path: string): any
processFile(
path: string
path: string) {
  try {
    const 
const content: string
content = 
const readFileSync: (path: string) => string
readFileSync(
path: string
path);
    return 
var JSON: JSON
An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
JSON.
JSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): any
Converts a JavaScript Object Notation (JSON) string into an object.
@param ― text A valid JSON string.
@param ― reviver A function that transforms the results. This function is called for each member of the object.
If a member contains nested objects, the nested objects are transformed before the parent object is.
@throws ― {SyntaxError} If text is not valid JSON.
parse(
const content: string
content);
  } catch (
function (local var) exception: unknown
exception) {
    throw 
function (local var) exception: unknown
exception;
  }
}

async function 
function fetchData(): Promise<Response>
fetchData() {
  try {
    return await 
function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
fetch("/api/data");
  } catch (
function (local var) error: unknown
error) {
    
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr
If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
@since ― v0.1.100
error("Failed to fetch data:", 
function (local var) error: unknown
error);
    throw 
function (local var) error: unknown
error;
  }
}

function 
function processFile(path: string): any
processFile(
path: string
path: string) {
  try {
    const 
const content: string
content = 
const readFileSync: (path: string) => string
readFileSync(
path: string
path);
    return 
var JSON: JSON
An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
JSON.
JSON.parse(text: string, reviver?: (this: any, key: string, value: any) => any): any
Converts a JavaScript Object Notation (JSON) string into an object.
@param ― text A valid JSON string.
@param ― reviver A function that transforms the results. This function is called for each member of the object.
If a member contains nested objects, the nested objects are transformed before the parent object is.
@throws ― {SyntaxError} If text is not valid JSON.
parse(
const content: string
content);
  } catch (
function (local var) exception: unknown
exception) {
    throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error(`Failed to process file ${
path: string
path}`, { 
ErrorOptions.cause?: unknown
cause: 
function (local var) exception: unknown
exception });
  }
}

Options

This rule is not configurable.

When Not To Use It

If you have a specific need to explicitly catch and rethrow errors for documentation purposes or to maintain consistent code structure across multiple try-catch blocks, you might choose to disable this rule. However, in most cases, removing unnecessary catch clauses improves code clarity and maintainability.

Equivalents in Other Linters

Made with ❤️‍🔥 around the world by the Flint team and contributors.

unnecessaryCatches

Examples

Options

When Not To Use It

Further Reading

Equivalents in Other Linters