TypeScript Quiz

1. What happens to type annotations when TypeScript compiles to JavaScript?

• They become runtime checks
• They are removed entirely
• They become JSDoc comments
• They are kept as comments

Types are erased at compile time; the output is ordinary JavaScript (lesson 01).

2. Which declaration is inferred as the literal type "draft"?

• let status = "draft";
• const status = "draft";
• var status = "draft";
• let status: string = "draft";

A const can never change, so TypeScript keeps the exact literal type (lesson 04).

3. Which type accepts any value but forces you to narrow it before use?

• any
• never
• unknown
• object

unknown is the safe counterpart to any (lesson 05).

4. What is the return type of a function that always throws?

• void
• undefined
• never
• unknown

It can never produce a value, so its return type is never (lesson 05).

5. What does readonly string[] prevent?

• Calling mutating methods like push
• Reading elements by index
• Using map and filter
• Passing the array to functions

Readonly arrays remove the methods that modify the array (lesson 06).

6. How do you write a tuple of a string followed by a number?

• (string | number)[]
• Array<string, number>
• [string, number]
• { string; number }

Tuples list one type per position in square brackets (lesson 07).

7. Which can an interface do that a type alias cannot?

• Describe an object shape
• Be extended by another type
• Be declared twice and merged
• Have optional properties

Interfaces support declaration merging; duplicate type aliases are an error (lessons 09 and 34).

8. What does a string enum NOT generate that a numeric enum does?

• A runtime object
• A reverse mapping from value to name
• Named members
• A type you can annotate with

Only numeric enums get reverse mappings like Status[1] === "Shipped" (lesson 10).

9. Given value: string | number, which call compiles without narrowing?

• value.toUpperCase()
• value.toFixed(2)
• value.toString()
• value.length

Only members shared by every type in the union are allowed (lesson 12).

10. What does 0 ?? 20 evaluate to?

• 0
• 20
• undefined
• null

?? only falls back for null or undefined, so 0 is kept (lesson 13).

11. What does a type assertion like value as number do at runtime?

• Converts the value to a number
• Throws if the value isn't a number
• Nothing — it only changes what the compiler believes
• Returns NaN for non-numbers

Assertions are erased; use Number() for real conversion (lesson 14).

12. What does the satisfies operator do?

• Converts a value to a type
• Checks a value against a type while keeping its inferred type
• Disables excess property checks
• Makes all properties readonly

satisfies validates without widening (lesson 14).

13. In a set of function overloads, which signature can callers NOT use directly?

• The first overload
• The last overload
• The implementation signature
• Any overload with optional parameters

Only the overload signatures are visible; the implementation signature is hidden (lesson 16).

14. What does constructor(private name: string) {} do?

• Declares a parameter only
• Declares and assigns a private property in one step
• Creates a static property
• Is a syntax error

This is a parameter property (lesson 17).

15. Which access modifier lets subclasses — but not outside code — access a member?

• private
• protected
• public
• readonly

protected members are visible to the class and its subclasses (lesson 18).

16. What is true of an abstract class?

• It can't contain implemented methods
• It can't be instantiated with new directly
• It disappears at compile time
• A class can extend several of them

Abstract classes are partial classes meant to be extended (lesson 18).

17. What does the T in function first<T>(items: T[]): T represent?

• A runtime parameter
• A type parameter filled in when the function is called
• The this type
• A tuple type

Generics take types as parameters, usually inferred from arguments (lesson 20).

18. What does K extends keyof T mean?

• K is a subclass of T
• K must be one of T's property names
• K has all of T's properties
• K is a copy of T

keyof T is a union of property names, and extends constrains K to it (lessons 21 and 24).

19. Which return type makes isCat(pet) narrow pet when it returns true?

• boolean
• Cat
• pet is Cat
• asserts Cat

A type predicate tells TypeScript what a true result means (lesson 23).

20. In an exhaustive switch, what type is the value in the default branch once every case is handled?

• unknown
• any
• never
• undefined

Assigning it to never makes a missing case a compile error (lesson 23).

21. What is (typeof ROLES)[number] when ROLES = ["admin", "user"] as const?

• string
• number
• "admin" | "user"
• readonly string[]

Indexing a readonly tuple type by number gives the union of its elements (lesson 24).

22. What does Record<"a" | "b", number> require?

• At least one of keys a or b
• Both keys a and b, each with a number
• Any string key with number values
• An array of numbers

With a union of literal keys, every key is required (lesson 25).

23. Which utility type removes listed properties from an object type?

• Pick
• Exclude
• Omit
• Extract

Omit works on properties; Exclude works on union members (lessons 26–27).

24. What does Awaited<Promise<string>> produce?

• string
• Promise<string>
• unknown
• void

Awaited unwraps promise types like await does (lesson 27).

25. In a mapped type, what does -? do?

• Makes every property optional
• Removes optionality from every property
• Deletes the property
• Makes properties readonly

A minus prefix removes a modifier; that's how Required works (lesson 28).

26. What is T extends string ? "yes" : "no" when T is string | number?

• "yes"
• "no"
• "yes" | "no"
• never

Conditional types distribute over unions when checking a bare type parameter (lesson 29).

27. Why use import type { User } from "./models"?

• It makes User readonly
• It guarantees the import is removed from compiled JavaScript
• It is required for interfaces
• It loads the module lazily

Type-only imports are always erased (lesson 31).

28. In strict mode, what is the type of err in catch (err)?

• Error
• any
• unknown
• string

Anything can be thrown, so you must narrow it first (lesson 37).

29. Since TypeScript 6.0, what must you do for process from @types/node to be recognised?

• Nothing — all @types packages load automatically
• List "node" in the types compiler option
• Set strict to false
• Import process from "typescript"

The types option now defaults to an empty list (lessons 33 and 38).

30. What is the main change in TypeScript 7.0?

• A new syntax for generics
• The compiler was rewritten as native code, making builds roughly 10× faster
• Removal of interfaces
• Types are now checked at runtime

TypeScript 7 is a native port of the compiler; the language itself is unchanged (lesson 44).