Access Modifiers

Learning objectives#

• Use public, private and protected
• Compare TypeScript private with JavaScript #private
• Combine modifiers with readonly and static
• Design classes with a small public surface

Explanation#

public (the default): accessible from anywhere.

private: accessible only inside the same class. protected: inside the class and its subclasses.

TypeScript’s private is a compile-time check only — at runtime the property is a normal one. JavaScript’s #field is enforced by the engine at runtime. Use #field when real privacy matters.

readonly can be combined with any modifier (private readonly). static members belong to the class itself: Config.defaultTimeout.

Syntax#

1class A {
2  public x = 1;
3  protected y = 2;
4  private z = 3;
5  #w = 4;           // runtime-private
6  static count = 0;
7}

Code example: Who can access what?#

1class Employee {
2  static company = 'Techie Babaji';
3  public name: string;
4  protected salary: number;
5  private pan: string;
6  #bankPin: number;
7

8  constructor(name: string, salary: number, pan: string, pin: number) {
9    this.name = name;
10    this.salary = salary;
11    this.pan = pan;
12    this.#bankPin = pin;
13  }
14}
15

16class Manager extends Employee {
17  bonus() {
18    return this.salary * 0.2;   // ✓ protected is visible in subclasses
19    // return this.pan;         // ✗ Property 'pan' is private and only accessible within class 'Employee'
20  }
21}
22

23const m = new Manager('Asha', 100000, 'ABCDE1234F', 4321);
24m.name;                 // ✓ public
25m.salary;               // ✗ Property 'salary' is protected and only accessible within class 'Employee' and its subclasses
26Employee.company;       // ✓ static, accessed on the class
27

28console.log((m as any).pan);   // 'ABCDE1234F' — TS private is only a compile-time check
29// (m as any).#bankPin           // ✗ impossible even at runtime

TypeScript rejects m.salary and this.pan. Casting to any bypasses TS private (it prints 'ABCDE1234F'), but #bankPin cannot be reached at all.

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. static company belongs to the class, not each employee.
2. Manager can read salary because it is protected.
3. pan is private to Employee — even subclasses cannot see it.
4. Outside code can only use public members.
5. as any skips type checking and exposes the TS-private field at runtime.
6. #bankPin stays private at runtime too.

Real-world use case#

Common mistakes#

Best practices#

• Default to private; make public only what callers need
• Use #private when runtime privacy matters
• Use protected sparingly
• Use private readonly for injected dependencies

Remember this#

Practice exercise#

1class Car {
2  static wheels = 4;
3  constructor(
4    public model: string,
5    protected speed: number,
6    private readonly engineNumber: string,
7  ) {}
8}

Mini quiz#

Want more? Practise all TypeScript MCQs · TypeScript interview questions

Related topics#

My notes#

Saved in this browser.