JavaScript Private Properties

Last Updated : 28 Jan, 2026

Private properties are variables that cannot be accessed directly from outside the class in which they are defined. They support encapsulation, a key principle of object-oriented programming (OOP), by keeping internal data protected and manageable.

  • Restrict direct external access to class data.
  • Allow interaction only through controlled class methods.
  • Reduce unintended side effects and improve code reliability.
  • Implemented using modern JavaScript syntax for better security and clarity.

Creating a Private Property in JavaScript

To illustrate private properties, let's consider a simple User class where each user has a unique ID. We want to ensure that this ID cannot be changed directly from outside the class.

Here's how you might define the User class with a public property:

JavaScript 
class User {
    constructor(id) {
        this.id = id; // Public property
    }
}

const user = new User('123');
console.log(user.id); 

user.id = '321';
console.log(user.id);

In the example above, the id property is public, meaning it can be accessed and modified directly from outside the class. This could lead to potential issues if the ID is inadvertently changed.

To convert this into a private property, you can use the new private field syntax by adding a # before the property name:

JavaScript 
class User {
    #id; // Private property
    
    constructor(id) {
        this.#id = id;
    }

    // Method to access the private ID
    getId() {
        return this.#id;
    }

    // Method to change the private ID
    changeId(newId) {
        this.#id = newId;
    }
}

const user = new User('123');
console.log(user.getId()); // Output: 123

// Attempting to access or modify the private property directly will result in an error
user.#id = '321'; // SyntaxError: Private field '#id' must be declared in an enclosing class

// Changing the ID through the class method
user.changeId('321');
console.log(user.getId()); // Output: 321

Features of Private Properties

  1. Private Fields Syntax: The # symbol is used before the property name to declare it as private. This is a recent addition to JavaScript and ensures that the property is only accessible within the class.
  2. Encapsulation: By using private properties, you ensure that critical data cannot be altered from outside the class. This makes your code more robust and secure.
  3. Controlled Access: You can provide controlled access to private properties through methods defined within the class, as shown with the getId and changeId methods in the example.

Limitations and Browser Support

While private properties add a valuable layer of protection, they come with some limitations:

  • Not Yet Universally Supported: The private fields syntax (#) is a relatively new feature and may not be supported in all JavaScript environments, especially older browsers. Developers might need to use polyfills or transpilers like Babel to ensure compatibility.
  • No Access Outside the Class: Once a property is marked as private using #, it cannot be accessed or modified outside the class by any means, making it a strictly controlled entity.
Comment

Explore