TypeScript Interview Questions

What does the compiler output?

TypeScript is JavaScript with static types. The compiler checks the types and removes them, outputting plain JavaScript. Types do not exist at runtime, so runtime checks (and validation of outside data) still need JavaScript code such as type guards.

Merging, and what each can describe.

Both describe object shapes. Interfaces can be extended with extends and merge when declared twice. Type aliases can name any type, including unions, tuples and function types, and compose with &. A common convention: interfaces for object shapes, type aliases for everything else.

Which one forces a check?

Both accept any value. any disables checking entirely. unknown must be narrowed before use, so it is the safe type for JSON, API responses and caught errors.

Ordinary JavaScript checks.

By following checks such as typeof, instanceof, in, equality, truthiness and custom type guards:

function format(v: string | number): string {
  return typeof v === "number" ? v.toFixed(1) : v.toUpperCase();
}
console.log(format(2), format("ok"));

2.0 OK

A shared literal property, and never.

A union of object types sharing a literal property (kind, type, status) that identifies each member, so checking it narrows to one member. Assigning the value to a never variable in the default branch makes the compiler report any unhandled member.

Keep the type, not lose it.

Generics add type parameters so code works with many types while preserving which one is used:

function first<T>(items: T[]): T | undefined {
  return items[0];
}
const n = first([10, 20]);
console.log((n ?? 0) + 1);

11

With any, the result would be untyped and errors would go unnoticed.

K extends keyof T.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const user = { name: "Asha", age: 21 };
console.log(getProperty(user, "age") + 1);

22

Passing a key that does not exist is a compile error, and the return type is the exact property type.

Update payloads, safe user objects, lookup tables.

Partial<T> for updates, Pick and Omit to select or remove properties (such as Omit<User, "password">), Readonly, Record<K, V> for dictionaries, Exclude/Extract/NonNullable for unions, and ReturnType, Parameters and Awaited to reuse function types.

value is Type.

A function whose return type is a type predicate such as value is User. When it returns true, TypeScript narrows the value to that type. TypeScript trusts the predicate, so its runtime checks must be correct. Guards are how unknown data becomes typed data.

Which one checks, and which keeps the inferred type?

as T tells the compiler to treat a value as T without checking it (only obvious mismatches are rejected). satisfies T checks that the value matches T while keeping its precise inferred type. satisfies is safe; as makes you responsible.

A conditional type with infer.

type MyReturnType<F> = F extends (...args: never[]) => infer R ? R : never;
const make = () => ({ id: 1 });
const value: MyReturnType<typeof make> = { id: 2 };
console.log(value.id);

2

infer R captures the return type when F matches a function type.

strict, and a few more.

strict (including strictNullChecks and noImplicitAny), noUncheckedIndexedAccess, noImplicitOverride, verbatimModuleSyntax and skipLibCheck, plus the right module and moduleResolution for the runtime (nodenext for Node.js, bundler with a bundler).