Summary
This chapter explains how union types allow a variable to be one of several specified types and how intersection types combine multiple types so that a value must satisfy all of them.

General domain of usage
Data modeling

Union and intersection types in TypeScript allow you to write more flexible and expressive type definitions. A **union type** uses the pipe symbol (`|`) to indicate that a value can be one of several types.

An **intersection type** uses the ampersand (`&`) to combine multiple types into one. The resulting type must satisfy all the properties of each type involved.

// Union type: a value can be a string OR a number
let userId: string | number;

userId = "abc123";
console.log("User ID (string):", userId);

userId = 42;
console.log("User ID (number):", userId);

// Intersection type: a value must have properties of both types
type Name = { name: string };
type Age = { age: number };
type Person = Name & Age;

const person: Person = {
  name: "Alice",
  age: 30,
};

console.log("Person (intersection type):", person);

In the code above, `userId` can be either a `string` or a `number`, so you can assign both `"abc123"` and `42` to it. This is helpful when a variable might accept more than one type, such as an ID that could be stored as a string or a number.

In the code sample, the `Person` type is an intersection of the `Name` and `Age` types, so an object of type `Person` must have both a `name` property of type `string` and an `age` property of type `number`. This is useful when you want to combine several type definitions into a single, more specific one.

Choosing between union and intersection types depends on your needs: use a union when a value can be one of several types, and use an intersection when a value must satisfy all the types at once.

Which scenario is best for using a union type instead of an intersection type?

Explore TypeScript's type system, guiding you from the basics of primitive types to advanced concepts like type inference, narrowing, and safe handling of any and unknown. Learn how TypeScript makes JavaScript code safer, more robust, and easier to maintain.

Explore how TypeScript brings structure and safety to JavaScript through its type system. Define clear type annotations, check your code for errors at compile time, and work confidently with primitive and special types to build a solid foundation.

Build expressive data models using TypeScript's complex type tools. Combine and organize information with objects, arrays, tuples, unions, intersections, and literal types to represent real-world structures in code.

Take advantage of TypeScript's intelligent type system to make your code safer and cleaner. Let the compiler infer types automatically, narrow them through control flow, and apply best practices using any, unknown, and type assertions for advanced safety and flexibility.

Union and Intersection Types