**Course Title:** Mastering TypeScript: From Basics to Advanced Applications **Section Title:** Advanced TypeScript Features **Topic:** Mapped types and conditional types **Introduction to Mapped Types** Mapped types are a powerful feature in TypeScript that allow you to create new types by transforming existing types. They are particularly useful when working with complex data structures, such as objects and arrays. With mapped types, you can easily create new types that represent the result of applying a transformation to an existing type. **Defining Mapped Types** A mapped type is defined using the `as` keyword, followed by a type parameter, an `in` keyword, and the type you want to transform. The basic syntax is as follows: ```typescript type MappedType<T> = { [K in keyof T]: ... }; ``` Here, `T` is the type parameter, and `keyof T` is a type that represents the union of all the keys in the `T` type. The `...` represents the type transformation that you want to apply. **Example: Uppercase Keys** Let's define a mapped type that transforms the keys of an object to uppercase: ```typescript type UppercaseKeys<T> = { [K in keyof T as K['toUpperCase']]: T[K]; }; interface Person { name: string; age: number; } type UppercasePerson = UppercaseKeys<Person>; // type UppercasePerson = { // NAME: string; // AGE: number; // } ``` In this example, we define a mapped type `UppercaseKeys` that transforms the keys of an object to uppercase. We then apply this transformation to the `Person` interface and get a new type `UppercasePerson` with uppercase keys. **Example: Optional Properties** Here's another example that makes all the properties of an object optional: ```typescript type MakeOptional<T> = { [K in keyof T]?: T[K]; }; interface Person { name: string; age: number; } type OptionalPerson = MakeOptional<Person>; // type OptionalPerson = { // name?: string; // age?: number; // } ``` **Introduction to Conditional Types** Conditional types are another advanced feature in TypeScript that allow you to create types that depend on a condition. They are useful when you need to define a type that varies depending on a specific condition. **Defining Conditional Types** A conditional type is defined using the `extends` keyword, followed by a condition, a question mark, and the types that depend on the condition. The basic syntax is as follows: ```typescript type ConditionalType<T> = T extends Condition ? ResultType : AlternateType; ``` **Example: Number or String** Let's define a conditional type that depends on whether a type is a number or a string: ```typescript type IsNumberOrString<T> = T extends number | string ? T : never; type Result1 = IsNumberOrString<number>; // type Result1 = number type Result2 = IsNumberOrString<string>; // type Result2 = string type Result3 = IsNumberOrString<boolean>; // type Result3 = never ``` In this example, we define a conditional type `IsNumberOrString` that depends on whether a type is a number or a string. We then test this type with different input types. **Example: Mapped Type with Conditional Type** Here's an example that combines a mapped type with a conditional type: ```typescript type TransformType<T> = { [K in keyof T]: T[K] extends Function ? never : T[K]; }; interface Person { name: string; age: number; walk(): void; } type TransformedPerson = TransformType<Person>; // type TransformedPerson = { // name: string; // age: number; // } ``` In this example, we define a mapped type `TransformType` that removes properties with function values. We then apply this transformation to the `Person` interface and get a new type `TransformedPerson` without the `walk` method. **Key Takeaways** Mapped types and conditional types are powerful features in TypeScript that allow you to create complex types that depend on specific conditions. By understanding how to use these features, you can write more expressive and robust code. * Use mapped types to transform existing types. * Use conditional types to create types that depend on a condition. * Combine mapped types and conditional types to create complex transformations. **Practice Time** Try defining a mapped type that transforms the values of an object to uppercase. Then, try defining a conditional type that depends on whether a type is an array or an object. **Leave a Comment/Ask for Help** Do you have any questions or need help with the material? Please leave a comment below.