TypeScript có hỗ trợ tất cả các nguyên lý hướng đối tượng không?

Question

Nguyễn Thắng · Accepted Answer

TypeScript là một ngôn ngữ lập trình mở rộng từ JavaScript, và nó hỗ trợ nhiều nguyên lý hướng đối tượng (OOP) nhưng không phải tất cả. Việc hiểu rõ những nguyên lý nào được hỗ trợ và những nguyên lý nào có thể không được thực thi một cách hoàn hảo là rất quan trọng cho việc phát triển ứng dụng. Dưới đây là phân tích chi tiết về các nguyên lý hướng đối tượng mà TypeScript hỗ trợ.
1. Các Nguyên Lý Hướng Đối Tượng Được Hỗ Trợ
1.1. Đóng gói (Encapsulation)
TypeScript hỗ trợ đóng gói thông qua việc sử dụng các modifier như public, private, và protected. Điều này cho phép bạn kiểm soát quyền truy cập vào các thuộc tính và phương thức của lớp.
Ví dụ:
class Person {
    private name: string;
    constructor(name: string) {
        this.name = name;
    }
    public getName(): string {
        return this.name;
    }
}
const person = new Person("Alice");
console.log(person.getName()); // Kết quả: Alice
// console.log(person.name); // Lỗi: Property 'name' is private
1.2. Kế thừa (Inheritance)
TypeScript hỗ trợ kế thừa, cho phép một lớp kế thừa từ một lớp khác. Điều này giúp tái sử dụng mã và tổ chức tốt hơn.
Ví dụ:
class Animal {
    protected name: string;
    constructor(name: string) {
        this.name = name;
    }
    public speak(): string {
        return `${this.name} makes a noise.`;
    }
}
class Dog extends Animal {
    public speak(): string {
        return `${this.name} barks.`;
    }
}
const dog = new Dog("Rex");
console.log(dog.speak()); // Kết quả: Rex barks.
1.3. Đa hình (Polymorphism)
TypeScript hỗ trợ đa hình thông qua phương thức ghi đè (method overriding) và giao diện (interfaces). Bạn có thể ghi đè các phương thức trong lớp con hoặc triển khai nhiều giao diện trong một lớp.
Ví dụ:
class Cat extends Animal {
    public speak(): string {
        return `${this.name} meows.`;
    }
}
const animals: Animal&#x5B;] = &#x5B;new Dog("Rex"), new Cat("Whiskers")];
animals.forEach(animal => {
    console.log(animal.speak());
});
// Kết quả:
// Rex barks.
// Whiskers meows.
1.4. Giao diện (Interfaces)
TypeScript hỗ trợ giao diện, cho phép bạn định nghĩa cấu trúc của một đối tượng mà không cần cung cấp cài đặt chi tiết. Điều này giúp bạn xây dựng các ứng dụng theo hướng hợp đồng.
Ví dụ:
interface Shape {
    area(): number;
}
class Circle implements Shape {
    constructor(private radius: number) {}
    public area(): number {
        return Math.PI * this.radius ** 2;
    }
}
const circle = new Circle(5);
console.log(circle.area()); // Kết quả: 78.53981633974483
2. Các Nguyên Lý Hướng Đối Tượng Không Được Hỗ Trợ Hoàn Hảo
2.1. Trừu tượng (Abstraction)
TypeScript không hỗ trợ trực tiếp cho các lớp trừu tượng như một số ngôn ngữ OOP khác (như Java hoặc C#). Tuy nhiên, bạn có thể tạo các lớp trừu tượng bằng cách sử dụng các giao diện hoặc lớp cha với các phương thức trừu tượng.
Ví dụ:
abstract class Shape {
    abstract area(): number; // Phương thức trừu tượng
}
class Rectangle extends Shape {
    constructor(private width: number, private height: number) {
        super();
    }
    public area(): number {
        return this.width * this.height;
    }
}
2.2. Tính đa hình kiểu (Subtype Polymorphism)
Mặc dù TypeScript hỗ trợ đa hình thông qua các lớp và giao diện, nhưng nó không hoàn toàn tuân theo nguyên lý đa hình kiểu, vì TypeScript được biên dịch thành JavaScript, nơi các kiểu không được kiểm tra một cách nghiêm ngặt trong thời gian chạy.
3. Kết Luận
TypeScript hỗ trợ nhiều nguyên lý hướng đối tượng quan trọng như đóng gói, kế thừa, đa hình và giao diện. Tuy nhiên, một số nguyên lý như trừu tượng không được hỗ trợ một cách hoàn hảo như trong các ngôn ngữ OOP khác. Việc hiểu rõ các nguyên lý này sẽ giúp bạn phát triển ứng dụng một cách hiệu quả và tổ chức mã nguồn tốt hơn.