Union Types and Intersection Types

I. Union Types

A union type indicates that a variable can be one of several types, commonly used to represent values that may exist in multiple states.

  • Syntax: type A = string | number | boolean
  • Application Scenarios:
    • Enum Values: type Color = 'RED' | 'GREEN' | 'BLUE'
    • Variable Arguments: function print(value: string | number) { ... }
  • Characteristics:
    • Type Assertion: Use the as keyword for explicit type casting, such as let x: number = '123' as number.
    • Type Inference: TypeScript automatically infers the type based on assignment, such as let y = 42;.

II. Intersection Types

An intersection type indicates that an object must satisfy the requirements of multiple types simultaneously, often used in inheritance relationships.

  • Syntax: interface A { prop: number } interface B { prop: string } type C = A & B
  • Application Scenarios:
    • Inheriting Interfaces: class D extends A & B
    • Union Conditions: interface E extends A & B { new(): C }
  • Characteristics:
    • Type Merging: Intersection types merge all constraints, such as type F = A & B & { age: number }.
    • Type Safety: Enforce type safety using the as keyword for explicit casting, such as let x: A & B = { prop: 'hello' }.

III. Comparison Between Union and Intersection Types

Feature Union Type Intersection Type
Purpose Represents optional states Represents required conditions
Syntax ` `
Flexibility High Low
Type Checking Automatic inference Requires explicit definition
Applicable Scenarios Enums, variable arguments Inheriting interfaces, union conditions

IV. Common Errors and Optimizations

  • Error 1: Undefined type definitions leading to type conflicts, such as type G = A & B & { name: string }.
  • Error 2: Overuse of union types resulting in excessive type checking overhead; consider using interfaces or enums as alternatives.
  • Optimization Strategies:
    • Simplify type casting using the as keyword.
    • Construct inheritance relationships via extends.
    • Apply Partial or Required for dimensionality reduction on complex types.

V. Practical Recommendations

  • Union Types: Prioritize enum values or variable arguments to avoid redundant type definitions.
  • Intersection Types: Ensure clear inheritance relationships between interfaces to prevent type conflicts.
  • Tooling Assistance: Leverage TypeScript's type checking tools (such as tsc) to optimize type definitions.
  • Code Standards: Adhere to TypeScript Strict Mode to enhance type safety.

VI. Summary

Union types and intersection types are core components of the TypeScript type system. Proper utilization can significantly improve code flexibility and safety. Understanding their syntax characteristics and application scenarios aids in building more efficient type definitions.