TypeScript

How to answer in an interview

TypeScript is a typed superset of JavaScript that compiles down to plain JavaScript. I would use it to catch mistakes earlier at compile time, make large codebases easier to navigate, and improve tooling such as autocompletion, refactoring, and documentation inside the editor. It is especially valuable on teams where multiple developers share and extend the same code over time.

Explain like I am 5

TypeScript is like JavaScript with a safety helmet and better labels on the boxes. It helps you spot mistakes before the code runs, and then it turns back into normal JavaScript so the computer can use it.

How to answer in an interview

Both interfaces and type aliases can describe object shapes, and in many cases they overlap. I usually prefer interface for object-oriented public contracts because it supports declaration merging and is easy to extend, while type aliases are more flexible for unions, intersections, primitive aliases, tuple types, and function signatures. The right choice depends on whether I need extensibility or more expressive composition.

Explain like I am 5

An interface is like a reusable form that can be added to later. A type alias is like a label that can point to almost any kind of shape, including mixed-together shapes and choice-based shapes.

How to answer in an interview

Generics let you write reusable functions, classes, and interfaces that preserve type information without forcing you to use 'any'. By introducing a type parameter such as T, you can keep the input and output types connected, which makes APIs safer and more flexible. Constraints with 'extends' let you require that a generic type has certain properties before it can be used.

Explain like I am 5

Generics are like a blank label on a box. You can fill in the right kind of thing later, and the box still remembers what kind of thing belongs inside it.

How to answer in an interview

A union type means a value can be one of several types, such as string | number, so you need to narrow before using it safely. An intersection type means a value must satisfy all of the combined types, such as combining shared behavior from multiple interfaces. I use unions when modeling alternatives and intersections when composing capabilities.

Explain like I am 5

A union is like a choice between different doors — you can pick one. An intersection is like carrying all the keys at once — you need every piece together.

How to answer in an interview

Type narrowing is how TypeScript uses runtime checks and control flow to reduce a broad type to a more specific one. Common narrowing tools include 'typeof', 'instanceof', the 'in' operator, custom type guards, and discriminated unions. This is important because it lets you write safer code without losing the benefits of flexible type definitions.

Explain like I am 5

Type narrowing is like looking at a mystery box and asking a few yes-or-no questions until you know exactly what kind of thing is inside.

How to answer in an interview

Utility types are built-in helper types that transform existing types into new ones, such as Partial, Pick, Omit, Readonly, Record, ReturnType, and Exclude. They reduce repetitive boilerplate and make type definitions easier to maintain because I can reuse and reshape existing models instead of redefining them from scratch.

Explain like I am 5

Utility types are like editing tools for type blueprints. They let you copy just the parts you need, hide parts you do not want, or make a template easier to reuse.

How to answer in an interview

A discriminated union is a union of types that share a common literal property (the discriminant), enabling TypeScript to narrow the correct type in a switch or if-else block. This pattern is extremely useful for modeling state machines, API responses, or any scenario where an object can be one of several shapes, and the discriminant tells you which shape it is.

Explain like I am 5

A discriminated union is like a set of differently colored envelopes where the color tells you exactly what kind of letter is inside, so the computer can figure out what to do just by looking at the color.

How to answer in an interview

I use type aliases when I need unions, intersections, tuple types, mapped types, or computed properties — things interfaces cannot express. I use interfaces when defining object shapes that might need declaration merging or where extends-based inheritance is cleaner. In practice, object-oriented public contracts usually use interfaces, while complex type-level compositions use type aliases.

Explain like I am 5

Type aliases are more flexible for mixing and matching different kinds of types together. Interfaces are cleaner when you just need to define the shape of an object and might want to extend it later.

How to answer in an interview

An async function always returns a Promise, so TypeScript automatically wraps the return type in Promise<T>. You can type a variable as Promise<T> or use the Awaited utility type to extract the resolved type. For callbacks returning Promises, you type the return as Promise<void> or the specific resolved type, and the compiler handles the rest.

Explain like I am 5

When you write an async function, TypeScript knows it always returns a Promise and wraps the return type automatically, so you just focus on the actual value and let the compiler handle the Promise wrapper.

How to answer in an interview

Declaration files provide type information for JavaScript libraries that don't have built-in TypeScript types, allowing TypeScript to type-check code that uses those libraries. They're typically installed via @types packages from DefinitelyTyped or written manually for internal modules. A .d.ts file contains only type declarations, no runtime code.

Explain like I am 5

