Curriculum
Encapsulation in JavaScript is one of the core principles of Object-Oriented Programming used to protect data and control access to object properties and methods. Understanding Encapsulation in JavaScript helps beginners build secure, maintainable, and scalable applications using proper object-oriented design practices.
Modern applications often contain:
Allowing direct access to all object properties may create:
JavaScript provides:
Encapsulation helps developers:
Encapsulation is widely used in:
Understanding Encapsulation in JavaScript is essential for advanced JavaScript development.
Encapsulation helps developers:
Modern Object-Oriented Programming heavily relies on encapsulation.
Encapsulation is:
It also means:
Only controlled methods should:
Example:
Users should not:
Instead:
This improves:
Example:
class User{
constructor(name){
this.name = name;
}
show(){
console.log(this.name);
}
}
let user = new User("Rahul");
user.show();The class bundles:
Together inside:
Example:
user.balance = -50000;Direct property access may:
Encapsulation helps prevent:
Modern JavaScript provides:
Private fields use:
#Example:
class BankAccount{
#balance = 1000;
}The property becomes:
Example:
class BankAccount{
#balance = 1000;
showBalance(){
console.log(this.#balance);
}
}
let account = new BankAccount();
account.showBalance();Output:
1000Private fields are accessible only:
Example:
console.log(account.#balance);Output:
Because:
Methods provide:
Example:
class BankAccount{
#balance = 1000;
deposit(amount){
this.#balance += amount;
}
getBalance(){
return this.#balance;
}
}
let account = new BankAccount();
account.deposit(500);
console.log(account.getBalance());Output:
1500The balance changes only through:
Controlled methods help:
This creates:
Example:
class User{
#age = 0;
setAge(age){
if(age > 0){
this.#age = age;
}
}
getAge(){
return this.#age;
}
}
let user = new User();
user.setAge(25);
console.log(user.getAge());Output:
25Validation prevents:
Before private fields, JavaScript used:
Example:
function Counter(){
let count = 0;
return {
increment(){
count++;
},
getCount(){
return count;
}
};
}
let counter = Counter();
counter.increment();
console.log(counter.getCount());Output:
1Closures also provide:
Encapsulation is used in:
Modern software architecture heavily depends on secure data management.
Example:
class Login{
#password = "12345";
verify(password){
return this.#password === password;
}
}Passwords remain:
Example:
class Product{
#stock = 10;
buy(){
this.#stock--;
}
}Inventory updates remain:
Example:
class Student{
#marks = 0;
updateMarks(value){
if(value >= 0){
this.#marks = value;
}
}
}Validation improves:
| Public Members | Private Members |
|---|---|
| Accessible everywhere | Accessible only inside class |
| No restriction | Protected access |
| Flexible but risky | More secure |
Encapsulation balances:
| Without Encapsulation | With Encapsulation |
|---|---|
| Unsafe direct changes | Controlled modifications |
| Harder validation | Easier validation |
| Less secure | More secure |
Encapsulation improves software quality significantly.
Beginners often:
Incorrect example:
account.#balanceProblem:
Correct approach:
account.getBalance()Benefits include:
Encapsulation is fundamental in advanced JavaScript development.
Best practices include:
Readable encapsulated code improves maintainability.
Understanding Encapsulation in JavaScript helps developers:
Encapsulation is essential in modern web development.
Encapsulation in JavaScript is an Object-Oriented Programming principle used to bundle data and methods together while restricting direct access to internal object details. JavaScript supports encapsulation using private fields, methods, and closures to improve security, maintainability, and scalability in modern applications.
Encapsulation is the process of protecting object data and controlling access to it.
Encapsulation improves security, maintainability, and data validation.
Private fields are class properties prefixed with # and accessible only inside the class.
Yes, closures can hide variables and create private data access.
Encapsulation is used in banking systems, APIs, authentication systems, and enterprise applications.