Building Your Learning Module...
Getting things ready for you!
Find videos you like?
Save to resource drawer for future reference!
Just like private fields, you can now create truly private methods using the # prefix! These methods are completely hidden from outside the class - providing true encapsulation!
class User {
#email = '';
// Private method
#validateEmail(email) {
return email.includes('@') && email.includes('.');
}
// Public method uses private method
setEmail(email) {
if (this.#validateEmail(email)) {
this.#email = email;
return 'Email set successfully!';
}
return 'Invalid email!';
}
getEmail() {
return this.#email;
}
}
const user = new User();
console.log(user.setEmail('alice@example.com')); // 'Email set successfully!'
console.log(user.getEmail()); // 'alice@example.com'
// Private method NOT accessible
user.#validateEmail('test@test.com'); // ❌ SyntaxError!class MathUtils {
// Private static method
static #validateNumber(num) {
return typeof num === 'number' && !isNaN(num);
}
static #formatResult(result) {
return `Result: ${result.toFixed(2)}`;
}
// Public static method
static calculate(a, b, operation) {
if (!this.#validateNumber(a) || !this.#validateNumber(b)) {
return 'Invalid numbers!';
}
let result;
switch(operation) {
case 'add': result = a + b; break;
case 'multiply': result = a * b; break;
default: return 'Unknown operation';
}
return this.#formatResult(result);
}
}
console.log(MathUtils.calculate(5, 3, 'add')); // 'Result: 8.00'
// Private static methods NOT accessible
MathUtils.#validateNumber(5); // ❌ SyntaxError!class PaymentProcessor {
#balance = 1000;
// Private methods for internal logic
#checkBalance(amount) {
return this.#balance >= amount;
}
#deductFunds(amount) {
this.#balance -= amount;
}
#addFunds(amount) {
this.#balance += amount;
}
#logTransaction(type, amount) {
console.log(`[${type}] $${amount} - Balance: $${this.#balance}`);
}
// Public API
processPayment(amount) {
if (!this.#checkBalance(amount)) {
return 'Insufficient funds!';
}
this.#deductFunds(amount);
this.#logTransaction('PAYMENT', amount);
return 'Payment successful!';
}
deposit(amount) {
this.#addFunds(amount);
this.#logTransaction('DEPOSIT', amount);
return 'Deposit successful!';
}
getBalance() {
return `Current balance: $${this.#balance}`;
}
}
const processor = new PaymentProcessor();
console.log(processor.processPayment(50)); // 'Payment successful!'
console.log(processor.deposit(100)); // 'Deposit successful!'
console.log(processor.getBalance()); // 'Current balance: $1050'
// All private methods are hidden
processor.#checkBalance(100); // ❌ Error
processor.#deductFunds(50); // ❌ ErrorImplementation details stay hidden - can't be called from outside
Change private methods without breaking external code
Only expose what users need - hide complexity
Use # prefix for truly private methods
Can't be accessed from outside the class
Works with static methods as well!
Modern JavaScript encapsulation