# Advanced TypeScript Patterns: Generics, Utility Types, and More TypeScript has evolved far beyond simple type annotations. In this article, we'll explore advanced patterns that will level up your TypeScript game. ## Generic Constraints and Conditional Types ### Advanced Generic Patterns ```typescript // Generic with constraints interface Lengthwise { length: number; } function logLength(arg: T): T { console.log(arg.length); return arg; } // Generic utility function function pluck(objects: T[], key: K): T[K][] { return objects.map(obj => obj[key]); } ``` ### Conditional Types ```typescript type IsArray = T extends any[] ? true : false; type IsString = T extends string ? true : false; // Practical example: Extract promise type type UnwrapPromise = T extends Promise ? U : T; type Result = UnwrapPromise>; // string type Direct = UnwrapPromise; // number ``` ## Mapped Types and Template Literal Types ### Creating Flexible APIs ```typescript // Mapped type for readonly type Readonly = { readonly [P in keyof T]: T[P]; }; // Template literal types type EventName = `on${Capitalize}`; type ClickEvent = EventName<'click'>; // 'onClick' // Combining with mapped types type Handlers = { [K in keyof T as EventName]: (value: T[K]) => void; }; ``` ## Utility Types in Practice ```typescript // Custom utility types type DeepPartial = T extends object ? { [P in keyof T]?: DeepPartial; } : T; type DeepRequired = T extends object ? { [P in keyof T]-?: DeepRequired; } : T; // Practical application interface Config { api: { endpoint: string; timeout: number; retry: { attempts: number; delay: number; }; }; } type PartialConfig = DeepPartial; ``` ## Type Guards and Narrowing ```typescript // Custom type guard function isString(value: unknown): value is string { return typeof value === 'string'; } // Discriminated unions type Result = { success: true; data: T } | { success: false; error: Error }; function handleResult(result: Result) { if (result.success) { // TypeScript knows result.data exists console.log(result.data); } else { // TypeScript knows result.error exists console.error(result.error); } } ``` ## Conclusion These advanced TypeScript patterns help you build more type-safe and maintainable applications. Practice using them in your projects to become more proficient with TypeScript's powerful type system.