TypeScript Interview Questions

Angular, React and Node interviews now assume TypeScript. Interviewers rarely ask for trivia; they check whether you understand what the type system does (and doesn't) guarantee. Below are the questions that come up most, grouped from fundamentals to advanced, each with a short answer and code where it helps.

Fundamentals

1. What is TypeScript, and does it make code faster?

A superset of JavaScript that adds static types checked at compile time. Types are erased, so the output is plain JavaScript with the same run-time speed. The gain is in catching bugs earlier and in better editor tooling.

2. any vs unknown vs never

function parse(json: string): unknown {
  return JSON.parse(json);
}

const data = parse('{"name":"Asha","score":91}');
// data.name;                                      // error: data is unknown – you must check first
if (typeof data === "object" && data !== null && "name" in data) {
  console.log(String(data.name));
}

function fail(message: string): never {            // never returns
  throw new Error(message);
}
try {
  fail("unreachable state");
} catch (e) {
  console.log((e as Error).message);
}

Asha
unreachable state

any switches checking off; unknown accepts anything but forces you to narrow before use; never is the type with no values (functions that never return, exhausted unions).

3. type vs interface?

Both describe object shapes. Interfaces can be reopened (declaration merging) and extended with extends; type aliases can also name unions, tuples, primitives and mapped or conditional types. A common team rule: interfaces for object shapes and public APIs, types for unions and computed types.

4. Does TypeScript check data at run time?

No. An API response typed as User is only assumed to be a User. Validate external data (API responses, form input, environment variables) with a schema library such as zod, and derive the type from the schema.

Everyday TypeScript

5. What is narrowing? Name the ways to narrow.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; w: number; h: number };

function isCircle(s: Shape): s is { kind: "circle"; radius: number } {   // user-defined type guard
  return s.kind === "circle";
}

function area(s: Shape): number {
  switch (s.kind) {                       // discriminant narrowing
    case "circle": return Math.PI * s.radius ** 2;
    case "rect": return s.w * s.h;
    default: {
      const unreachable: never = s;       // compile error if a new kind is not handled
      return unreachable;
    }
  }
}

const shapes: Shape[] = [{ kind: "circle", radius: 1 }, { kind: "rect", w: 3, h: 4 }];
console.log(shapes.map(area).map((a) => a.toFixed(2)), shapes.filter(isCircle).length);

[ '3.14', '12.00' ] 1

Narrowing with typeof, instanceof, in, equality, truthiness, discriminant fields and type predicates (x is T). The never check makes a switch exhaustive.

6. Write a generic function with a constraint.

function maxBy<T extends object, K extends keyof T>(items: readonly T[], key: K): T | undefined {
  return items.reduce<T | undefined>((best, item) => (best === undefined || item[key] > best[key] ? item : best), undefined);
}

const team = [{ name: "Asha", score: 91 }, { name: "Ravi", score: 97 }, { name: "Meera", score: 88 }];
console.log(maxBy(team, "score")?.name, maxBy(team.slice(0, 0), "score"));

Ravi undefined

7. Explain Partial, Pick, Omit and Record with a use case.

Partial<User> for PATCH bodies, Omit<User, "passwordHash"> for API responses, Pick<User, "id" | "name"> for list items, Record<Role, Permission[]> for lookup tables that must cover every key.

8. What's the difference between optional (x?: T) and x: T | undefined?

With ? the property may be missing entirely; with T | undefined it must be present but may hold undefined. Under exactOptionalPropertyTypes, x?: T no longer accepts an explicit undefined.

Advanced

9. Implement your own ReturnType.

type MyReturnType<F> = F extends (...args: never[]) => infer R ? R : never;

function login(user: string) {
  return { user, token: "abc123", expiresIn: 3600 };
}
type Session = MyReturnType<typeof login>;

const s: Session = login("asha");
console.log(Object.keys(s), s.expiresIn / 60);

[ 'user', 'token', 'expiresIn' ] 60

10. What does satisfies do?

It checks that a value matches a type without widening the value's inferred type, so you keep literal keys and values (see the previous lesson). Useful for config objects and theme tokens.

11. What is a .d.ts file? What is declaration merging?

A file with only type declarations, describing JavaScript defined elsewhere (from @types/* packages or your own declare module). Declaration merging means two interface declarations with the same name combine – that's how you add fields to Window or NodeJS.ProcessEnv.

12. Structural typing – what does it mean?

interface Point { x: number; y: number }
class Vector {
  constructor(public x: number, public y: number, public z: number) {}
}

function length2d(p: Point): number {
  return Math.hypot(p.x, p.y);
}
console.log(length2d(new Vector(3, 4, 12)));   // a Vector has x and y, so it is a Point

5

Compatibility depends on shape, not on declared names. Any value with the required members fits – unlike Java or C#, which use nominal typing. (Excess property checks still apply to object literals written directly.)

TypeScript with React and Node

13. How do you type React component props and state?

// Button.tsx
type ButtonProps = {
  label: string;
  variant?: "primary" | "danger";
  onClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
} & Omit<React.ComponentPropsWithoutRef<"button">, "onClick">;   // plus every native button prop

export function Button({ label, variant = "primary", ...rest }: ButtonProps) {
  return <button className={`btn btn-${variant}`} {...rest}>{label}</button>;
}

// state: inferred from the initial value, or given explicitly when it can be null
const [user, setUser] = useState<User | null>(null);
const inputRef = useRef<HTMLInputElement>(null);

Type props as a plain function parameter rather than React.FC; pass a generic to useState when the initial value doesn't show the full type.

14. How do you type an Express handler?

import type { Request, Response } from "express";

type Params = { id: string };
type Body = { title: string };

app.put("/courses/:id", (req: Request<Params, unknown, Body>, res: Response) => {
  // req.params.id is string, req.body.title is string – but validate the body at run time!
  res.json({ id: req.params.id, title: req.body.title });
});

15. What tsconfig options would you turn on for a new project?

strict (always), noUncheckedIndexedAccess (array and record lookups include undefined), verbatimModuleSyntax or isolatedModules (for esbuild/SWC), noImplicitOverride, and skipLibCheck to keep builds fast.

Practice

Summary

Practise more on our React interview questions and Next.js interview questions.