Suggest an edit

Improve this article

Refine the answer for “When to use any?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## When you **CAN** use `any`

Sometimes `any` is genuinely appropriate - as a **temporary tool**, not a permanent solution.

### 1. **When the type is truly unknown (temporarily)**

For example, you are parsing JSON from an external API that has no types yet:

```javascript
let data: any = JSON.parse(response);
```

Later you can replace it with:

```javascript
let data: unknown = JSON.parse(response);
```

and add checks - but at an early stage of development `any` is acceptable.

---

### 2. **During quick debugging or prototyping**

When you are just experimenting with logic or an API, and you need to "get it running somehow".

```javascript
function debug(value: any) {
  console.log("Debug:", value);
}
```

> The main thing is not to forget to later replace `any` with a real type.

---

### 3. **When working with code that has no types**

For example, a library has no `.d.ts` descriptions or is written in JavaScript.

```javascript
const legacyLib: any = require("old-js-lib");
legacyLib.doSomethingWeird();
```

> In this case `any` lets you work without compile errors until you write or install types (`@types/...`).

---

### 4. **When the type is too complex and you know what you are doing**

Sometimes TS's type system cannot handle extremely dynamic structures (for example, deeply nested generics).
Then `any` can be a temporary "bypass" of the compiler:

```javascript
const deepValue: any = getValueFromComplexStructure();
```

> The main thing is to localize the use of `any` and not let it leak "outward".

---

### 5. **In generic logs, tracing, telemetry**

If a function just logs, without changing data, strict typing is not needed:

```javascript
function logEvent(event: any) {
  console.log("EVENT:", event);
}
```

---

## When you **CANNOT** use `any`

Here is where `any` turns from a convenience into a threat.

---

### 1. **In application logic**

If the variables involved in computations have type `any`,
TypeScript stops protecting you from type errors.

```javascript
let user: any = { name: "Tim" };
user(); // Runtime error - TS will not warn you
```

---

### 2. **In API contracts**

If a function is exported and used by other modules, `any` makes it **unpredictable**.

```javascript
function getUser(id: any): any { ... }
```

> Better:
>
> ```javascript
> function getUser(id: number): User { ... }
> ```

---

### 3. **In public libraries**

If you are writing an SDK or an NPM package, `any` kills all the benefit of TypeScript for your users.
They lose autocomplete, hints, and type safety.

---

### 4. **In large projects**

`any` is like a virus: once it enters the type system, it **spreads**.
Example:

```javascript
function process(value: any) {
  return value; // returns any
}

const result = process("test");
result.toFixed(2); // Runtime error, but TS stays silent
```

> Now `result` has also become `any`, and the whole chain loses typing.

---

### 5. **When interacting with the DOM, APIs, and user data**

Type errors often occur there, and `any` hides them.
For example:

```javascript
const el: any = document.getElementById("btn");
el.addEventListener("click", 123); // TS will not complain, but it will break at runtime
```

---

## Summary

| Scenario | Use `any`? | Alternative |
|---|---|---|
| Quick debugging / prototype | Temporarily okay | Replace later with a specific type |
| Library without `.d.ts` | Acceptable | `@types/...` or `unknown` |
| Processing external data | Temporarily | `unknown` + checks |
| API contracts, business logic | Not allowed | Strict interfaces |
| Public libraries | Not allowed | Universal generics |
| Large projects | Not allowed | `unknown` or precise types |

---

## Usage recommendations

- **Localize** `any` - limit its scope (to one variable, not "down the chain").
- **Use** `as Type` if you know the type and TypeScript could not infer it:

```javascript
  const data = JSON.parse(text) as User;
  ```
- **Enable strict flags in tsconfig.json**:

```javascript
  {
    "compilerOptions": {
      "noImplicitAny": true,
      "strictNullChecks": true,
      "strict": true
    }
  }
  ```
-> TypeScript will warn you if type `any` appears implicitly somewhere.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts665 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.