Objects & Type Aliases (type Keyword)

Type Inference & Literal Types (const vs. let)

Discover how TypeScript infers types automatically and how let versus const declarations shape wide types versus narrow literal types.

1. Structuring Object Shapes

Objects are the foundation of JavaScript applications. TypeScript allows you to define explicit object shape contracts to ensure properties and methods match expected schemas.

2. The type Alias Keyword

A Type Alias creates a reusable custom name for any type definition (object shapes, unions, primitives, or tuples):

// Define a reusable object shape type alias
type UserProfile = {
  readonly id: number;      // Readonly property (cannot be reassigned)
  name: string;
  email: string;
  bio?: string;             // Optional property (string | undefined)
};

const user1: UserProfile = {
  id: 101,
  name: "Alex",
  email: "alex@devloom.dev",
};

// user1.id = 999; // Error: Cannot assign to 'id' because it is a read-only property

3. Nested Object Types

Type aliases can be composed and nested cleanly:

type Address = {
  city: string;
  country: string;
};

type Employee = {
  id: number;
  name: string;
  address: Address; // Nested type alias reference
};

4. Excess Property Checks

When assigning an object literal directly to a typed variable, TypeScript performs Excess Property Checks to catch typo bugs:

type Point = { x: number; y: number };

// Error: 'z' does not exist in type 'Point'
// const p: Point = { x: 10, y: 20, z: 30 };

5. Common Mistakes

• Forgetting Optional Checks: Accessing an optional property (user.bio.length) without null checking throws a compile error because bio might be undefined. Use optional chaining user.bio?.length.

6. Next Steps

Use type aliases for custom data structures. Next, let me compare Interfaces versus Type Aliases!