Suggest an edit

Improve this article

Refine the answer for “The typeof operator in JavaScript”. 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)

**`typeof` is an operator that, while the program runs, returns a string describing the type of a value.** In TypeScript the `typeof` keyword used in type position means something else: at compile time it extracts the type of a variable, function or class.

## Theory

### TL;DR
- In JavaScript `typeof` works at runtime and returns a **string**, not the type itself.
- Possible results: `"number"`, `"string"`, `"boolean"`, `"undefined"`, `"object"`, `"function"`, `"symbol"`, `"bigint"`.
- `typeof null` gives `"object"`, a well known historical bug in the language.
- Arrays are technically objects, so `typeof []` also gives `"object"`.
- `typeof` on an undeclared variable does not throw: it is the safe way to check whether it exists.
- In TypeScript `typeof` in type position works at compile time and returns a type.

### Quick example
```javascript
console.log(typeof 42);           // "number"
console.log(typeof 'hello');      // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof { a: 1 });     // "object"
console.log(typeof [1, 2, 3]);    // "object" (arrays are objects!)
console.log(typeof null);         // "object" (historical language bug)
console.log(typeof function(){}); // "function"
```

> The operator returns a **string**, not the type itself.

### What typeof actually reports

| Case | Result | Comment |
| --- | --- | --- |
| `typeof x` (when `x` is not declared) | `"undefined"` | Does not throw, so it is safe |
| `typeof null` | `"object"` | Historical bug in JS |
| `typeof []` | `"object"` | Arrays are technically objects |
| `typeof function() {}` | `"function"` | A special subtype of object |

The main thing to remember: `typeof` cannot tell an array apart from a plain object or from `null`. For arrays use `Array.isArray(x)`, and check `null` with a direct comparison `x === null`.

### Safely checking whether a variable exists
```javascript
if (typeof user === 'undefined') {
  console.log('user is not defined');
}
```

Here `typeof` lets you check for a variable **without an error**, even if it was never declared. Any other reference to an undeclared identifier would immediately throw a `ReferenceError`.

### typeof in TypeScript
And here is the key difference.

> In **TypeScript** `typeof` is an **operator that works with types at compile time**, and it returns a **type**, not a string.

That is, it **does not evaluate the value**, it **takes the type of a variable or expression** so that the type can be used in annotations.

```typescript
const user = {
  name: 'Tim',
  age: 30
};

// take the type of the user object
type UserType = typeof user;

// equivalent to:
type UserType = {
  name: string;
  age: number;
};
```

> Unlike JavaScript, `typeof` here **does not run any code**, it simply **extracts the type** of a variable, function or class.

### typeof together with ReturnType
```typescript
function makeUser() {
  return { name: 'Alice', active: true };
}

type User = ReturnType<typeof makeUser>;
// User = { name: string; active: boolean }
```

> Here `typeof makeUser` gives the **type of the function**, and `ReturnType<...>` gives the type of the value it returns.

### Key differences between JS and TS

| Aspect | `typeof` in JavaScript | `typeof` in TypeScript |
| --- | --- | --- |
| When it works | At runtime | At compile time |
| What it returns | A type string (`"number"`, `"object"`, ...) | The type of a variable, function or object |
| Usable in conditions | Yes | No, it only works inside types |
| Example | `typeof x === 'string'` | `type T = typeof x` |
| If `x` is not declared | No error | Compilation error |

### A contrasting example
```javascript
// JavaScript
let a = 10;
console.log(typeof a); // "number"
```

```typescript
// TypeScript
let a = 10;
type AType = typeof a; // AType = number
```

> The first returns a string **at runtime**, the second creates a **type** at compile time.

### Common mistakes
- **Expecting `"array"` from `typeof []`.** No such result exists, an array is an object. Use `Array.isArray(value)`.
- **Relying on `typeof value === 'object'` to detect an object.** `null` passes that check too. The correct form is `value !== null && typeof value === 'object'`.
- **Confusing the string with the type.** In JS `typeof x` is always a string, so `typeof x === Number` is never true, you need `typeof x === 'number'`.
- **Thinking TypeScript's `typeof` checks anything at runtime.** In type position it disappears after compilation and does not affect the emitted JavaScript.
- **Forgetting that `typeof` is the only safe way to touch an undeclared variable.** `if (user === undefined)` throws a `ReferenceError`, while `if (typeof user === 'undefined')` does not.

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

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.