TypeScript - Modern JavaScript Development & Type Safety Flashcards

Question 1

`unknown` vs. `any`

Accepted Answer

`any` disables all type checking. `unknown` is type-safe: it accepts any value, but forces type checking or narrowing before performing operations on that value.

Question 2

`never` Type

Accepted Answer

Represents values that *never* occur. Commonly used for functions that always throw an exception, contain infinite loops, or to enforce exhaustive checks in switch cases.

Question 3

TypeScript Compilation Process

Accepted Answer

TypeScript is a statically typed superset of JavaScript. The TypeScript compiler (`tsc`) performs type checking at compile time and transpiles `.ts` files down to plain JavaScript, removing all type annotations for execution.

Question 4

`tsconfig.json`

Accepted Answer

The central configuration file for a TypeScript project. It specifies root files and compiler options, such as `target` (JavaScript version output), `module` system, `strict` mode flags, and `outDir`.

Question 5

Primitive Types in TypeScript

Accepted Answer

Built-in basic types corresponding directly to JavaScript primitives: `string`, `number`, `boolean`, `null`, `undefined`, `symbol`, and `bigint`.

Question 6

Union Types (`|`)

Accepted Answer

A construct that allows a variable to hold values of two or more distinct types. For example: `let id: string | number;` allows `id` to be either a `string` or a `number`.

Question 7

Intersection Types (`&`)

Accepted Answer

Combines multiple types into one, requiring an object to satisfy *all* constituent properties. Example: `type AdminUser = User & Permissions;`.

Question 8

Interface vs. Type Alias

Accepted Answer

`interface` defines object shapes and supports declaration merging (can be extended/re-opened). `type` (Type Alias) creates a name for any type, including primitives, unions, tuples, and objects, but cannot be re-opened.

Question 9

Type Inference

Accepted Answer

TypeScript's automatic deduction of variable types or function return types based on initial values or code logic without explicit type annotations (e.g., `let x = 42;` infers `x` as `number`).

Question 10

Numeric vs. String Enums

Accepted Answer

Enums declare named constants. **Numeric enums** auto-increment from 0 (`enum Direction { Up, Down }`), whereas **String enums** require explicit string initializers (`enum Direction { Up = "UP" }`) and offer better runtime debuggability.

Question 11

Generics (`<T>`)

Accepted Answer

Components that work over a variety of types rather than a single one, preserving type safety. Example:
```typescript
function identity<T>(arg: T): T {
  return arg;
}
```

Question 12

Generic Constraints (`extends`)

Accepted Answer

Restricts the types that can be passed to a generic parameter using the `extends` keyword. Example: `<T extends { length: number }>` ensures `T` possesses a numeric `length` property.

Question 13

Type Guards

Accepted Answer

Runtime checks that allow TypeScript to narrow down a broad type (like a union) to a more specific type within a conditional block using operators like `typeof`, `instanceof`, or `in`.

Question 14

Custom Type Predicates (`is`)

Accepted Answer

Functions whose return type signature uses `arg is Type`. Example:
```typescript
function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}
```

Question 15

Class Access Modifiers

Accepted Answer

TypeScript provides three access controls for class members:
- `public`: Accessible anywhere (default).
- `private`: Accessible only within the defining class.
- `protected`: Accessible within the class and its subclasses.

Question 16

Utility Type: `Partial<T>`

Accepted Answer

Constructs a type with all properties of `T` set to optional. Useful for update operations where only a subset of properties is required.

Question 17

Utility Type: `Required<T>`

Accepted Answer

Constructs a type with all properties of `T` set to required. It is the exact opposite of `Partial<T>`.

Question 18

Utility Type: `Readonly<T>`

Accepted Answer

Constructs a type with all properties of `T` marked as `readonly`, making the properties immutable after creation.

Question 19

Utility Type: `Pick<T, K>`

Accepted Answer

Constructs a type by selecting a specific subset of property keys `K` from type `T`. Example: `Pick<User, "id" | "email">`.

Question 20

Utility Type: `Omit<T, K>`

Accepted Answer

Constructs a type by taking all properties from `T` and removing the specified keys `K`. Example: `Omit<User, "password">`.

Question 21

Utility Type: `Record<K, T>`

Accepted Answer

Constructs an object type whose keys are of type `K` and values are of type `T`. Example: `Record<string, number>` creates a dictionary mapping string keys to numeric values.

TypeScript - Modern JavaScript Development & Type Safety

Cards in this deck

Related Flashcard Sets

Monash FIT9132 - Data Mining & Machine Learning Fundamentals

Biochemistry - Metabolic Pathways & Regulation

JLPT N2 - Advanced Japanese Grammar, Vocabulary & Kanji

CPA Exam - AUD (Auditing and Attestation)