Skip to main content

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 or type
  • If the type is not known, using the safer unknown type

TypeScript's --noImplicitAny compiler option prevents an implied any, but doesn't prevent any from being explicitly used the way this rule does.

.eslintrc.cjs
module.exports = {
  "rules": {
    "@typescript-eslint/no-explicit-any": "error"
  }
};

Try this rule in the playground ↗

Examples​

const age: any = 'seventeen';
Open in Playground
const ages: any[] = ['seventeen'];
Open in Playground
const ages: Array<any> = ['seventeen'];
Open in Playground
function greet(): any {}
Open in Playground
function greet(): any[] {}
Open in Playground
function greet(): Array<any> {}
Open in Playground
function greet(): Array<Array<any>> {}
Open in Playground
function greet(param: Array<any>): string {}
Open in Playground
function greet(param: Array<any>): Array<any> {}
Open in Playground

Options​

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 Playground

When 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.

Further Reading​

Resources​