TypeScript Interview Questions

Both describe object shapes. Interfaces can be re-opened (declaration merging) and extended with extends. Type aliases can also name unions, tuples and mapped types. For object shapes, either works; teams usually pick one convention.

A superset of JavaScript that adds static types. The compiler catches type errors before runtime, editors give better autocompletion and refactoring, and types document how code is meant to be used.

any disables type checking. unknown accepts any value but forces you to narrow it before use — the safe choice for untrusted data. never represents values that never occur, such as a function that always throws or an exhaustive switch default.

No. The compiler (tsc, or a bundler such as Vite with esbuild) removes the types and outputs plain JavaScript. Types exist only at compile time, so they cannot validate data arriving from an API at runtime.

TypeScript works out types from values, so let count = 0 is a number without an annotation. Annotate function parameters, public APIs and empty values, and let inference handle the rest.

An array type (string[]) holds any number of items of one type. A tuple ([string, number]) has a fixed length with a type per position — useful for returning pairs like React’s useState.

An optional parameter (name?: string) may be omitted and is typed string | undefined. A default parameter (name = "Guest") is also optional to the caller but always has a value inside the function.

Types that allow only specific values: "sm" | "md" | "lg" or 200 | 404. They make invalid values impossible and give autocomplete in the editor.

Generics preserve the relationship between input and output types, so the compiler still checks your code. any disables checking entirely.

A union (A | B) is a value of either type. An intersection (A & B) combines types so the value has all members of both.

Refining a broad type to a more specific one inside a code path using checks such as typeof, instanceof, in, equality checks, truthiness or user-defined type guards (value is Type).

Partial<T>, Required<T>, Readonly<T>, Pick<T, K>, Omit<T, K>, Record<K, V>, ReturnType<F>, Parameters<F>, NonNullable<T> and Awaited<T>.

1type UpdateUser = Partial<Omit<User, "id">>;

A group of checks including strictNullChecks, noImplicitAny, strictFunctionTypes, strictPropertyInitialization and useUnknownInCatchVariables. It catches many real bugs and should be on for new projects.

A runtime check that narrows a type inside a branch: typeof, instanceof, the in operator, equality checks, or a custom function returning value is Type.

1interface Cat { meow(): void }
2interface Dog { bark(): void }
3function isCat(pet: Cat | Dog): pet is Cat {
4  return 'meow' in pet;
5}

A union of object types that share a literal property such as kind or status. Checking that property narrows to one member, and a never check in the default branch makes the switch exhaustive.

With extends: function getId<T extends { id: number }>(item: T) accepts any object with a numeric id and keeps its full type. keyof constraints (K extends keyof T) make property-access helpers type-safe.

public is accessible everywhere, protected in the class and subclasses, private only in the class (at compile time). readonly can be set only in the declaration or constructor. Parameter properties (constructor(private repo: Repo)) declare and assign in one step.

An interface is only a type and disappears at runtime. An abstract class exists at runtime, can hold shared implementation and constructor logic, and cannot be instantiated directly.

An async function returns Promise<T>. Annotate it explicitly on public functions, type fetched JSON (await res.json() is any), and use Awaited<T> to unwrap promise types.

strict (all strict checks), target and module (output), moduleResolution (bundler or node16), noUncheckedIndexedAccess, skipLibCheck, paths for aliases, and noEmit when a bundler compiles the code.

keyof T produces a union of T’s property names. typeof value gets the type of a runtime value. Together they derive types from existing data, e.g. type Key = keyof typeof config.

Enums generate runtime JavaScript objects; string literal unions ("draft" | "published") exist only at compile time, produce no output and work well with plain JSON. Many teams prefer literal unions or as const objects.

Mapped types build new types by looping over keys: { [K in keyof T]?: T[K] } is how Partial works. Conditional types choose a type with T extends U ? X : Y, and infer extracts parts, as in ReturnType.

Describe props with an interface or type, use React.ComponentProps<"button"> to extend native props, type events as React.ChangeEvent<HTMLInputElement>, and let useState infer unless the initial value is null.

Angular is written in TypeScript: decorators, DI tokens, typed reactive forms, strict template type checking and typed HttpClient responses (http.get<Product[]>()) all depend on it.

An assertion tells the compiler to trust you and checks nothing at runtime. as unknown as T can turn any value into anything. Prefer narrowing, satisfies, or runtime validation (zod) for external data.