Sử dụng Access Modifiers trong TypeScript

Mục tiêu của bài viết này là cung cấp kiến thức về việc sử dụng Access Modifiers trong TypeScript. Access Modifiers là một khía cạnh quan trọng của lập trình hướng đối tượng, cho phép bạn quản lý truy cập và tính bảo mật của dữ liệu và phương thức trong mã nguồn TypeScript. Chúng giúp kiểm soát cách các thành phần của lớp tương tác với nhau và đóng gói logic trong mã nguồn.

Mình sẽ bắt đầu với việc hiểu khái niệm cơ bản về Access Modifiers và sau đó đi vào cú pháp và cách sử dụng chúng. Sau đó, sẽ tìm hiểu các lợi ích và hạn chế của việc sử dụng Access Modifiers và đi sâu hơn vào ví dụ minh họa.

Với kiến thức về Access Modifiers, bạn có thể tạo mã nguồn dễ bảo trì, bảo mật hơn và linh hoạt trong quản lý kiểu dữ liệu trong TypeScript. Hãy cùng bắt đầu khám phá chi tiết trong bài viết dưới đây.

Access Modifiers là gì?

Access Modifiers là các từ khoá trong TypeScript được sử dụng để quy định mức độ truy cập đối với các thành phần của một lớp (class) hoặc đối tượng (object). Các Access Modifiers định rõ ai có quyền truy cập vào các thành phần của lớp, như các thuộc tính (properties), phương thức (methods), hay constructor.

Bài viết này được đăng tại [free tuts .net]

Có ba Access Modifiers chính trong TypeScript:

• Public (mặc định): Các thành phần được đánh dấu là public có thể truy cập từ bất kỳ nơi nào, ngoài lớp và từ bên ngoài lớp.

• Private: Các thành phần được đánh dấu là private chỉ có thể truy cập từ bên trong lớp đó. Bất kỳ sự truy cập từ bên ngoài lớp sẽ bị từ chối.

• Protected: Các thành phần được đánh dấu là protected cũng chỉ có thể truy cập từ bên trong lớp đó, tương tự như private. Tuy nhiên, chúng cũng có thể truy cập từ các lớp con (subclasses) của lớp cha (superclass) chứa thành phần protected.

Access Modifiers giúp kiểm soát tính riêng tư và bảo mật của dữ liệu và logic trong lớp, đồng thời cung cấp tính linh hoạt trong việc quản lý truy cập. Chúng giúp ngăn chặn việc truy cập trái phép và làm cho mã nguồn dễ bảo trì hơn.

Cú pháp sử dụng Access Modifiers

Cú pháp sử dụng Access Modifiers trong TypeScript như sau:

Public (Mặc định)

Đây là một access modifier không cần từ khóa cụ thể. Nếu bạn không đánh dấu thành phần nào bằng private hoặc protected, nó sẽ mặc định là public. Điều này có nghĩa rằng nó có thể truy cập từ bất kỳ đâu, cả trong lớp và từ bên ngoài lớp. Ví dụ:

class Car {
    model: string; // Public property
    constructor(model: string) {
        this.model = model;
    }
}
const myCar = new Car("Tesla");
console.log(myCar.model); // OK, because it's public

Private

Đánh dấu một thành phần là private bằng cách sử dụng từ khóa private. Thành phần private chỉ có thể truy cập bên trong lớp đó và không thể truy cập từ bên ngoài lớp. Ví dụ:

class Employee {
    private employeeId: number; // Private property
    constructor(id: number) {
        this.employeeId = id;
    }
}
const employee = new Employee(123);
console.log(employee.employeeId); // Error, because it's private

Protected

Đánh dấu một thành phần là protected bằng từ khóa protected. Thành phần protected có thể truy cập bên trong lớp đó và từ các lớp con (subclasses) của nó. Ví dụ:

class Person {
    protected name: string;
    constructor(name: string) {
        this.name = name;
    }
}

class Student extends Person {
    showName() {
        console.log(`My name is ${this.name}`); // OK, because it's protected and Student is a subclass
    }
}
const student = new Student("Alice");
student.showName();

Những access modifiers này giúp kiểm soát tính riêng tư của thành phần lớp và cung cấp sự bảo mật trong việc quản lý truy cập đối với dữ liệu và logic của lớp.

Sử dụng Access Modifiers

Sử dụng Access Modifiers trong lớp

• Access modifiers có thể sử dụng để đánh dấu tính riêng tư của toàn bộ lớp. Ví dụ:

class Account {
    private balance: number;
    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }
    
    getBalance(): number {
        return this.balance;
    }
}
const myAccount = new Account(1000);
console.log(myAccount.balance); // Error, because balance is private

Sử dụng Access Modifiers trong phương thức

• Access modifiers có thể sử dụng để kiểm soát truy cập vào các phương thức của lớp. Ví dụ:

class BankAccount {
    private balance: number;
    
    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }
    
    withdraw(amount: number): void {
        if (amount > 0 && amount <= this.balance) {
            this.balance -= amount;
        }
    }
    
    deposit(amount: number): void {
        if (amount > 0) {
            this.balance += amount;
        }
    }
}
const myBankAccount = new BankAccount(1000);
myBankAccount.withdraw(500); // OK
myBankAccount.balance = 5000; // Error, because balance is private

Sử dụng Access Modifiers trong thuộc tính

• Access modifiers cũng có thể được sử dụng để kiểm soát truy cập vào các thuộc tính của lớp. Ví dụ:

