Privacy and Static Members

Introduction: Protecting Your Data

In our first lesson, we learned how to create blueprints for objects using the class keyword. We used the constructor to set initial properties, like a person's name or a book's title . While that approach is a great start, it has a small problem: any part of your program can reach inside your object and change that data. For example, if you have a bank account object with a balance, you probably do not want someone to accidentally set that balance to a negative number or a piece of text. In professional software development, we use a concept called encapsulation . This means we bundle the data and the methods that work on that data together, but we also hide the "innards" of the object from the outside world. By the end of this lesson, you will know how to use private fields to hide sensitive data, and how to use getters and setters to provide a safe way for others to interact with that data.

Private Instance Fields With

Up until recently, JavaScript did not have a way to truly hide data inside a class. Developers often used a naming convention, like putting an underscore before a variable name (such as _balance), to tell others, "Please do not touch this." However, this was just a suggestion and did not actually stop anyone from changing the value. Modern JavaScript now includes private fields. To make a property private, you must declare it at the top of your class using the # symbol before its name. Once a property is marked with a #, it can only be accessed or changed inside the code of that specific class. If you try to access it from outside the class, JavaScript will throw a SyntaxError. JavaScriptclass Account { #balance; // This is a private field constructor(balance = 0) { this.#balance = balance; } } const myAccount = new Account(100); // console.log(myAccount.#balance); // This would cause a SyntaxError!class Account { #balance; // This is a private field constructor(balance = 0) { this.#balance = balance; } } const myAccount = new Account(100); // console.log(myAccount.#balance); // This would cause a SyntaxError! In the code above, the #balance field is declared before the constructor. This tells the JavaScript engine that this piece of data is "private" to the Account class. When we create an instance called myAccount, the balance is safely tucked away. Because the language itself enforces this rule, it is impossible for another developer to accidentally overwrite the balance from outside the class definition.

Getters: Controlled Read Access

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Setters: Controlled Write Access With Validation

While getters allow us to read data, setters allow us to change it. You might ask, "If we are just going to let people change the value, why make it private in the first place?" The answer is validation. A setter allows us to check the new value before we actually save it to our private field. This ensures our object always stays in a valid state—even when it is first created.

It is also worth noting that if you define a getter without a matching setter, you create a read-only property. Any attempt to assign a new value to it will silently fail in non-strict mode, or throw a TypeError in strict mode. This is a useful pattern when you want to expose a value but guarantee it can never be changed from the outside.

We define a setter using the set keyword. Inside the setter, we can write logic to make sure the data being provided is correct. To ensure the input is a valid number (and not something like NaN, Infinity, or a string), we use Number.isFinite().

JavaScript

class Account {
  #balance;

  constructor(balance = 0) {
    // We assign via the setter to ensure validation runs during creation
    this.balance = balance;
  }

  get balance() {
    return this.#balance;
  }

  set balance(value) {
    if (!Number.isFinite(value) || value < 0) {
      throw new Error("Invalid balance: must be a positive number");
    }
    this.#balance = value;
  }
}

const myAccount = new Account(100);
myAccount.balance = 250; // This works and updates #balance
// myAccount.balance = -50; // This would throw an Error!
// const badAccount = new Account("money"); // This would also throw an Error!

class Account {
  #balance;

  constructor(balance = 0) {
    // We assign via the setter to ensure validation runs during creation
    this.balance = balance;
  }

  get balance() {
    return this.#balance;
  }

  set balance(value) {
    if (!Number.isFinite(value) || value < 0) {
      throw new Error("Invalid balance: must be a positive number");
    }
    this.#balance = value;
  }
}

const myAccount = new Account(100);
myAccount.balance = 250; // This works and updates #balance
// myAccount.balance = -50; // This would throw an Error!
// const badAccount = new Account("money"); // This would also throw an Error!

In this logic, the setter acts as a "guard." By calling this.balance = balance inside the constructor, we make sure that even the very first value passed to the class is checked. This prevents our account from ever having a negative balance or an invalid numeric value.

Putting It All Together: The Account Class

Now that we have explored all these individual parts, let’s look at how they work together in a complete, professional example. This Account class uses private fields to protect the balance, a private static field to track the total number of accounts, and accessors to manage how this data is used.

JavaScript

"use strict";

class Account {
  #balance;                  // truly private — enforced by the language
  static #count = 0;         // private static state

  constructor(owner, balance = 0) {
    this.owner = owner;
    // We use the setter to ensure the initial balance follows our rules
    this.balance = balance; 
    Account.#count++;
  }

  static get total() {       // public static accessor
    return Account.#count;
  }

  get balance() {            // controlled read
    return this.#balance;
  }

  set balance(value) {       // controlled write — invariants enforced
    if (!Number.isFinite(value) || value < 0) {
      throw new Error("Invalid balance");
    }
    this.#balance = value;
  }
}

const a = new Account("Ada", 100);
const b = new Account("Grace", 500);

console.log("a.balance:", a.balance);
a.balance = 250;
console.log("a.balance (after set):", a.balance);
console.log("Account.total:", Account.total);

"use strict";

class Account {
  #balance;                  // truly private — enforced by the language
  static #count = 0;         // private static state

  constructor(owner, balance = 0) {
    this.owner = owner;
    // We use the setter to ensure the initial balance follows our rules
    this.balance = balance; 
    Account.#count++;
  }

  static get total() {       // public static accessor
    return Account.#count;
  }

  get balance() {            // controlled read
    return this.#balance;
  }

  set balance(value) {       // controlled write — invariants enforced
    if (!Number.isFinite(value) || value < 0) {
      throw new Error("Invalid balance");
    }
    this.#balance = value;
  }
}

const a = new Account("Ada", 100);
const b = new Account("Grace", 500);

console.log("a.balance:", a.balance);
a.balance = 250;
console.log("a.balance (after set):", a.balance);
console.log("Account.total:", Account.total);

Output:

text

a.balance: 100
a.balance (after set): 250
Account.total: 2

a.balance: 100
a.balance (after set): 250
Account.total: 2

In this final example, the Account class is fully protected. The #balance is hidden from the outside, but we can still interact with it safely through the balance getter and setter. By calling the setter within the constructor, we ensure that an Account can never be created with an invalid balance. This structure is a perfect example of modern, clean, and safe JavaScript code.

Introduction: Protecting Your Data

Private Instance Fields With

Getters: Controlled Read Access

Join the 1M+ learners on CodeSignal

Setters: Controlled Write Access With Validation

Static Properties And Methods

Private Static Fields

Putting It All Together: The Account Class

Summary And What's Next