Class trong TypeScript

Class trong TypeScript vẫn là class JavaScript mà mèo con đã biết. Cái TS thêm vào là vài tính năng kiểm tra lúc biên dịch. Đầu tiên là access modifier - kiểm soát ai được đụng vào field/method: public (mặc định, ai cũng dùng), private (chỉ trong class), protected (trong class và lớp con):

class TaiKhoan {
  private soDu = 0;
  nap(x: number) { this.soDu += x; }
}
const t = new TaiKhoan();
t.nap(100);   // OK - method public
t.soDu;       // Loi - soDu la private

error TS2341: Property 'soDu' is private and only accessible within class 'TaiKhoan'.

• ▸public (mặc định): ai cũng truy cập được; private: chỉ trong class; protected: thêm cả lớp con.
• ▸Access modifier giúp đóng gói: lộ ra method an toàn, che state bên trong.
• ▸Đây là kiểm tra lúc biên dịch, không phải khoá lúc chạy (xem Bước 3).

Khai báo field rồi gán this.x = x trong constructor là việc lặp đi lặp lại. TypeScript cho một lối tắt: đặt access modifier ngay trên tham số constructor, gọi là parameter property - TS tự khai báo field và gán giúp:

class Meo {
  constructor(private ten: string) {}
}

class Meo {
    constructor(ten) {
        this.ten = ten;
    }
}

Một dòng private ten: string trong ngoặc đã thay cho ba việc: khai báo field, nhận tham số, và gán. Class nhiều field nhờ vậy gọn hẳn.

Đây là chỗ hay gây ngộ nhận. private của TypeScript chỉ là giao kèo lúc biên dịch - đúng tinh thần type erasure ở Bài 1: khi ra JavaScript, field private trở thành một thuộc tính thường, vẫn đọc được lúc chạy:

class A { private secret = 42; }
const a = new A();
console.log((a as any).secret);   // lach qua "as any"

42

class A {
    constructor() {
        this.secret = 42;
    }
}

Muốn riêng tư thật sự lúc chạy, dùng #private của chính JavaScript - engine tự chặn, không lách được:

class B {
  #secret = 42;
  doc() { return this.#secret; }
}
const b = new B();
console.log(b.doc());      // 42 - method trong class doc duoc
// console.log(b.#secret); // Loi: khong doc duoc tu ngoai lop

42

Một class có thể hứa "tôi sẽ có hình dạng của interface này" bằng implements - chính là structural typing ở Bài 3 nhưng có tên gọi rõ ràng. Thiếu field thì tsc bắt ngay:

interface CoTen { ten: string; }

class Meo implements CoTen {
  constructor(public ten: string) {}   // du 'ten' -> OK
}

abstract class là khung dùng chung: nó có thể chứa method đã cài đặt lẫn method abstract (bắt lớp con cài), và không tạo instance trực tiếp được:

abstract class HinhHoc {
  abstract dienTich(): number;          // lop con bat buoc cai dat
  moTa() { return "Dien tich: " + this.dienTich(); }
}

class HinhVuong extends HinhHoc {
  constructor(private canh: number) { super(); }
  dienTich() { return this.canh * this.canh; }
}

// new HinhHoc()  -> Loi: Cannot create an instance of an abstract class

• ▸implements: class hứa khớp hình dạng một interface; thiếu thì tsc báo TS2420.
• ▸abstract class: khung chung có code dùng lại + method abstract bắt lớp con cài đặt.
• ▸Không new được abstract class trực tiếp (TS2511) - phải qua một lớp con cụ thể.

Bạn vừa thấy TypeScript khoác cho class JavaScript một lớp kiểm tra: che state bằng access modifier, viết gọn bằng parameter property, ràng buộc bằng implements và abstract - tất cả đều là chuyện lúc biên dịch. Từ bài sau, ta quay lại trọng tâm của TypeScript: mô hình hoá dữ liệu bằng kiểu.