TypeScript Essentials - Types, Interfaces & Generics Flashcards

Question 1

What is TypeScript?

Accepted Answer

TypeScript is a strongly typed, open-source programming language developed by Microsoft that builds on JavaScript by adding static type definitions. TypeScript code compiles (transpiled) down to plain JavaScript.

Question 2

Primitive Types

Accepted Answer

TypeScript supports JavaScript's primitive types: `number`, `string`, `boolean`, `null`, `undefined`, `symbol`, and `bigint`.

```typescript
let count: number = 42;
let name: string = "Alice";
let isActive: boolean = true;
```

Question 3

Type Annotation

Accepted Answer

An explicit mechanism to specify the intended type of a variable, function parameter, or return value using a colon (`:`).

```typescript
function add(a: number, b: number): number {
  return a + b;
}
```

Question 4

Type Inference

Accepted Answer

TypeScript automatically determines and assigns a type to a variable based on its initial value when no explicit type annotation is provided.

```typescript
let message = "Hello World"; // Inferred as string
```

Question 5

The `any` Type

Accepted Answer

A escape hatch type that disables all static type checking for a variable. Usage of `any` allows reading/writing arbitrary properties and calling non-existent methods without compile-time errors.

Question 6

The `unknown` Type

Accepted Answer

A type-safe counterpart to `any`. Represents any value, but TypeScript prevents performing arbitrary operations on an `unknown` variable until its type is narrowed via explicit type checks.

Question 7

The `void` Return Type

Accepted Answer

Indicates that a function does not return a value (or returns `undefined`).

```typescript
function logMessage(msg: string): void {
  console.log(msg);
}
```

Question 8

The `never` Type

Accepted Answer

Represents values that *never* occur. It is used as the return type for functions that always throw an exception or enter an infinite loop, or for impossible branches in type narrowing.

Question 9

Arrays vs. Tuples

Accepted Answer

An **Array** holds an arbitrary number of elements of a specific type (`number[]`). A **Tuple** represents an array with a fixed number of elements where each position has a specific type.

```typescript
let list: number[] = [1, 2, 3];
let tuple: [string, number] = ["Age", 30];
```

Question 10

Type Alias (`type`)

Accepted Answer

A syntax used to create a custom name for any type, including primitives, unions, intersections, and object structures.

```typescript
type ID = string | number;
type Point = { x: number; y: number };
```

Question 11

Union Types

Accepted Answer

A type created by combining two or more existing types using the pipe (`|`) operator. A value of a union type can be any one of those types.

```typescript
let result: string | number;
result = "Success"; // Valid
result = 200;       // Valid
```

Question 12

Intersection Types

Accepted Answer

A type created by combining multiple types using the ampersand (`&`) operator. An object of an intersection type must contain all members of all combined types.

```typescript
type Person = { name: string };
type Employee = { id: number };
type Staff = Person & Employee;
```

Question 13

Literal Types

Accepted Answer

Types that accept exact predefined values rather than broad categories like `string` or `number`.

```typescript
type Direction = "NORTH" | "SOUTH" | "EAST" | "WEST";
let move: Direction = "NORTH";
```

Question 14

Interface Definition

Accepted Answer

An `interface` defines the structure or shape of an object, specifying property names and their corresponding types.

```typescript
interface User {
  id: number;
  username: string;
}
```

Question 15

Optional Properties (`?`)

Accepted Answer

Properties in an interface or type alias that do not need to be provided when instantiating the object, marked with a `?` operator.

```typescript
interface Profile {
  username: string;
  bio?: string; // Optional
}
```

Question 16

Readonly Properties

Accepted Answer

Properties marked with the `readonly` keyword can only be assigned during object initialization and cannot be modified afterward.

```typescript
interface Config {
  readonly apiKey: string;
}
```

Question 17

Extending Interfaces

Accepted Answer

Interfaces can inherit properties from other interfaces using the `extends` keyword to build modular object shapes.

```typescript
interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}
```

Question 18

Declaration Merging

Accepted Answer

A feature unique to `interface` where multiple interface declarations sharing the same name in the same scope automatically merge their definitions into a single interface. Type aliases (`type`) cannot do this.

Question 19

Interface vs. Type Alias

Accepted Answer

- **`interface`**: Best for defining object shapes/contracts, supports extension via `extends` and declaration merging.
- **`type`**: More flexible; supports primitives, unions (`|`), intersections (`&`), and tuples, but does not support declaration merging.

Question 20

Generics Overview

Accepted Answer

Generics enable components to work with a variety of types rather than a single one, providing type safety without sacrificing code reusability using type parameters (e.g., `<T>`).

Question 21

Generic Functions

Accepted Answer

Functions that capture type arguments using angle brackets ``, allowing the argument and return types to be dynamically linked. ```typescript function identity(arg: T): T { return arg; } let output = identity("Hello"); ```

Question 22

Generic Interfaces

Accepted Answer

Interfaces that accept type parameters, allowing flexible and reusable data structures.

```typescript
interface ApiResponse<Data> {
  status: number;
  payload: Data;
}
```

Question 23

Generic Constraints (`extends`)

Accepted Answer

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

```typescript
function getLength<T extends { length: number }>(item: T): number {
  return item.length;
}
```

Question 24

The `keyof` Operator

Accepted Answer

An indexed type query operator that produces a string or numeric literal union of all keys in a given type.

```typescript
interface Car {
  make: string;
  model: string;
}
type CarKeys = keyof Car; // "make" | "model"
```

TypeScript Essentials - Types, Interfaces & Generics

Cards in this deck

Related Flashcard Sets

TypeScript - Advanced Type Systems, Generics & Design Patterns

Harvard ECON1011 - Intermediate Microeconomics: Game Theory & Market Structures

MIT 18.03 - Differential Equations: Ordinary Differential Equations, Laplace & Fourier

CPA Exam FAR - Financial Accounting & Reporting: US GAAP & Revenue Recognition