**Course Title:** Mastering TypeScript: From Basics to Advanced Applications **Section Title:** Working with Types and Interfaces **Topic:** Understanding the concept of union and intersection types. **Introduction:** In the previous topics, we explored the basics of TypeScript, control structures, functions, and working with types and interfaces. Now, it's time to dive deeper into the world of TypeScript types and explore two powerful concepts: union and intersection types. These concepts will help you create more robust and maintainable code by allowing you to define more complex and specific types. **Union Types:** A union type is a way to combine two or more types into a single type that accepts any of the combined types. Union types are denoted using the `|` operator. For example: ```typescript type StringOrNumber = string | number; let value: StringOrNumber = 'Hello'; // Okay value = 42; // Okay value = true; // Error ``` In the above example, the `StringOrNumber` type is a union of `string` and `number` types. This means that the `value` variable can hold either a string or a number value. **Practical Use Case:** Union types are particularly useful when working with APIs or external data sources where the data can be of different types. For example: ```typescript type StatusCode = 200 | 400 | 500; function handleResponse(statusCode: StatusCode) { if (statusCode === 200) { console.log('Request successful'); } else if (statusCode === 400) { console.log('Bad request'); } else if (statusCode === 500) { console.log('Server error'); } } ``` In the above example, the `StatusCode` type is a union of three possible status codes (200, 400, and 500). The `handleResponse` function takes a `StatusCode` as an argument and performs different actions based on the status code. **Intersection Types:** An intersection type is a way to combine two or more types into a single type that requires all the properties of the combined types. Intersection types are denoted using the `&` operator. For example: ```typescript type Rectangle = { width: number; height: number; }; type Circle = { radius: number; }; type Shape = Rectangle & Circle; const shape: Shape = { width: 10, height: 20, radius: 5 }; ``` In the above example, the `Shape` type is an intersection of `Rectangle` and `Circle` types. This means that the `shape` object must have all the properties of both `Rectangle` and `Circle` types. **Practical Use Case:** Intersection types are particularly useful when working with legacy code or when integrating multiple systems that require different types of data. For example: ```typescript type Address = { street: string; city: string; }; type Contact = { email: string; phone: string; }; type Customer = Address & Contact; const customer: Customer = { street: '123 Main St', city: 'Anytown', email: 'john@example.com', phone: '555-555-5555' }; ``` In the above example, the `Customer` type is an intersection of `Address` and `Contact` types. This means that the `customer` object must have all the properties of both `Address` and `Contact` types. **Conclusion:** Union and intersection types are powerful tools in TypeScript that allow you to create more robust and maintainable code. By understanding these concepts, you can write more expressive and specific types that help you catch errors at compile-time rather than runtime. **Additional Resources:** * [TypeScript Documentation - Union Types](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types) * [TypeScript Documentation - Intersection Types](https://www.typescriptlang.org/docs/handbook/advanced-types.html#intersection-types) **Exercise:** * Create a union type that represents a `Person` with either a `name` property or an `id` property. * Create an intersection type that represents a `Car` with properties from both `Vehicle` and `Automobile` types. **Do you have any questions or need help with the concepts covered in this topic? Please leave a comment below!** Next Topic: [Understanding classes, constructors, and inheritance in TypeScript](#)