TypeScript Developer interview questions

TypeScript is a statically checked language that extends JavaScript with types and compiles to JavaScript.

• Valid JavaScript syntax is generally valid TypeScript syntax, so projects can adopt it gradually.
• The compiler reports many type mistakes before the code runs.
• Browsers and Node.js normally execute the emitted JavaScript, not TypeScript source directly.

Static type checking means TypeScript analyzes value usage before the program runs.

• The compiler compares assignments, arguments, and return values with their declared or inferred types.
• It can reject operations such as calling a string method on a number.
• Static checks reduce a class of mistakes but do not prove that all runtime behavior is correct.

A type annotation explicitly states the type expected for a variable, parameter, property, or return value.

• A variable annotation appears after its name, as in count: number.
• An annotation lets the compiler reject values that do not match the stated contract.
• Annotations are most useful at boundaries or when inference cannot express the intended type clearly.

Type inference lets TypeScript determine a type from the surrounding code without an explicit annotation.

• A variable initialized with 42 is usually inferred as number.
• A function return type can be inferred from the values returned by its branches.
• Inference reduces repetition while preserving compile-time checking.

Contextual typing infers a value's type from the place where that value is used.

• A callback parameter can be inferred from the method or function receiving the callback.
• An object literal can be checked against the type expected by a variable or argument.
• This context often provides useful types even when the value has no annotations of its own.

The most common primitive types are string, number, boolean, bigint, symbol, null, and undefined.

• TypeScript uses lowercase names such as string rather than boxed object types such as String.
• JavaScript has one number type for ordinary integer and floating-point values.
• null and undefined require explicit handling when strict null checking is enabled.

An array type states the type allowed for each element, using forms such as string[] or Array<string>.

• Both forms describe an array whose elements are strings.
• A union element type such as Array<string | number> allows either member in the same array.
• The element type is checked when values are read, inserted, or passed to array methods.

A tuple is an array type with a known length and a specific type for each position.

• A type such as [string, number] requires a string first and a number second.
• A normal number[] can contain any number of numeric elements without position-specific meanings.
• Tuples suit small ordered records, while named object properties are often clearer for larger data.

An object type describes the property names and value types an object must provide.

• A property such as name: string is required unless it is marked optional.
• Methods can be represented with function-valued properties or method syntax.
• TypeScript checks structural compatibility, so the object's shape matters more than its declared name.

An interface gives a reusable name to an object shape.

• It declares required, optional, readonly, and method members for objects or classes.
• Other interfaces can extend it to add or refine members.
• Values satisfy it by having a compatible structure, without explicitly declaring that relationship.

A type alias assigns a reusable name to any TypeScript type expression.

• It can name an object shape, union, intersection, tuple, primitive, or function type.
• The alias does not create a new runtime value or a distinct nominal type.
• Type aliases can compose existing types into clearer domain vocabulary.

Both interface and type can describe object shapes, but they differ in extension and declaration behavior.

• Interfaces extend with extends and can merge when the same interface is declared more than once.
• Type aliases compose with intersections and cannot be reopened by another declaration.
• Type aliases also represent unions and tuples, so consistency and the needed feature usually guide the choice.

Interface extension creates an interface that includes members from one or more parent interfaces.

• The child uses extends and can add its own properties or methods.
• Any redeclared property must remain compatible with the inherited contract.
• Extension is useful for expressing a clear relationship between related object shapes.

A union type represents a value that may be any one of several listed types.

• The vertical bar combines members, as in string | number.
• Before narrowing, code may use only operations safe for every member of the union.
• Unions model alternatives more precisely than weakening the value to any.

An intersection type combines multiple types into one type that must satisfy all of them.

• The ampersand combines members, as in Identified & Timestamped.
• For object types, the result normally contains the required properties from every member.
• Conflicting property requirements can make part or all of an intersection impossible to construct.

A union accepts a value matching at least one member, while an intersection requires a value matching every member.

• string | number represents either a string or a number.
• Named & Auditable represents an object that meets both object contracts.
• Union code usually narrows alternatives, while intersection code can use the combined compatible members.

A literal type represents one exact string, number, or boolean value rather than the wider primitive type.

• A type such as 'pending' accepts only that string value.
• Literal unions can define a closed set such as 'pending' | 'done'.
• Exact values help the compiler catch misspelled or unsupported options.

A const declaration often preserves a primitive literal, while as const keeps literal values throughout an expression.

• A const variable initialized with 'open' can be inferred as the literal type 'open'.
• Object properties normally widen because their values could be reassigned.
• Applying as const keeps nested literal values narrow and marks object properties and tuple elements readonly.

An optional property marked with ? may be absent from an object.

• Reading it usually produces a type that includes undefined.
• Code must check for absence before using it as a definitely present value.
• Optional does not automatically mean the same thing as a required property whose value may be undefined.

readonly prevents a property or collection element from being reassigned through that TypeScript reference.

• A readonly property can be initialized but not later assigned directly.
• ReadonlyArray<T> blocks mutating methods such as push and splice.
• readonly is a compile-time restriction and does not freeze the JavaScript object at runtime.