TypeScript - Advanced Types, Interfaces & Modern Development Flashcards

Question 1

Tuple Types

Accepted Answer

Fixed-length arrays where each element has a specific, known type at a designated index.

Example:
```typescript
type Response = [number, string]; // [200, "OK"]
```

Question 2

Declaration Merging

Accepted Answer

A TypeScript feature where multiple `interface` declarations with the same name in the same scope automatically merge their definitions into a single combined interface.

Question 3

Numeric vs String Enums

Accepted Answer

Enums define sets of named constants. Numeric enums auto-increment starting from `0` and support reverse mapping (`Enum[0]`). String enums require explicit string initializers for each member and do not support reverse mapping.

Question 4

Interface vs Type Alias

Accepted Answer

`interface` defines object shapes and supports *declaration merging* (re-opening types). `type` aliases can represent objects, primitives, unions, intersections, and tuples, but cannot be re-opened once declared.

Question 5

Discriminated Unions

Accepted Answer

A pattern for combining union types containing a common literal property (the "discriminant"). It allows TypeScript to automatically narrow down the specific type in conditional blocks.

Example:
```typescript
type Action = 
  | { type: 'square'; size: number }
  | { type: 'rectangle'; width: number; height: number };
```

Question 6

`any` vs `unknown`

Accepted Answer

`any` disables type checking completely, allowing any operation or property access without verification. `unknown` is a type-safe counterpart; values of type `unknown` cannot be accessed, called, or assigned to other typed variables without prior type narrowing or assertions.

Question 7

The `never` Type

Accepted Answer

Represents the type of values that never occur. It is used for functions that never return (e.g., those that always throw errors or contain infinite loops) and for exhausting switch branches in type discrimination.

Question 8

`void` vs `undefined`

Accepted Answer

`void` indicates that a function does not return a meaningful value (its return value is ignored). `undefined` is a concrete JavaScript primitive value representing an unassigned variable or explicitly missing return value.

Question 9

Union (`|`) 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 a value to satisfy *all* constituent properties simultaneously.

Question 10

Literal Types

Accepted Answer

Types that specify exact, concrete values (strings, numbers, or booleans) rather than general types.

Example:
```typescript
type Direction = 'north' | 'south' | 'east' | 'west';
```

Question 11

Generics (`<T>`)

Accepted Answer

A tool for creating reusable code components that work over a variety of types while preserving explicit type safety.

Example:
```typescript
function identity<T>(arg: T): T {
  return arg;
}
```

Question 12

Generic Constraints (`extends`)

Accepted Answer

Limits the types that can be passed to a generic parameter using the `extends` keyword.

Example:
```typescript
function logLength<T extends { length: number }>(arg: T): T {
  console.log(arg.length);
  return arg;
}
```

Question 13

The `keyof` Type Operator

Accepted Answer

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

Example:
```typescript
type Person = { name: string; age: number };
type PersonKeys = keyof Person; // 'name' | 'age'
```

Question 14

The `typeof` Type Operator

Accepted Answer

Used in type contexts to extract the TypeScript type of an existing JavaScript variable or object.

Example:
```typescript
const config = { host: 'localhost', port: 8080 };
type Config = typeof config; // { host: string; port: number }
```

Question 15

Mapped Types

Accepted Answer

Generic types that transform properties by iterating over keys using `in keyof` syntax.

Example:
```typescript
type OptionsFlags<T> = {
  [Property in keyof T]: boolean;
};
```

Question 16

Conditional Types

Accepted Answer

Selects one of two types based on a type relationship test using ternary syntax.

Syntax:
`T extends U ? X : Y` (Evaluates to `X` if `T` is assignable to `U`, else `Y`).

Question 17

The `infer` Keyword

Accepted Answer

Used inside conditional types to introduce a type variable that is automatically inferred within the true branch.

Example:
```typescript
type UnpackArray<T> = T extends (infer U)[] ? U : T;
```

Question 18

Utility Types: `Partial` & `Required`

Accepted Answer

`Partial` returns a type with all properties of `T` set to optional (`?`). `Required` returns a type with all optional properties of `T` set to mandatory (`-?`).

Question 19

Utility Types: `Pick` & `Omit`

Accepted Answer

`Pick` constructs a type by selecting a set of keys `K` from type `T`. `Omit` constructs a type by copying all properties from `T` and then removing the specified keys `K`.

Question 20

Declaration Files (`.d.ts`)

Accepted Answer

Files containing only TypeScript type information without runtime JavaScript code. They are used to describe existing JavaScript libraries or ambient global variables to the TypeScript compiler.

Question 21

`tsconfig.json`: `strict` Flag

Accepted Answer

Enables a suite of strict type-checking options, including `noImplicitAny`, `strictNullChecks`, `strictFunctionTypes`, and `strictPropertyInitialization`, maximizing type safety throughout the codebase.

TypeScript - Advanced Types, Interfaces & Modern Development

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