TypeScript · Beginner interview

TypeScript is a superset of JavaScript that adds static types checked at compile time, then compiles down to plain JavaScript. It catches type errors, typos, and null mistakes before you run the code, and powers editor features like autocomplete and safe refactoring. You get JavaScript's flexibility plus a safety net and better tooling on large codebases.

Nothing — types are erased during compilation. The emitted JavaScript has no interfaces or type annotations, so you can't check a TypeScript type at runtime the way you'd think (typeof still works on values, but an interface doesn't exist). If you need runtime validation, you use a library like Zod or write manual checks; the type system only protects you at compile time.

any opts out of type checking entirely — anything goes, which defeats the purpose. unknown is the safe counterpart: it accepts any value but forces you to narrow or check it before using it. never is the empty type — a value that can't exist, used for things like a function that always throws or the exhaustive default of a union. Prefer unknown over any, and use never to prove exhaustiveness.

Both describe object shapes and are mostly interchangeable. interface is open — it supports declaration merging and is conventional for public object/class contracts. type is more flexible: it can also alias unions, intersections, tuples, primitives, and mapped/conditional types. A common rule: interface for object/class shapes, type when you need unions or other non-object types.

interface User { id: string; name: string }
type Status = "active" | "banned";

A union (A | B) means a value is one of several types — e.g. string | number — and you must narrow it before using type-specific operations. An intersection (A & B) combines types so a value must satisfy all of them at once, often used to merge object shapes. Union is 'either/or'; intersection is 'both'.

An optional property (name?: string) may be absent, so its type includes undefined and you must handle that case. A readonly property can be set when the object is created but not reassigned afterward, which the compiler enforces. Both are compile-time guarantees that document intent and prevent whole classes of mistakes.

You annotate each parameter and, optionally, the return type after the parameter list. TypeScript can usually infer the return type, but annotating it on public functions documents intent and catches mistakes where the body returns the wrong thing.

function add(a: number, b: number): number {
  return a + b;
}

A generic is a type parameter that lets a function or type work with many types while preserving the relationship between them. For example, an identity function typed <T>(x: T): T returns exactly the type it was given, instead of any. You use generics to write reusable, type-safe code — like a container or a function that maps over an array — without losing type information.

function first<T>(arr: T[]): T | undefined {
  return arr[0];
}

Inference is TypeScript working out a type you didn't write. If you say let n = 5, it infers number; map and filter infer element types; a function's return type is inferred from its body. Good TypeScript leans on inference for locals and annotates the boundaries — function parameters and public APIs — where inference can't help.

tsconfig.json configures the compiler — which files to include, the target JS version, module system, and type-checking options. strict turns on a bundle of stricter checks at once, most importantly strictNullChecks (null/undefined must be handled) and noImplicitAny (no silent any). Starting strict is strongly recommended; loosening later is harder than tightening.

A .d.ts file contains type declarations with no implementation — it describes the shape of existing JavaScript so TypeScript can check code that uses it. Many libraries ship their own; for those that don't, the community publishes types as @types/<package> on npm (DefinitelyTyped). Installing @types/node, for instance, gives you typings for Node's built-in modules.

Inside a conditional, TypeScript narrows a union to a more specific type based on a runtime check. typeof x === 'string' narrows x to string in that branch; instanceof narrows to a class; a truthiness check removes null/undefined. This lets you safely use type-specific methods after proving the type.

function len(x: string | string[]) {
  return typeof x === "string" ? x.length : x.length;
}