Previous Exam Questions on TypeScript

This topic gathers exam-style TypeScript questions modeled on assessments spanning multiple modules of this course — basic types and classes through generics and advanced type manipulation. Use it as a final review before a module test or final exam: each question mimics the phrasing and depth an instructor might use, and each answer explains not just the 'what' but the reasoning the compiler applies, so you can transfer the logic to slightly different exam questions rather than memorizing answers verbatim.

No. 'protected' members are accessible within the declaring class and any subclass, but not from outside the class hierarchy. Attempting dog.name from external code raises 'Property name is protected and only accessible within class Animal and its subclasses.' Only 'public' members (the default) are accessible everywhere; 'private' members are restricted to the exact declaring class, not even subclasses.

Partial<Point> produces { x?: number; y?: number; }, making every property of Point optional. Partial is one of TypeScript's built-in mapped utility types, implemented internally as type Partial<T> = { [P in keyof T]?: T[P]; }. It is commonly used for update/patch functions where only a subset of fields needs to be supplied, e.g. function updatePoint(p: Point, patch: Partial<Point>): Point.

It compiles successfully. Shape is an abstract class that cannot be instantiated directly ('new Shape()' would error), but Circle implements the abstract area() method, so 'new Circle(2)' is valid and can be assigned to a variable typed as the base class Shape. Calling s.area() calls Circle's implementation at runtime (polymorphism), and the compiler infers 'area' as type number because Shape.area() is declared to return number.

function logLength<T extends { length: number }>(arg: T): T { console.log(arg.length); return arg; } uses 'extends' to constrain the generic parameter T so that only types with a numeric 'length' property (strings, arrays, or custom objects with a length field) are accepted. Calling logLength(42) fails to compile because number has no length property, while logLength('hello') and logLength([1,2,3]) both compile because string and array types satisfy the constraint.

keyof Point produces the union of string literal types 'x' | 'y' — every known property name of Point. It is commonly used in generic accessor functions, e.g. function getProp<T, K extends keyof T>(obj: T, key: K): T[K] { return obj[key]; }, which guarantees at compile time that 'key' is a valid property of 'obj' and that the return type matches that property's actual type (T[K], an indexed access type).

This is control-flow-based type narrowing. Outside the if block, x has the declared union type string | number, so calling toUpperCase() directly would fail because number has no such method. Inside the 'if (typeof x === "string")' branch, TypeScript's control flow analysis narrows x's type specifically to string, so x.toUpperCase() is valid there. Outside the branch (or in an else branch), x would be narrowed to number instead.

A conditional type selects between two types based on a type-level condition, using the form T extends U ? X : Y; for example type IsString<T> = T extends string ? true : false;. A mapped type transforms every property of an existing type using an [P in keyof T] clause; for example type Readonly<T> = { readonly [P in keyof T]: T[P] }. Conditional types branch based on a check, while mapped types iterate over and transform an object type's properties — the two are often combined, e.g. in utility types like Exclude or Pick.

By default, numeric enums are auto-incremented starting at 0, so Direction.Up is 0 and Direction.Down is 1 (Left is 2, Right is 3). Unlike a plain union of string literals, a numeric enum is compiled into a real JavaScript object at runtime with both forward (Up -> 0) and reverse (0 -> 'Up') mappings, which is why numeric enums have a runtime footprint that literal-type unions do not.

Record<K, T> constructs an object type whose keys are exactly the union K and whose values all have type T. Record<'admin' | 'user', string[]> produces { admin: string[]; user: string[]; }. It is used whenever you need a lookup object with a known, finite set of keys and a consistent value type, such as role-to-permissions maps, ensuring at compile time that every key in the union is present and no extra keys are added.

This raises 'Property greet in type Derived is not assignable to the same property in base type Base' because Derived narrows the method signature incompatibly — Base.greet() takes zero arguments while Derived.greet(name: string) requires one, breaking the Liskov substitution guarantee that a Derived should be usable anywhere a Base is expected. The fix is to make the parameter optional (greet(name?: string): void) so Derived.greet() remains callable with zero arguments, matching Base's contract.

'item' is inferred as number through contextual typing: because [1, 2, 3] is typed as number[], TypeScript already knows the callback passed to .map() will receive a number, so it infers the parameter type from the array's element type without requiring an explicit annotation. This is a common exam trick question because students often assume unannotated parameters are implicitly 'any', but contextual typing from the surrounding call fills in the type automatically.

Yes, it compiles. The ternary's condition typeof x === 'number' narrows x to number in the 'true' branch, allowing x * 2, and by process of elimination narrows x to string in the 'false' branch, allowing x.repeat(2). This is exhaustive narrowing across a two-member union using typeof, a classic exam pattern for testing understanding of control-flow narrowing inside expressions, not just if-statements.