no-explicit-any
Disallow the
any
type.
Extending "plugin:@typescript-eslint/recommended"
in an ESLint configuration enables this rule.
Some problems reported by this rule are automatically fixable by the --fix
ESLint command line option.
Some problems reported by this rule are manually fixable by editor suggestions.
The any
type in TypeScript is a dangerous "escape hatch" from the type system.
Using any
disables many type checking rules and is generally best used only as a last resort or when prototyping code.
This rule reports on explicit uses of the any
keyword as a type annotation.
Preferable alternatives to any
include:
- If the type is known, describing it in an
interface
ortype
- If the type is not known, using the safer
unknown
type
TypeScript's
--noImplicitAny
compiler option prevents an impliedany
, but doesn't preventany
from being explicitly used the way this rule does.
module.exports = {
"rules": {
"@typescript-eslint/no-explicit-any": "error"
}
};
Try this rule in the playground ↗
Examples
- ❌ Incorrect
- ✅ Correct
const age: any = 'seventeen';
Open in Playgroundconst ages: any[] = ['seventeen'];
Open in Playgroundconst ages: Array<any> = ['seventeen'];
Open in Playgroundfunction greet(): any {}
Open in Playgroundfunction greet(): any[] {}
Open in Playgroundfunction greet(): Array<any> {}
Open in Playgroundfunction greet(): Array<Array<any>> {}
Open in Playgroundfunction greet(param: Array<any>): string {}
Open in Playgroundfunction greet(param: Array<any>): Array<any> {}
Open in Playgroundconst age: number = 17;
Open in Playgroundconst ages: number[] = [17];
Open in Playgroundconst ages: Array<number> = [17];
Open in Playgroundfunction greet(): string {}
Open in Playgroundfunction greet(): string[] {}
Open in Playgroundfunction greet(): Array<string> {}
Open in Playgroundfunction greet(): Array<Array<string>> {}
Open in Playgroundfunction greet(param: Array<string>): string {}
Open in Playgroundfunction greet(param: Array<string>): Array<string> {}
Open in PlaygroundOptions
This rule accepts the following options:
type Options = [
{
/** Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type. */
fixToUnknown?: boolean;
/** Whether to ignore rest parameter arrays. */
ignoreRestArgs?: boolean;
},
];
const defaultOptions: Options = [
{ fixToUnknown: false, ignoreRestArgs: false },
];
fixToUnknown
By default, this rule will not provide automatic ESLint fixes: only opt-in suggestions.
Switching types to unknown
is safer but is likely to cause additional type errors.
Enabling { "fixToUnknown": true }
gives the rule an auto-fixer to replace : any
with : unknown
.
ignoreRestArgs
A boolean to specify if arrays from the rest operator are considered okay. false
by default.
The examples below are incorrect when {ignoreRestArgs: false}
, but correct when {ignoreRestArgs: true}
.
function foo1(...args: any[]): void {}
function foo2(...args: readonly any[]): void {}
function foo3(...args: Array<any>): void {}
function foo4(...args: ReadonlyArray<any>): void {}
declare function bar(...args: any[]): void;
const baz = (...args: any[]) => {};
const qux = function (...args: any[]) {};
type Quux = (...args: any[]) => void;
type Quuz = new (...args: any[]) => void;
interface Grault {
(...args: any[]): void;
}
interface Corge {
new (...args: any[]): void;
}
interface Garply {
f(...args: any[]): void;
}
Open in PlaygroundWhen Not To Use It
any
is always a dangerous escape hatch.
Whenever possible, it is always safer to avoid it.
TypeScript's unknown
is almost always preferable to any
.
However, there are occasional situations where it can be necessary to use any
.
Most commonly:
- If your project isn't fully onboarded to TypeScript yet,
any
can be temporarily used in places where types aren't yet known or representable - If an external package doesn't yet have typings and you want to use
any
pending adding a.d.ts
for it - You're working with particularly complex or nuanced code that can't yet be represented in the TypeScript type system
You might consider using ESLint disable comments for those specific situations instead of completely disabling this rule.
Related To
Further Reading
- TypeScript
any
type - TypeScript's
unknown
type - TypeScript
any
type documentation - TypeScript
unknown
type release notes