TypeScript interview questions and answers

Both describe object shapes. Interfaces can be reopened and merged (declaration merging) and extended with extends, which suits public object contracts and library types. Type aliases can name anything: unions, intersections, tuples, primitives, mapped and conditional types. Many teams use interfaces for objects and types for everything else; consistency matters more than the choice.

Generics are type parameters that let one function, class or type work with many types while keeping them connected, such as function first<T>(items: T[]): T | undefined. Constraints (<T extends { id: string }>) limit what is accepted. They give reuse without losing type safety, unlike any.

any switches off type checking for a value; it spreads unsafety. unknown accepts anything but forces you to narrow it (typeof, instanceof, a type guard or a schema) before use, so it is the safe choice for untrusted data. never is the type with no values: functions that never return, and exhaustive checks where all cases are handled.

TypeScript refines a union type within a branch based on checks: typeof, instanceof, in, equality, truthiness, and discriminant properties (if (shape.kind === 'circle')). Custom type guards (x is Cat) and assertion functions extend it. Narrowing is what makes unions practical.

Declare a props type or interface and annotate the parameter: function Button({ label, onClick }: { label: string; onClick: () => void }). Use React.ComponentProps<'button'> to extend native element props, children: React.ReactNode for content, and generics for components like typed lists.

Types built from string patterns, such as on${Capitalize<Name>}, which turns a Name union like 'click' | 'focus' into 'onClick' | 'onFocus'. Combined with unions they generate many string types, and with infer they can parse strings at the type level, for example extracting route params from a path.

Use overloads for a fixed set of signatures, generics with constraints (<T extends { id: string }>) when the output depends on the input type, or unions with narrowing inside. Prefer generics over overloads when one signature can express the relationship.

A union of object types that share a literal 'tag' property, such as type Result = { status: 'ok'; data: User } | { status: 'error'; error: string }. Checking status narrows to one member, and a switch with a never default makes the compiler flag any unhandled case when a new member is added.

Partial<T> (all optional), Required<T>, Readonly<T>, Pick<T, K>, Omit<T, K>, Record<K, V>, ReturnType<F>, Parameters<F>, Awaited<T>, NonNullable<T>, Exclude and Extract on unions. They derive new types from existing ones instead of repeating definitions.

Mapped types build a type by transforming each key: { [K in keyof T]?: T[K] } is Partial. Conditional types choose a type by a test: T extends string ? 'text' : 'other', distributing over unions, and infer extracts parts such as a function's return type. Together they power most utility types.

strict: true enables strictNullChecks (null and undefined must be handled), noImplicitAny, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, useUnknownInCatchVariables and more. It catches far more bugs; new projects should always use it.

Types disappear at runtime, so annotate the response as unknown and validate it with a schema library such as Zod or Valibot, then infer the TypeScript type from the schema (z.infer<typeof User>). One source of truth, checked at the boundary.

It constrains a type parameter: function getLength<T extends { length: number }>(x: T) accepts anything with a length. In conditional types, T extends U ? X : Y checks assignability and distributes over unions.

{ [key: string]: number } describes objects with any string keys. Accessing a missing key returns undefined at runtime but is typed as number unless noUncheckedIndexedAccess is enabled. Prefer Record with known keys or a Map where possible.

Interfaces with the same name merge their members. Module augmentation (declare module 'lib' { interface Options { extra: string } }) adds types to a library's interfaces, for example registering a router or adding properties to Express's Request.

readonly marks properties or arrays as not writable in types. as const makes a literal deeply readonly and narrows its values to literal types ('admin' instead of string), useful for config objects and creating unions from arrays.

Use typeof on a value to get its type, keyof typeof obj for its keys, (typeof arr)[number] for an array element union, ReturnType<typeof fn> and Parameters<typeof fn>. Single sources of truth reduce duplicated definitions.

An async function returns Promise<T>; annotate as async function load(): Promise<User>. Use Awaited<T> to unwrap nested promise types, and type Promise.all results by passing a tuple.

How subtyping of components relates to subtyping of composite types. Return types are covariant; function parameters are contravariant under strictFunctionTypes (method parameters stay bivariant). Explicit in and out modifiers on type parameters can document and enforce it.

value satisfies Type checks that a value conforms to a type without widening the value's own inferred type. You keep precise literal types (for autocompletion and narrowing) while still getting an error if the shape is wrong, unlike a type annotation which replaces the inferred type.

typeof value in a type position gives the type of a JavaScript value, such as a config object. keyof T gives the union of T's keys. Together, keyof typeof config lists the keys of an object value.

Files containing only type declarations for JavaScript code, so TypeScript knows the shapes of untyped libraries or globals. Packages ship them, or they come from DefinitelyTyped (@types/...). declare module adds types for modules without them.

Enums define named constants and emit JavaScript objects at runtime; numeric enums allow any number and have reverse mappings. Teams often prefer union of string literals or as const objects, which add no runtime code and work with type-stripping tools such as Node's built-in TypeScript support.

Interfaces describe shape only and disappear at runtime. Abstract classes can contain implemented methods and fields plus abstract members subclasses must implement, and exist at runtime. Use interfaces for contracts and abstract classes for shared behaviour.

A way to simulate nominal types: type UserId = string & { readonly __brand: 'UserId' }. Values must be created through a function that validates and casts, so you cannot accidentally pass an OrderId where a UserId is expected.

