Avoid the any Type

Why this matters

any is not a type — it is an escape hatch that disables TypeScript's entire type system for that value. The danger is that any is contagious:

const data: any = fetchData();
const name = data.user.name; // no error — even if data has no user property
processName(name); // name is now also any inside processName

One any at the boundary silently disables type checking for every function that touches the value. TypeScript won't warn you about misspelled properties, wrong argument types, or null access. You only discover the problem at runtime — usually in production.

Codebases with widespread any usage get the worst of both worlds: they pay the cost of TypeScript (compilation step, type annotations, .ts files) but receive none of the safety benefits.

The rule

Never use any. For every any in your code, there is a safer alternative:

• If you don't know the type yet, use unknown and narrow it
• If it can be multiple types, use a union type
• If it's a generic container, use a type parameter
• If it comes from an external API, define an interface for the response shape

Bad example

// BAD: any disables all type safety
function processApiResponse(response: any) {
  // No errors — TypeScript trusts you completely
  const users = response.data.users; // could be undefined
  return users.map((u: any) => u.naem); // typo not caught
}
 
// BAD: any in catch blocks
try {
  await fetchData();
} catch (error: any) {
  console.log(error.mesage); // typo not caught
}

Good example

// GOOD: define the shape
interface ApiResponse {
  data: {
    users: User[];
  };
}
 
function processApiResponse(response: ApiResponse) {
  const users = response.data.users; // fully typed
  return users.map((u) => u.name); // typo would be caught
}
 
// GOOD: use unknown for catch blocks
try {
  await fetchData();
} catch (error: unknown) {
  if (error instanceof Error) {
    console.log(error.message); // type-safe access
  }
}

How to detect

Search for explicit any annotations:

grep -n ": any" --include="*.ts" --include="*.tsx" -r src/
grep -n "as any" --include="*.ts" --include="*.tsx" -r src/

Use the @typescript-eslint/no-explicit-any rule to enforce this automatically:

{
  "rules": {
    "@typescript-eslint/no-explicit-any": "error"
  }
}

Remediation

1. Enable @typescript-eslint/no-explicit-any as an error
2. Replace any parameters with proper interfaces or unknown
3. Replace any return types with explicit return types
4. Replace as any casts with proper type narrowing
5. For third-party libraries without types, use @types/* packages or write declaration files

References

• TypeScript Handbook: any
• typescript-eslint: no-explicit-any
• Matt Pocock: Why unknown is better than any