Suggest an edit

Improve this article

Refine the answer for “What is an intersection type?”. 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)

## What is an **Intersection Type**

An **intersection type** combines **several types into one**,
creating a type that **contains all the properties** and **the requirements of each** of them.

> In simpler terms:
> `A & B` means: an object must match **both type A and type B at the same time**.

---

## Example 1. Intersecting two objects

```javascript
type User = { name: string };
type Contact = { email: string };

type UserWithContact = User & Contact;

const person: UserWithContact = {
  name: "Tim",
  email: "tim@example.com",
};
```

`UserWithContact` now **combines** the fields of both types:

- `name` from `User`
- `email` from `Contact`

---

## Example 2. Intersecting interfaces

```javascript
interface A { a: number }
interface B { b: string }

type AB = A & B;

const value: AB = { a: 10, b: "hello" };
```

> You can use this with either `type` or `interface` - the result is the same.

---

## Example 3. Using it in functions

Sometimes you need to type parameters that satisfy **several constraints** at once:

```javascript
type CanLog = { log: () => void };
type CanError = { error: (msg: string) => void };

function handleLogger(service: CanLog & CanError) {
  service.log();
  service.error("Something went wrong");
}

const logger = {
  log: () => console.log("OK"),
  error: (msg: string) => console.error(msg),
};

handleLogger(logger); // the object implements both interfaces
```

---

## Example 4. Intersecting with primitives

TypeScript allows you to intersect even primitive types,
but the result can be **never reachable** (`never`):

```javascript
type A = string;
type B = number;

type C = A & B; // impossible - string and number do not intersect
// type C = never
```

> Intersecting incompatible types produces `never`.

---

## Example 5. Intersecting union types

Intersection also applies to unions (`|`):

```javascript
type A = { a: number } | { b: number };
type B = { a: number } | { c: number };

type Intersection = A & B;
// Result: { a: number } | ({ a: number } & { c: number }) | ({ b: number } & { a: number }) | ...
```

> In real practice this is rarely written by hand,
> but TypeScript can compute the resulting type precisely.

---

## Example 6. Inheritance through intersection

Sometimes it is simpler to use `&` instead of `extends`:

```javascript
type Base = { id: number };
type Timestamps = { createdAt: Date; updatedAt: Date };

type Entity = Base & Timestamps;

const post: Entity = {
  id: 1,
  createdAt: new Date(),
  updatedAt: new Date(),
};
```

> This lets you build **composite types** out of modules, like "mixins" in OOP.

---

## Intersection vs Union

| Operator | Name | Description |
|---|---|---|
| `A \| B` | **Union** |
| `A & B` | **Intersection** | The value must be **A and B at the same time** |

Comparison example:

```javascript
type Dog = { bark: () => void };
type Cat = { meow: () => void };

type PetUnion = Dog | Cat; // either a dog or a cat
type PetBoth  = Dog & Cat; // both a dog and a cat at the same time
```

---

## Example 7. Intersecting with generic types

```javascript
function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

const result = merge({ name: "Tim" }, { age: 25 });
// type of result: { name: string; age: number }
```

> A very common real-world technique: a `merge` function returns the intersection of two objects.

---

## Important to remember

- Intersection combines **properties**, not values.
- If the same property has different types in the intersection, TS raises an incompatibility error:

```javascript
type A = { id: number };
type B = { id: string };
type C = A & B; // Type 'string' is not assignable to type 'number'
```

---

## Summary

| Property | Description |
|---|---|
| Operator | `&` |
| Name | Intersection Type |
| Meaning | "Both at the same time" |
| Result | A type that includes all the properties |
| Opposite | ` |
| Common use | Type composition, mixins, combining interfaces |

---

### Simple definition:

> An **intersection type** (`A & B`) is a type
> that combines **all the fields and requirements** from `A` and `B`.
>
> An object of such a type must **match both** at the same time.

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

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.