Set baseUrl and paths (for example '@/*': ['./src/*']) in tsconfig, and make sure the bundler or runtime resolves them too (Next.js and Vite read tsconfig paths; Node needs imports in package.json or a loader).

It distinguishes a missing optional property from one explicitly set to undefined, so { name?: string } no longer accepts { name: undefined } unless the type includes undefined.

Added in TypeScript 5.4, it stops a type parameter from being inferred from a particular argument, so another argument decides the type, as in function pick<T extends string>(options: T[], fallback: NoInfer<T>).

TypeScript compares types by their shape: any object with the required properties fits, whatever its declared name. Nominal systems (Java, C#) require the declared type. Branded types (string & { __brand: 'UserId' }) simulate nominal typing when needed.

tsc type-checks and emits JavaScript, but many tools (esbuild, SWC, Babel) strip types per file without type checking. isolatedModules warns about code that needs whole-program information to compile, such as re-exporting types without export type.

1. Aany
2. BunknownCorrect answer
3. Cobject
4. Dvoid

Why: unknown is the type-safe counterpart of any.

1. AA readonly User
2. BUser with all properties required
3. CUser with all properties optionalCorrect answer
4. DOnly User's keys

Why: Partial makes every property optional.

1. Atuple
2. Btype alias
3. CinterfaceCorrect answer
4. Denum const

Why: Interfaces support declaration merging.

1. AHTMLButton
2. BButtonProps
3. CReact.Button
4. DReact.ComponentProps<'button'>Correct answer

Why: Extend it for custom buttons.

1. ACreates a class
2. BCopies T
3. CConstrains T to types with a lengthCorrect answer
4. DMakes T a string

Why: A generic constraint.

1. AalwaysStrict
2. BnoUncheckedIndexedAccessCorrect answer
3. CstrictNullChecks only
4. DnoImplicitAny

Why: Safer index signatures.

1. Aobject
2. B"a" | "b"Correct answer
3. C1 | 2
4. Dstring

Why: keyof yields the union of keys.

1. AOmitCorrect answer
2. BExclude
3. CExtract
4. DPick

Why: Omit<T, K> drops properties K.

1. Avoid
2. Bundefined
3. CneverCorrect answer
4. Dnull

Why: It never returns normally.

1. Ais
2. Binfer
3. Cas
4. DsatisfiesCorrect answer

Why: satisfies validates without widening.

1. AMakes it string[]
2. BFreezes it at runtime
3. CNothing
4. DMakes it readonly ['a', 'b']Correct answer

Why: Literal tuple type.

1. AArrayType<arr>
2. Barr[]
3. C(typeof arr)[number]Correct answer
4. Dkeyof arr

Why: Indexed access by number.

1. AUnwrap<T>
2. BResolve<T>
3. CPromise.type<T>
4. DAwaited<T>Correct answer

Why: Handles nested promises.

1. AEnum merging
2. BNamespaces only
3. CModule augmentationCorrect answer
4. DType casting

Why: declare module 'lib'.

1. AIgnored
2. BContravariantCorrect answer
3. CCovariant
4. DInvariant always

Why: Methods remain bivariant.

1. AImports a type
2. BCreates an enum
3. CRuns code
4. DDeclares a type variable to capture part of a typeCorrect answer

Why: e.g. T extends Promise<infer U> ? U : T.

1. AskipLibCheck
2. BnoImplicitAny
3. CstrictNullChecksCorrect answer
4. DesModuleInterop

Why: Without it, null fits every type.

1. A{ a: number; b: number }Correct answer
2. Bnumber[]
3. CMap<string, number>
4. D'a' | 'b'

Why: Record maps each key to the value type.

1. Avalue is TypeCorrect answer
2. Basserts Type
3. CType
4. Dboolean only

Why: The is predicate narrows on true.

1. AEnums
2. BDecorators
3. CNominal typingCorrect answer
4. DRuntime classes

Why: UserId vs. OrderId.

1. Ainclude and exclude
2. Blib and target
3. CbaseUrl and pathsCorrect answer
4. DrootDir and outDir

Why: Bundlers must resolve them too.

1. AUtility types
2. BAbstract classesCorrect answer
3. CInterfaces
4. DType aliases

Why: Types are erased.

1. AAny types
2. BNull values
3. CInferring T from that argumentCorrect answer
4. DUsing generics

Why: Added in TypeScript 5.4.

1. AArgs<fn>
2. BReturnType<typeof fn>
3. CInputs<fn>
4. DParameters<typeof fn>Correct answer

Why: A tuple of parameter types.

1. ANumbers only
2. BUnions of string patternsCorrect answer
3. CRuntime strings
4. DClasses

Why: e.g. on${string}.

1. ARemoves types
2. BMakes it mutable
3. CMakes properties readonly with literal typesCorrect answer
4. DConverts it to an enum

Why: Values keep their literal types.

1. Anpm audit
2. Btsconfig paths
3. Ceslint
4. D@types packages (DefinitelyTyped)Correct answer

Why: DefinitelyTyped publishes @types/* packages.

1. AOnly in tests
2. BAt runtime
3. CAt compile timeCorrect answer
4. DIn the database

Why: Types are erased in the emitted JavaScript.

1. APrettier
2. Besbuild, SWC and BabelCorrect answer
3. Ctsc only
4. DESLint

Why: Run tsc --noEmit separately.

1. ANull values
2. BReadonly arrays
3. CExplicit undefined for optional propsCorrect answer
4. DOptional props

Why: Unless undefined is in the type.