Beginner TypeScript Interview Questions and Answers

TypeScript is a superset of JavaScript that adds static types. Any valid JavaScript is (mostly) valid TypeScript. The TypeScript compiler checks the types and then removes them, producing plain JavaScript that runs in browsers and Node.js. Types exist only at compile time.

Errors such as wrong argument types, misspelled properties and unhandled null are caught before the code runs; editors give accurate auto-complete, inline documentation and safe refactoring; types document how code should be used; and large codebases are easier to change safely. The costs are a build or type-check step and learning the type system.

TypeScript works out types without annotations, from initial values (let count = 0 is a number), return statements and context (callback parameters in array.map((x) => ...)). You annotate where inference cannot help or where the type documents intent: function parameters, public return types and outside data.

Both can describe object shapes. interface can be extended with extends and supports declaration merging (two declarations with the same name combine). type can name any type, including unions, tuples, primitives and function types, and composes with &. A common convention is interfaces for object shapes and type aliases for everything else.

Both accept any value. any turns off type checking, so you can use the value in any way, even incorrectly. unknown must be narrowed (with typeof, instanceof, a type guard and so on) before it can be used, which makes it the safe choice for outside data such as JSON or caught errors.

A union A | B means a value can be either type. Before narrowing, you can only use what all members share; after a check such as typeof value === "string", TypeScript knows the specific type. Unions with null or undefined model optional values: string | null.

Types that allow one exact value, such as "left" or 42. In unions, they describe a fixed set of allowed values: type Size = "small" | "medium" | "large". They catch typos and enable auto-complete.

prop?: T makes the property optional (its type includes undefined, so it must be checked before use). readonly prop: T prevents reassigning the property after creation; this is checked at compile time only.

void is the return type of a function that returns no useful value (it finishes normally). never is the type of something that never happens: a function that always throws or loops forever, or a value in a branch that has been ruled out completely. never is used for exhaustiveness checks.

"strict": true in tsconfig.json enables a group of checks, most importantly strictNullChecks (null and undefined must be handled explicitly) and noImplicitAny (no silent any types). It should be enabled in every new project.

Arrays: number[] or Array<number>. Tuples have a fixed length and a type per position: [string, number], for example ["maths", 92]. Use readonly number[] for arrays that must not be modified.

Enums define named constants that exist at runtime: enum Status { Active = "ACTIVE", Inactive = "INACTIVE" }. Numeric enums auto-increment and reverse-map. Many teams prefer string literal unions ("active" | "inactive") or as const objects, which need no special compilation, accept plain strings and work with tools that only strip types.

Annotate parameters and, optionally, the return type: function add(a: number, b: number): number. Optional parameters use ?, defaults use =, rest parameters are arrays (...nums: number[]). A function type is written as (a: number, b: number) => number.

No. Types are erased during compilation, so you cannot check if (value is User) at runtime using a TypeScript type. Runtime checks need JavaScript (typeof, instanceof, property checks), usually wrapped in type guard functions or validation libraries such as Zod.