TypeScript - Fundamentals & Advanced Type Systems Flashcards

Question 1

`Partial<T>` Utility Type

Accepted Answer

Constructs a type with all properties of `T` set to optional (`?`).

**Implementation under the hood:**
```typescript
type Partial<T> = {
  [P in keyof T]?: T[P];
};
```

Question 2

`Required<T>` Utility Type

Accepted Answer

Constructs a type consisting of all properties of `T` set to required, removing optional modifiers (`?`).

**Implementation:**
```typescript
type Required<T> = {
  [P in keyof T]-?: T[P];
};
```

Question 3

`any` vs. `unknown`

Accepted Answer

`any` opts out of type checking entirely, allowing any operation without compile-time verification. `unknown` is the type-safe counterpart; any value can be assigned to `unknown`, but operations on it are prohibited until type narrowing or explicit type assertions are applied.

Question 4

Union Types (`|`) vs. Intersection Types (`&`)

Accepted Answer

A **Union Type** (`A | B`) represents a value that can be *either* type `A` or type `B`. An **Intersection Type** (`A & B`) combines multiple types into one, requiring the value to satisfy *all* constituent types simultaneously.

Question 5

`interface` vs. `type` Alias

Accepted Answer

**`interface`** defines object shapes and supports declaration merging (re-opening interfaces) and OOP-style `extends`. **`type`** aliases can represent object shapes, primitive types, unions, tuples, and mapped types, but cannot be re-opened for declaration merging.

Question 6

Generic Syntax (`<T>`)

Accepted Answer

Generics provide variable components to type definitions, allowing functions, classes, and interfaces to operate over multiple types while maintaining strict type safety. Syntax: `function identity<T>(arg: T): T { return arg; }`.

Question 7

User-Defined Type Guards (`is` operator)

Accepted Answer

Functions returning a type predicate in the format `arg is Type` to explicitly narrow types. Example:
```typescript
function isString(val: unknown): val is string {
  return typeof val === "string";
}
```
When returning `true`, TypeScript narrows `val` to `string` in the calling scope.

Question 8

`Readonly<T>` Utility Type

Accepted Answer

Constructs a type with all properties of `T` marked as `readonly`, preventing property reassignment at compile time.

**Implementation:**
```typescript
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};
```

Question 9

`Pick<T, K>` Utility Type

Accepted Answer

Constructs a type by selecting the set of properties `K` (string literal or union of keys) from object type `T`.

**Example:**
```typescript
type UserPreview = Pick<User, "id" | "name">;
```

Question 10

`Omit<T, K>` Utility Type

Accepted Answer

Constructs a type by picking all properties from `T` and then removing property keys specified in `K`.

**Example:**
```typescript
type UserWithoutPassword = Omit<User, "password">;
```

Question 11

`Record<K, T>` Utility Type

Accepted Answer

Constructs an object type whose property keys are `K` and whose property values are `T`.

**Example:**
```typescript
type PageInfoMap = Record<string, { title: string }>;
```

Question 12

The `never` Type

Accepted Answer

Represents values that *never* occur. It is assigned to functions that always throw an error or never return (infinite loops), and serves as the bottom type in exhaustiveness checking within `switch`/`if` blocks.

Question 13

Strict Mode Flag: `strictNullChecks`

Accepted Answer

When enabled, `null` and `undefined` are not assignable to other types unless explicitly included in a union (e.g., `string | null`). This prevents runtime "cannot read property of undefined" crashes.

Question 14

Strict Mode Flag: `noImplicitAny`

Accepted Answer

A compiler flag that raises type errors on expressions and declarations that default to an implied `any` type when TypeScript cannot infer a specific type automatically.

Question 15

Discriminated Unions

Accepted Answer

A design pattern where members of a union share a single common literal property (the "discriminant"). TypeScript uses this common field to automatically narrow the union in conditional or `switch` blocks.

Question 16

Conditional Types

Accepted Answer

Types that select one of two branches based on a type relationship test.

**Syntax:**
`T extends U ? X : Y`
If type `T` is assignable to `U`, the type evaluates to `X`; otherwise, it evaluates to `Y`.

Question 17

The `infer` Keyword in Conditional Types

Accepted Answer

Used within the `extends` clause of a conditional type to declare a dynamic type variable that TypeScript infers inside the true branch.

**Example:**
```typescript
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
```

Question 18

Mapped Types

Accepted Answer

Allows creating new types by transforming property types over an existing index signature or key set.

**Syntax:**
```typescript
type Flags<T> = {
  [K in keyof T]: boolean;
};
```

Question 19

`keyof` Type Operator

Accepted Answer

Takes an object type and produces a string or numeric literal union of its key names.

**Example:**
For `type Point = { x: number; y: number }`, `keyof Point` produces `'x' | 'y'`.

Question 20

Indexed Access Types (`T[K]`)

Accepted Answer

Look up a specific property's type on another type.

**Example:**
```typescript
type User = { id: number; name: string };
type UserId = User["id"]; // Evaluates to number
```

Question 21

`const` Assertions (`as const`)

Accepted Answer

Constructs literal types for expressions, making object properties `readonly`, array expressions `readonly` tuples, and preventing literal values (like strings or numbers) from being widened to their base types.

TypeScript - Fundamentals & Advanced Type Systems

Cards in this deck

Related Flashcard Sets

HSK 1 - Basic Chinese Vocabulary, Pinyin & Character Recognition

Functional Programming - Immutability, Pure Functions & Higher-Order Functions

Neuroscience - Neuroanatomy & Brain Function

Microsoft Azure Administrator (AZ-104) - Compute, Storage & Networking