class Person {
    protected name: string;
    
    constructor(name: string) {
        this.name = name;
    }
    
    getName(): string {
        return this.name;
    }
    
    setName(newName: string): void {
        this.name = newName;
    }
}

class Employee extends Person {
    constructor(name: string) {
        super(name);
    }
    
    changeName(newName: string): void {
        this.name = newName; // OK, because name is protected in the base class
    }
}
const employee = new Employee("Alice");
console.log(employee.name); // Error, because name is protected

Access modifiers giúp bạn kiểm soát và hạn chế truy cập vào các thành phần lớp, giúp mã nguồn trở nên dễ bảo trì và an toàn hơn.

Lợi ích và hạn chế của việc sử dụng Access Modifiers

Lợi ích của việc sử dụng Access Modifiers

• Bảo mật dữ liệu: Access modifiers như private giúp bảo vệ dữ liệu và đảm bảo rằng các thành phần nội tại của lớp không thể bị truy cập từ bên ngoài.
• Kiểm soát truy cập: Access modifiers giúp kiểm soát truy cập vào phương thức và thuộc tính của lớp, giúp loại bỏ các truy cập không mong muốn và đảm bảo tính nhất quán trong mã nguồn.
• Tăng tính bảo mật và đọc mã nguồn dễ hiểu: Access modifiers là một công cụ mạnh mẽ để làm cho mã nguồn dễ đọc hơn và giảm nguy cơ lỗi trong quá trình phát triển.

Hạn chế của việc sử dụng Access Modifiers

• Phức tạp hóa mã nguồn: Việc sử dụng quá nhiều access modifiers có thể làm cho mã nguồn phức tạp và khó hiểu, đặc biệt khi áp dụng quá mức.
• Hạn chế tính linh hoạt: Sử dụng access modifiers quá nhiều có thể hạn chế tính linh hoạt của mã nguồn, làm cho việc mở rộng hoặc thay đổi mã trở nên khó khăn hơn.

Access modifiers nên được sử dụng một cách cân nhắc để đảm bảo tính bảo mật và hiệu quả của mã nguồn mà không làm tăng độ phức tạp không cần thiết.

Ví dụ minh họa

Sử dụng Access Modifiers để tạo lớp đối tượng

class Person {
    private name: string;
    protected age: number;
    public gender: string;

    constructor(name: string, age: number, gender: string) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public introduce(): void {
        console.log(`Hi, I'm ${this.name}, ${this.age} years old, and I am a ${this.gender}.`);
    }
}

class Employee extends Person {
    private employeeId: number;

    constructor(name: string, age: number, gender: string, employeeId: number) {
        super(name, age, gender);
        this.employeeId = employeeId;
    }

    public showEmployeeInfo(): void {
        // Có thể truy cập thuộc tính 'gender' của lớp cha vì nó là public
        console.log(`Employee ID: ${this.employeeId}, Gender: ${this.gender}`);
        // Không thể truy cập thuộc tính 'name' của lớp cha vì nó là private
        // Không thể truy cập thuộc tính 'age' của lớp cha vì nó là protected
    }
}

const john = new Employee("John", 30, "Male", 12345);
john.introduce(); // Có thể gọi phương thức public từ lớp cha
john.showEmployeeInfo(); // Có thể gọi phương thức public từ lớp con

Sử dụng Access Modifiers để quản lý quyền truy cập

class BankAccount {
    private balance: number;

    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }

    public deposit(amount: number): void {
        this.balance += amount;
        console.log(`Deposited $${amount}. New balance: $${this.balance}`);
    }

    public withdraw(amount: number): void {
        if (amount <= this.balance) {
            this.balance -= amount;
            console.log(`Withdrawn $${amount}. New balance: $${this.balance}`);
        } else {
            console.log("Insufficient funds.");
        }
    }
}

const account = new BankAccount(1000);
account.deposit(500);
account.withdraw(200);
account.withdraw(1500); // Khi thử rút một số lớn hơn số dư, sẽ nhận được thông báo "Insufficient funds."

Trong ví dụ trên, access modifiers (private, public) được sử dụng để quản lý quyền truy cập vào các thuộc tính và phương thức của lớp. Điều này giúp đảm bảo tính bảo mật và kiểm soát truy cập đúng cách.

Kết bài

Trong bài viết này, mình đã tìm hiểu về Access Modifiers trong TypeScript và cách chúng có thể được sử dụng để quản lý quyền truy cập vào các thuộc tính và phương thức trong lớp. Ta đã tìm hi các loại Access Modifiers (private, protected, và public) và cách chúng hoạt động.

Access Modifiers là một công cụ mạnh mẽ giúp kiểm soát truy cập và bảo vệ dữ liệu của bạn khỏi sự can thiệp không cần thiết. Bằng cách sử dụng chúng, bạn có thể tạo các lớp đối tượng có cấu trúc rõ ràng và quản lý quyền truy cập dễ dàng hơn.

Tuy nhiên, hãy lưu ý rằng việc sử dụng Access Modifiers cần phải xem xét kỹ lưỡng để đảm bảo mã nguồn của bạn có tính linh hoạt và dễ bảo trì. Điều này đặc biệt quan trọng khi bạn làm việc trong các dự án lớn hoặc với đội ngũ phát triển lớn.

Mong rằng bài viết này đã giúp bạn hiểu rõ hơn về cách sử dụng Access Modifiers và tận dụng chúng để tạo mã nguồn TypeScript hiệu quả và dễ đọc.