Type System & Type Manipulation Interview Questions
Comprehensive type system & type manipulation interview questions and answers for TypeScript.
Prepare for your next job interview with expert guidance.
Utility types are built-in types that facilitate common type transformations. Common utility types include: Partial<T> (makes all properties optional), Required<T> (makes all properties required), Readonly<T> (makes all properties readonly), Pick<T,K> (constructs type with subset of properties), Record<K,T> (constructs type with properties of keys K and type T), Exclude<T,U>, and Extract<T,U>.
Discriminated unions are union types where each member has a common property (the discriminant) that TypeScript can use to narrow down the specific type. Example: type Shape = { kind: 'circle'; radius: number } | { kind: 'square'; sideLength: number }. The 'kind' property helps TypeScript determine which shape type is being used.
The infer keyword is used in conditional types to extract and infer type parameters from other types. It's commonly used for complex type manipulations and for extracting types from functions, promises, and arrays. Example: type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any; This extracts the return type of a function type.
Template literal types combine literal types through template literal strings. They allow creating new string literal types by concatenating existing ones. Example: type EmailLocale = 'en' | 'fr' | 'de'; type EmailType = 'welcome' | 'goodbye'; type EmailTemplate = `${EmailLocale}_${EmailType}`; // Creates types like 'en_welcome', 'fr_goodbye', etc.
Omit<T, K> constructs a type by picking all properties from T and then removing those in K. It's useful for creating new types that exclude certain properties. Example: type Person = { name: string; age: number; email: string }; type PersonWithoutEmail = Omit<Person, 'email'>; // Results in { name: string; age: number }
Recursive types are types that reference themselves in their definition. They're useful for representing tree-like data structures or nested objects. Example: type TreeNode<T> = { value: T; children?: TreeNode<T>[] }; This creates a type that can represent a tree structure where each node can have child nodes of the same type.
ReturnType<T> extracts the return type of a function type T. It's useful when you want to reference the return type of a function without explicitly defining it. Example: function createUser() { return { id: 1, name: 'John' } }; type User = ReturnType<typeof createUser>; // Type will be { id: number; name: string }
Literal type widening occurs when TypeScript widens a literal type to its base type. Const assertions (using 'as const') prevent this widening and create readonly literal types. Example: let x = 'hello' // type is string (widened), but let x = 'hello' as const // type is 'hello' (literal). Const assertions are useful for creating precise literal types.
Record<K,T> creates an object type with properties of type K and values of type T, while index signatures use [key: K]: T syntax. Record is more strict as it requires all keys to exist, while index signatures allow any key. Example: type StringMap = Record<string, string> vs type StringDict = { [key: string]: string }.
TypeScript's typeof operator can be used in type contexts to reference the type of a variable or property. Unlike JavaScript's typeof which returns a string at runtime, TypeScript's typeof is used in type positions to create type references. Example: const point = { x: 0, y: 0 }; type Point = typeof point; // creates a type with shape { x: number, y: number }
Type widening is when TypeScript expands a narrow type to a more general one (like expanding a literal type to its base type). Type narrowing is the opposite - restricting a type to a more specific one through control flow analysis, type guards, or assertions. Understanding these concepts is crucial for working with TypeScript's type system effectively.
Type aliases are created using the type keyword followed by a name and type definition. They can represent simple types, unions, intersections, tuples, or complex object types. Example: type Point = { x: number; y: number }; type ID = string | number; They provide a way to give meaningful names to types and reduce repetition.
Pick<T, K> constructs a type by picking a set of properties K from type T. It's useful when you want to create a new type with only specific properties from an existing type. Example: type Person = { name: string; age: number; address: string }; type NameAge = Pick<Person, 'name' | 'age'>; // Results in { name: string; age: number }
Readonly<T> creates a new type where all properties of T are readonly. It's useful when you want to ensure that properties can't be modified after initialization. Example: type Point = { x: number; y: number }; type ReadonlyPoint = Readonly<Point>; This prevents accidental mutations of object properties.
Lookup types allow you to extract the type of a property from another type using indexed access notation. Example: type Person = { age: number; name: string }; type AgeType = Person['age']; // type AgeType = number. This is useful when you need to reference the type of a specific property from an existing type.
Mapped types allow you to create new types based on existing ones by transforming each property in the same way. They use the syntax { [P in keyof T]: NewType }. Common examples include making all properties optional (Partial<T>), readonly (Readonly<T>), or nullable. This is powerful for type transformations and creating utility types.
Conditional types select one of two possible types based on a condition expressed as a type relationship test. They use the syntax T extends U ? X : Y. They're powerful for creating complex type logic and are often used with generics. For example: type NonNullable<T> = T extends null | undefined ? never : T.
The keyof operator takes an object type and produces a string or numeric literal union of its keys. It's useful for creating types that depend on the properties of other types. For example: type Point = { x: number; y: number }; type PointKey = keyof Point; // type PointKey = 'x' | 'y'
Intersection types combine multiple types into one using the & operator. The resulting type has all properties from all the constituent types. For example: type Employee = Person & { employeeId: number }. This creates a new type that must satisfy all the requirements of both Person and the object with employeeId.
Index types allow you to create objects with dynamic property names while maintaining type safety. Index signatures use the syntax [key: string]: ValueType to specify that an object can have any number of properties with names of type string (or number) and values of ValueType. Example: type Dictionary = { [key: string]: string }; This allows any string keys with string values.
The unknown type is a type-safe alternative to any. While any allows all operations without type checking, unknown requires type checking or assertion before operations can be performed. This makes unknown safer than any because it forces you to perform type checks before using the value. It's ideal for representing values whose type you don't know at compile time.
Type assertions tell TypeScript to treat a value as a specific type using 'as' or angle bracket syntax. Type declarations explicitly define the type using ':'. Assertions are used when you know more about a type than TypeScript can infer, while declarations are used to specify what type a variable should have. Example: let str1 = value as string; (assertion) vs let str2: string = value; (declaration)
Extract<T, U> extracts from T all types that are assignable to U. It's useful for filtering union types. Example: type Numbers = Extract<string | number | boolean, number>; // Results in type Numbers = number. This utility helps create new types by filtering existing union types based on assignability.
