What are Private Members in ES6 Classes?

What are Private Members in ES6 Classes?

JavaScript has evolved significantly since its inception. Traditionally, JavaScript relied on prototype-based inheritance, which was often considered more flexible but also more complex and less intuitive for those familiar with class-based languages such as Java or C#. With the emergence of ECMAScript 6 (ES6) in 2015, JavaScript adopted a more structured, class-based approach to object-oriented programming (OOP), albeit syntactically. This shift paved the way for developers to write more organized and maintainable code.

Understanding ES6 Classes

ES6 classes brought about a more concise and readable way to create objects and handle inheritance. While this was mainly syntactic sugar over the existing prototype-based approach, it made the language more approachable to developers from other OOP backgrounds.

Basic Syntax and Structure

At its core, an ES6 class encapsulates data for the object and methods to manipulate that data. A simple class might look like this:

class Person {
constructor(name, age) {
this.name = name;
this.age = age;

greet() {
console.log(`Hello, I'm ${this.name} and I'm ${this.age} years old.`);

Here, constructor is a special method for creating and initializing objects created from a class. Methods, like greet, are added to the prototype chain.

Public vs Private Members

In OOP, encapsulation is crucial for bundling data (attributes) and methods that operate on that data into a single unit, as well as restricting direct access to some of an object’s components. This is where public and private members come in.

Traditional Approach in JavaScript

Before ES6, JavaScript developers had to employ strategies like closures and the Module Pattern to mimic the behavior of private members. For instance:

function createPerson(name, age) {
return {
greet() {
console.log(`Hello, I'm ${name}.`);

const person = createPerson('Alice', 25);
person.greet(); // Outputs: Hello, I'm Alice.

In the example above, name and age are encapsulated and can’t be accessed directly, but can be utilized within the greet method.

Problems with the Traditional Approach

One of the main issues with this approach is the lack of standardization. Each developer might have their own way of implementing encapsulation, leading to inconsistency. Moreover, it wasn’t very intuitive or clear to other developers reading the code about which members were meant to be private.

Introduction to Private Members in ES6

With ES6, a more standardized way of declaring private members in classes was introduced. This ensures that certain details of an object remain hidden and are not accessible outside of the class.

Why Use Private Members?

Private members serve several purposes:

  1. Encapsulation: To prevent external code from changing an object’s internal state unexpectedly.
  2. Abstraction: To present only the necessary features of an object, hiding the complexity.
  3. Safety: Avoid potential clashes with other methods or fields with the same name.

Private Fields

Private fields in ES6 classes are fields that cannot be accessed or changed from outside the class.

Syntax and Declaration

To declare a private field in an ES6 class, prefix the field name with a # character:

1class Circle {
2 #radius;
4 constructor(radius) {
5 this.#radius = radius;
6 }
8 getArea() {
9 return Math.PI * this.#radius * this.#radius;
10 }

Here, #radius is a private field.

Access and Restrictions

While the private field #radius can be accessed and modified within any method of the Circle class, trying to access it outside of the class will lead to a syntax error:

const circle = new Circle(5);
console.log(circle.#radius); // SyntaxError

Private Methods

Just like private fields, ES6 allows classes to have private methods, which can’t be accessed outside of their class.

Syntax and Usage

Similar to private fields, private methods are prefixed with the # character:

1class Rectangle {
2 #width;
3 #height;
5 constructor(width, height) {
6 this.#width = width;
7 this.#height = height;
8 }
10 #getArea() {
11 return this.#width * this.#height;
12 }
14 printArea() {
15 console.log(`Area: ${this.#getArea()} sq. units.`);
16 }
19const rect = new Rectangle(10, 5);
20rect.printArea(); // Outputs: Area: 50 sq. units.

The method #getArea is private and can’t be called outside the Rectangle class.

Benefits and Limitations of Private Methods

Private methods in ES6 classes offer a clean way to encapsulate the internal workings of a class.


  1. Encapsulation: They ensure that only the desired parts of an object are exposed, ensuring better control and modularity.
  2. Reduced Complexity: End users or developers only need to understand the public API, not the intricate details of the class internals.
  3. Refactor Safety: With private methods, developers can confidently change internal logic without affecting external consumers.


  1. Debugging Difficulties: They can be harder to debug as these members are not directly accessible from outside the class.
  2. Inflexibility: Once declared as private, it cannot be accessed even if a use-case arises where it might be beneficial.

Static Private Fields and Methods

In ES6, along with instance private members, we also have the ability to define static private fields and methods. These members are shared across all instances of the class, and like other static members, they’re associated with the class itself rather than individual instances.

Declaring and Using Static Private Members

To declare a static private field, prepend the field name with static #. For methods, the syntax is static #methodName.

1class MyClass {
2 static #privateStaticField = "This is private and static!";
4 static #privateStaticMethod() {
5 return "Static private method called!";
6 }
8 static publicMethod() {
9 return MyClass.#privateStaticMethod();
10 }

To use them, they must be accessed within the class, typically via public static methods.

Practical Examples

Simple Class Demonstration

Let’s look at a class BankAccount which utilizes private fields and methods:

1class BankAccount {
2 #balance = 0;
4 deposit(amount) {
5 if (this.#isValid(amount)) {
6 this.#balance += amount;
7 return "Amount deposited successfully!";
8 }
9 return "Invalid amount!";
10 }
12 #isValid(amount) {
13 return amount > 0;
14 }

Here, #isValid is a private method ensuring only valid transactions are processed.

Encapsulation in Action

Consider an online voting system:

1class VotingSystem {
2 #votes = [];
4 castVote(candidate) {
5 if (!this.#votes.includes(candidate)) {
6 this.#votes.push(candidate);
7 return "Vote casted for " + candidate;
8 }
9 return "You've already voted for this candidate!";
10 }

The private field #votes ensures data encapsulation and prevents unwanted tampering.

Advanced Considerations

Mix-ins and Inheritance

Private members are truly private. When it comes to inheritance, subclasses cannot directly access or override the private members of their superclasses.

WeakMaps for Encapsulation

Before private fields, developers used WeakMaps for emulating private properties. While both serve the purpose of data hiding, private members provide a more native and streamlined approach. Still, WeakMaps are powerful and allow more complex relationships between objects.

Potential Pitfalls

Common Mistakes

  1. Overusing Private Members: It’s important to strike a balance. Not everything needs to be private.
  2. Forgetting the ‘#’: Omitting the hash might lead to unexpected results.

Compatibility and Tooling

While ES6 and private members have been around for some time, not all environments support them. It’s crucial to ensure browser compatibility or use transpilers like Babel. Also, update linters like ESLint to recognize private member syntax.

Comparison with Other Languages

Languages like Java and C++ have had private members for a long time. JavaScript’s implementation is unique with its # syntax but serves a similar purpose: promoting encapsulation.

Real-world Scenarios

In libraries, frameworks, and large codebases, private members are invaluable. They ensure that internal code can change without affecting countless applications relying on them.

Future Evolution

While ES6 has introduced private members, the JavaScript community is vibrant and active. We can expect improvements in syntactic sugar, capabilities, or even new access modifiers.


Private members in ES6 classes represent a significant step towards mature object-oriented programming in JavaScript. Encouraging encapsulation, they lead to better, more maintainable code. Dive in, experiment, and make the most of this feature in your projects!

References & Further Reading

Happy coding on codedamn!

Sharing is caring

Did you like what Vishnupriya wrote? Thank them for their work by sharing it on social media.


No comments so far