Declaration files are like instruction manuals that tell TypeScript what shapes and types a JavaScript library uses, so TypeScript can understand and check code that calls that library.

How to answer in an interview

Assertion functions are functions that throw an error if a condition is false, and TypeScript uses the 'asserts' keyword to narrow types based on the function call. For example, assertIsString(value) tells TypeScript that after the call, value is guaranteed to be a string. They're useful for runtime validation at boundaries like API inputs.

Explain like I am 5

Assertion functions are like bouncers who check a person's ID — if the check passes, TypeScript trusts that the value has the right type from that point on.

How to answer in an interview

Record<K, V> is a utility type for creating objects with known key types and value types, useful for typed dictionaries. Map<K, V> is a runtime data structure with better performance for frequent additions and deletions, preserving key insertion order. Plain objects with index signatures work for simple cases but lack the type safety and methods of Map.

Explain like I am 5

Record is a type-level tool for saying 'every key must be this shape.' Map is a real, living container at runtime. Plain objects work for simple cases but don't have all the fancy features Map gives you.

How to answer in an interview

Declaration merging is TypeScript's ability to combine multiple declarations with the same name into a single definition. Interfaces merge their members, namespaces merge their exports, and you can augment existing modules or global types using module augmentation or ambient declarations. This is why libraries like Express let you extend Request with custom properties.

Explain like I am 5

Declaration merging is like having multiple people add notes to the same page — TypeScript combines all the additions into one complete definition, even if the parts were written separately.

How to answer in an interview

'any' disables type checking for a value, so I try to avoid it unless I am migrating legacy code. 'unknown' is safer because the compiler forces me to check and narrow it before using it. 'never' represents a value that should not exist, such as a function that cannot return or an impossible branch in exhaustive checks.

Explain like I am 5

any is like saying 'just put anything here and trust me.' unknown is like a sealed box you must inspect before using. never is like a path that should not be possible to walk down at all.

How to answer in an interview

Strict mode turns on a set of compiler checks that make TypeScript much more effective at finding bugs early, especially around null handling, implicit any usage, and unsafe assumptions. In production projects, I prefer strict mode because it forces clearer contracts, improves refactoring confidence, and prevents many bugs that would otherwise appear only at runtime.

Explain like I am 5

Strict mode is like a teacher who checks your work carefully and makes you fix sloppy answers before you hand in the assignment.

How to answer in an interview

Template literal types let you create new string literal types by combining existing ones using template literal syntax. Combined with intrinsic string manipulation types like Uppercase and Lowercase, they allow compile-time string transformations, which is useful for strongly-typed event names, CSS class builders, or API route definitions where the string pattern matters.

Explain like I am 5

Template literal types are like a word game at the type level — you can combine and transform string patterns to create new types, so TypeScript can enforce correct strings before you even run the code.

How to answer in an interview

Mapped types iterate over the keys of an existing type to produce a new type, allowing you to transform each property's type, add or remove modifiers like readonly or optional, or remap keys using the 'as' clause. Built-in types like Partial, Required, and Pick are implemented as mapped types under the hood.

Explain like I am 5

Mapped types are like running a type through a copy machine that lets you tweak each property — make things optional, strip readonly, or change the key names — without rewriting everything by hand.

How to answer in an interview

Conditional types take the form T extends U ? X : Y, allowing you to choose between two types based on whether one type extends another. They enable powerful type-level programming, such as extracting return types, filtering union members, or transforming types based on conditions. When applied to a union, conditional types distribute over each member automatically.

Explain like I am 5

Conditional types are like an if-else statement for types — if a type fits a certain pattern, you get one result, otherwise you get another, letting TypeScript make smart type decisions.

How to answer in an interview

The infer keyword lets you declare a type variable within a conditional type that TypeScript will try to infer from the checked type. It's commonly used to extract parts of complex types, like the return type of a function, the element type of an array, or the resolved type of a Promise, enabling powerful type-level extraction and transformation.

Explain like I am 5

The infer keyword is like leaving a blank space in a puzzle piece and letting TypeScript figure out what should fill that blank based on what you give it.

How to answer in an interview

Higher-order functions that accept callbacks should use generic type parameters to preserve the relationship between input and output types. For example, a map function should be typed as function map<T, U>(arr: T[], fn: (item: T) => U): U[], so TypeScript infers the output array type from the callback. This avoids losing type information through the transformation.

Explain like I am 5

When writing functions that take other functions as arguments, you use generics to tell TypeScript exactly what types flow in and out, so it can keep track of everything accurately.