JavaScript: Public, Private and Protected

JavaScript is an object-oriented programming language that allows developers to create objects with properties and methods. In JavaScript, objects have properties that can be either public, private, or protected. Understanding the differences between these types of properties is essential to creating secure and efficient code.

Public Properties

Public properties are accessible to anyone who can access the object. They are defined using the this keyword and can be accessed outside of the object using the dot notation. Public properties are commonly used to store information that needs to be shared with other parts of the code. Here is an example of a public property:

function Person(name) {
  this.name = name; // Public property
}

var john = new Person("John");
console.log(john.name); // Output: John

In this example, we have defined a Person object with a public name property. The name property is accessible outside of the object using the dot notation.

Private Properties

Private properties are not accessible outside of the object. They are defined using the let or const keywords and can only be accessed within the object using closures. Private properties are commonly used to store information that should not be exposed to other parts of the code. Here is an example of a private property:

function Person(name, age) {
  const ageLimit = 18; // Private property
  let isAdult = age >= ageLimit; // Private property

  this.name = name; // Public property

  this.isAdult = function() {
    return isAdult;
  }
}

var john = new Person("John", 25);
console.log(john.isAdult()); // Output: true
console.log(john.ageLimit); // Output: undefined

In this example, we have defined a Person object with private ageLimit and isAdult properties. The ageLimit property is a constant that cannot be changed outside of the object. The isAdult property is a boolean value that is calculated based on the age property passed into the constructor. The isAdult property is exposed outside of the object using a public method.

Protected Properties

Protected properties are accessible only to the object and its descendants. They are defined using the _ symbol at the beginning of the property name. Protected properties are commonly used to store information that needs to be accessed by child objects. Here is an example of a protected property:

function Animal() {
  this._legs = 4; // Protected property
}

function Dog() {
  Animal.call(this); // Inherit Animal properties

  this.bark = function() {
    console.log("Woof!");
  }
}

var fido = new Dog();
console.log(fido._legs); // Output: 4

In this example, we have defined an Animal object with a protected _legs property. The Dog object inherits the _legs property from the Animal object using the call() method. The _legs property is accessible within the Dog object and its descendants, but not outside of the object.

In conclusion, understanding the differences between public, private, and protected properties in JavaScript is crucial to writing secure and efficient code. Public properties are accessible outside of the object, private properties are not, and protected properties are only accessible to the object and its descendants. By using these property types effectively, developers can create objects that are both flexible and secure.