Private class members

JavaScript is a constantly evolving programming language, with new features and updates being released regularly. One such feature that is sure to blow developers’ minds in ES2022 is the introduction of the JavaScript private fields.

JavaScript has always had a somewhat weak support for encapsulation and data hiding, which is a fundamental principle of object-oriented programming. In the past, developers have used various techniques such as closures and WeakMap to emulate private fields, but they are often complex and hard to understand. With the introduction of private fields in ES2022, developers can now create truly private fields in JavaScript classes, making it easier to write robust, maintainable and secure code.

To create a private field, developers simply need to prefix the field name with a “#” symbol. For example, the following code creates a private field called “_secret” in a class called “MyClass”:

class MyClass {
  #_secret;

  constructor(secret) {
    this.#_secret = secret;
  }
}

Once a private field has been defined, it can only be accessed within the class or its subclasses, making it truly private and inaccessible from the outside world. This can help to prevent accidental or intentional data leaks and improve the overall security of the application.

In addition, private fields can also be used in conjunction with getters and setters to provide controlled access to the data. For example, the following code creates a private field called “_name” and a getter called “name” that allows the value of the field to be read but not modified.

class MyClass {
  #_name;

  constructor(name) {
    this.#_name = name;
  }

  get name() {
    return this.#_name;
  }
}

One of the most interesting aspect of private fields is that they are also fully supported by the JavaScript reflection API. This means that, unlike closures and WeakMap, private fields are fully inspectable and debuggable. For example, the following code uses the Object.getOwnPropertyDescriptor method to inspect a private field:

console.log(Object.getOwnPropertyDescriptor(MyClass.prototype, "#_secret"));

Another great feature of private fields is that they can also be used in combination with other ES2022 features like decorators. Decorators are a new way of adding metadata to class members, which can be used for things like type checking, performance optimization, and more. For example, the following code uses a decorator to add a type check to a private field:

class MyClass {
  @type("string")
  #_name;

  constructor(name) {
    this.#_name = name;
  }
}

In conclusion, the introduction of private fields in ES2022 is a game-changer for JavaScript developers. It allows for true encapsulation and data hiding in JavaScript classes, making it easier to write robust, maintainable and secure code. Private fields are also fully supported by the JavaScript reflection API, making them fully inspectable and debuggable. And they can be used in combination with other ES2022 features like decorators, making them even more powerful. With the growing popularity of JavaScript, it’s the perfect time for developers to start learning and incorporating these new features into their projects.

Categorised in: Javascript

This post was written by Prem