Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

forum

home / developersection / forums / how can you achieve encapsulation in javascript?
Ask Question
Sandra Emily
Sandra Emily

Student

Content writing is the process of writing, editing, and publishing content in a digital format. That content can include blog posts, video or podcast scripts, ebooks or whitepapers, press releases, product category descriptions, landing page or social media copy and more.

Message

1 Answers

Aryan Kumar
Aryan Kumar 09 Oct 2023
Report Abuse

In JavaScript, encapsulation can be achieved through a combination of closures and object-oriented programming techniques. Encapsulation is the concept of bundling the data (attributes) and the methods (functions) that operate on the data into a single unit, which is an object. It also involves controlling access to the internal state of an object to ensure data integrity. Here's how you can achieve encapsulation in JavaScript:

Private Properties and Methods:

  • JavaScript doesn't have native support for access control keywords like private, public, or protected as some other languages do. However, you can emulate private properties and methods using closures.
  • Define variables or functions within the constructor or a factory function, and they will be accessible only within that scope.
function Person(name) {
  let _name = name; // Private variable

  function _getFullName() { // Private method
    return _name;
  }

  this.sayHello = function() {
    console.log(`Hello, my name is ${_getFullName()}`);
  };
}

const person = new Person("Alice");
console.log(person._name); // undefined (private variable)
person.sayHello(); // Outputs: "Hello, my name is Alice"

Getter and Setter Methods:

  • Use getter and setter methods to access and modify private properties while controlling their access.
  • This allows you to validate and manage the data before it's read or modified.
function BankAccount() {
  let _balance = 0;

  this.getBalance = function() {
    return _balance;
  };

  this.deposit = function(amount) {
    if (amount > 0) {
      _balance += amount;
    } else {
      console.log("Invalid deposit amount.");
    }
  };

  this.withdraw = function(amount) {
    if (amount > 0 && amount <= _balance) {
      _balance -= amount;
    } else {
      console.log("Invalid withdrawal amount or insufficient balance.");
    }
  };
}

const account = new BankAccount();
account.deposit(1000);
console.log(account.getBalance()); // Outputs: 1000
account.withdraw(500);
console.log(account.getBalance()); // Outputs: 500

Use ES6 Classes:

  • With the introduction of ES6 classes, you can achieve encapsulation by defining private properties and methods using the _ convention.
  • While these properties and methods are not truly private, the _ convention signals to other developers that they are intended to be treated as private.
class Rectangle {
  constructor(width, height) {
    this._width = width; // Private property
    this._height = height; // Private property
  }

  area() {
    return this._width * this._height; // Public method
  }
}

const rect = new Rectangle(5, 10);
console.log(rect._width); // 5 (though it's meant to be private)
console.log(rect.area()); // Outputs: 50

Remember that JavaScript does not provide strict access control like some other languages, so encapsulation in JavaScript relies on conventions and the use of closures and getter/setter methods to create private and controlled access to properties and methods.

advertising