TypeScript Utility Types
TypeScript comes with a large number of types that can help with some common type manipulation, usually referred to as utility types.
This chapter covers the most popular utility types.
Partial
Partial changes all the properties in an object to be optional.
Example
            interface Point {
              x: number;
              y: number;
            }
            
            let pointPart: Partial<Point> = {}; // `Partial` allows x and y to be optional
pointPart.x = 10;
        
        Try it Yourself »
    Required
Required changes all the properties in an object to be required.
Example
            interface Car {
              make: string;
              model: string;
              mileage?: number;
            }
            
            let myCar: Required<Car> = {
              make: 'Ford',
              model: 'Focus',
              mileage: 12000 // `Required` forces mileage to be defined
            };
        
        Try it Yourself »
    Record
Record is a shortcut to defining an object type with a specific key type and value type.
Record<string, number> is equivalent to { [key: string]: number }
Get Certified!
$95 ENROLL
Omit
Omit removes keys from an object type.
Example
            interface Person {
              name: string;
              age: number;
              location?: string;
            }
            
            const bob: Omit<Person, 'age' | 'location'> = {
              name: 'Bob'
              // `Omit` has removed age and location from the type and they can't be defined here
            };
        
        Try it Yourself »
    Pick
Pick removes all but the specified keys from an object type.
Example
            interface Person {
              name: string;
              age: number;
              location?: string;
            }
            
            const bob: Pick<Person, 'name'> = {
              name: 'Bob'
              // `Pick` has only kept name, so age and location were removed from the type and they can't be defined here
            };
        
        Try it Yourself »
    Exclude
Exclude removes types from a union.
Example
            type Primitive = string | number | boolean
            const value: Exclude<Primitive, string> = true; // a string cannot be used here since Exclude removed it from the type.
        
        Try it Yourself »
    ReturnType
ReturnType extracts the return type of a function type.
Example
            type PointGenerator = () => { x: number; y: number; };
            const point: ReturnType<PointGenerator> = {
              x: 10,
              y: 20
            };
        
        Try it Yourself »
    Parameters
Parameters extracts the parameter types of a function type as an array.
Example
            type PointPrinter = (p: { x: number; y: number; }) => void;
            const point: Parameters<PointPrinter>[0] = {
              x: 10,
              y: 20
            };
        
        Try it Yourself »