TypeScript Academy · Lesson

readonly Properties and Parameter Properties

Use readonly and shorthand constructor properties.

Lesson 3 of 413 steps

readonly Properties and Parameter Properties is a free TypeScript Academy lesson on CoddyKit. This is lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, and your progress syncs across the web and the CoddyKit app. The TypeScript Academy course includes 4 lessons in total.

Welcome

readonly prevents properties from being changed after initialization. Parameter properties combine declaration and initialization into a single constructor line.

readonly on Class Properties

Declare a property readonly to allow setting it once (in the constructor) but prevent later changes.

class Invoice {
  readonly invoiceId: string;
  constructor(id: string) { this.invoiceId = id; }
}
const inv = new Invoice('INV-001');
// inv.invoiceId = 'INV-002'; // Error!

readonly in Interfaces

readonly also works in interfaces and object types to prevent property reassignment.

interface Point { readonly x: number; readonly y: number; }
const p: Point = { x: 5, y: 10 };
// p.x = 0; // Error

Parameter Properties

Prefix a constructor parameter with an access modifier to declare a property and assign it in one step.

class Product {
  constructor(
    public name: string,
    public price: number,
    private sku: string
  ) {} // no need to write this.name = name; etc.
}

readonly Parameter Properties

Combine `readonly` with an access modifier for parameter properties.

class Config {
  constructor(
    public readonly host: string,
    public readonly port: number = 3000
  ) {}
}

Initialization in Declarations

You can initialize a readonly property at the point of declaration. It cannot be changed after that.

class AppVersion {
  readonly version: string = '1.0.0';
  readonly buildDate: Date = new Date();
}

readonly vs const

`const` is for block-scoped variables. `readonly` is for class properties and object type members. They serve different scopes.

const API_KEY = 'secret'; // block variable
class Service {
  readonly key: string = API_KEY; // class property
}

Readonly Object Type

The `Readonly` utility type makes all properties of T readonly. Good for creating immutable snapshots.

interface User { name: string; age: number; }
const frozen: Readonly<User> = { name: 'Alice', age: 30 };
// frozen.name = 'Bob'; // Error

readonly Does Not Deep-Freeze

Like ReadonlyArray, readonly only prevents reassignment of the property itself — not mutation of the object the property points to.

class Team {
  readonly members: string[] = [];
}
const t = new Team();
t.members.push('Alice'); // Allowed — the array itself is mutable!
// t.members = []; // Error — can't reassign the property

Parameter Properties Save Boilerplate

Without parameter properties, you write: declare the field, declare the constructor param, and assign. With them, one line does all three.

// Without parameter properties (verbose)
class A {
  private x: number;
  constructor(x: number) { this.x = x; }
}
// With parameter properties (concise)
class B {
  constructor(private x: number) {}
}

When to Avoid Parameter Properties

Some teams avoid parameter properties in large classes because they hide the property declarations from the class body, reducing readability at a glance.

Quick Check

When using a parameter property in TypeScript, what is still TRUE about the readonly modifier?

Answer it in the interactive lesson

Recap

readonly prevents property mutation after construction. Parameter properties (access modifier + param name) declare and initialize properties in one line. Combine both for concise, immutable class designs.

Free to start

Learn TypeScript with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 101
Lessons: 352

Start learning free View the full course

Frequently Asked Questions

Is the “readonly Properties and Parameter Properties” lesson free?

Yes — the full text of “readonly Properties and Parameter Properties” is free to read here on the web. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO. The TypeScript Academy course includes 4 lessons in total.

What will I learn in “readonly Properties and Parameter Properties”?

Use readonly and shorthand constructor properties. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.

How long does the “readonly Properties and Parameter Properties” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

TypeScript Classes and Constructors
public, private, and protected Modifiers
readonly Properties and Parameter Properties
Implementing Interfaces with Classes

← Back to TypeScript Academy