Encapsulation

• Encapsulation in JavaScript is a concept that refers to bundling the data (variables) and methods (functions) that operate on the data into a single unit, typically known as a class.

• It allows you to control access to the data, ensuring that it's accessed and modified only through the defined methods.

• This helps in keeping the internal state of an object consistent and prevents external code from directly manipulating it, thus promoting data integrity and security.

class Car {
  constructor(make, model, year) {
    this.make = make;     // Public property
    this.model = model;   // Public property
    this.year = year;     // Public property
    this._mileage = 0;    // Private property (indicated by underscore convention)
  }

  // Public method to retrieve mileage
  getMileage() {
    return this._mileage;
  }

  // Public method to update mileage
  drive(distance) {
    this._mileage += distance;
    console.log(`You've driven ${distance} miles. Total mileage: ${this._mileage}`);
  }
}

// Creating an instance of Car
let myCar = new Car('Toyota', 'Camry', 2020);

// Accessing public properties
console.log(myCar.make);   // Output: Toyota

// Accessing private property (not recommended)
console.log(myCar._mileage);  // Output: 0 (Encapsulation is not enforced strictly in JavaScript)

// Accessing through public method (recommended)
console.log(myCar.getMileage()); // Output: 0

// Driving the car
myCar.drive(100); // Output: You've driven 100 miles. Total mileage: 100

// Trying to update mileage directly (not recommended)
myCar._mileage = 500; // We can still access private properties directly, but it's not a good practice

// Encapsulation helps to prevent unintentional direct modification of properties:
console.log(myCar.getMileage()); // Output: 100 (Still the original value, not 500)

In this example:

• Car class encapsulates the properties make, model, and year, along with the _mileage property which is intended to be private (though JavaScript doesn't strictly enforce this).

• Methods like getMileage() and drive(distance) provide controlled access to the _mileage property, allowing its retrieval and modification in a controlled manner.

• While JavaScript doesn't have strict visibility modifiers like some other languages, developers typically use naming conventions (like prefixing private members with an underscore) to indicate which properties or methods are intended to be private. However, these can still be accessed and modified directly, which is why encapsulation in JavaScript is more about convention and intention rather than strict enforcement.