TypeScript - Các modifier truy cập: Hướng dẫn thân thiện về quyền riêng tư mã代码

Xin chào bạn, ngôi sao lập trình tương lai! ? Tôi rất vui được làm hướng dẫn viên của bạn trong hành trình thú vị này qua các modifier truy cập của TypeScript. Là người đã dạy lập trình trong nhiều năm, tôi có thể告诉你 rằng việc hiểu các khái niệm này giống như học những握手 bí mật của thế giới lập trình. Vậy, hãy cùng nhau lặn sâu và khám phá những bí ẩn này nhé!

Các modifier truy cập là gì?

Trước khi chúng ta nhảy vào chi tiết, hãy nói về các modifier truy cập là gì. Hãy tưởng tượng bạn đang xây dựng một ngôi nhà cây siêu cool (đó là mã của chúng ta!). Các modifier truy cập giống như những quy tắc bạn đặt ra cho ai có thể leo lên, ai có thể ngó vào bên trong, và ai được sử dụng các ngăn bí mật. Chúng giúp chúng ta kiểm soát cách các phần của mã có thể được truy cập và sử dụng.

Trong TypeScript, chúng ta có ba modifier truy cập chính:

Modifier	Mô tả
public	Có thể truy cập từ bất kỳ đâu
private	Chỉ có thể truy cập trong cùng một lớp
protected	Có thể truy cập trong lớp và các lớp con

Bây giờ, hãy cùng khám phá chi tiết từng modifier này!

Modifier truy cập public

Modifier public giống như để cửa ngôi nhà cây của bạn rộng mở. Bất kỳ ai cũng có thể vào, sử dụng đu, hoặc mượn sách truyện của bạn. Trong thuật ngữ mã, điều này có nghĩa là bất kỳ phần nào của chương trình của bạn cũng có thể truy cập và sử dụng các phần tử này.

Dưới đây là một ví dụ thú vị:

class Superhero {
public name: string;
public power: string;

constructor(name: string, power: string) {
this.name = name;
this.power = power;
}

public usePower() {
console.log(`${this.name} uses ${this.power}!`);
}
}

const spiderman = new Superhero("Spider-Man", "web-slinging");
console.log(spiderman.name); // Outputs: Spider-Man
spiderman.usePower(); // Outputs: Spider-Man uses web-slinging!

Trong ví dụ này, name, power, và usePower() đều là public. Chúng ta có thể truy cập và sử dụng chúng từ bất kỳ đâu trong mã. Đó giống như Spider-Man bay tự do qua thành phố!

Modifier truy cập private

Bây giờ, hãy nói về private. Điều này giống như có một日记 bí mật trong ngôi nhà cây của bạn mà chỉ bạn mới có thể đọc. Trong TypeScript, các thành viên private chỉ có thể được truy cập trong cùng một lớp.

Hãy cập nhật lớp Superhero của chúng ta:

class Superhero {
public name: string;
private secretIdentity: string;

constructor(name: string, secretIdentity: string) {
this.name = name;
this.secretIdentity = secretIdentity;
}

private changeClothes() {
console.log("Quick change in a phone booth!");
}

public goOnMission() {
this.changeClothes();
console.log(`${this.name} is ready for action!`);
}
}

const superman = new Superhero("Superman", "Clark Kent");
console.log(superman.name); // Outputs: Superman
// console.log(superman.secretIdentity); // Error! secretIdentity is private
// superman.changeClothes(); // Error! changeClothes() is private
superman.goOnMission(); // This works! Outputs: Quick change in a phone booth! Superman is ready for action!

Thấy cách chúng ta không thể truy cập secretIdentity hoặc gọi changeClothes() trực tiếp? Đó là sức mạnh của private! Nó giữ bí mật của Superman an toàn.

Modifier truy cập protected

Cuối cùng, chúng ta có protected. Hãy tưởng tượng đây là một quy tắc đặc biệt của ngôi nhà cây mà chỉ bạn và anh chị em của bạn mới có thể áp dụng, nhưng không phải các đứa trẻ trong khu phố. Trong TypeScript, các thành viên protected có thể truy cập trong lớp và các lớp con.

Hãy tạo một gia đình Superhero:

class Superhero {
public name: string;
protected superpower: string;

constructor(name: string, superpower: string) {
this.name = name;
this.superpower = superpower;
}

protected useSuperpowerInternal() {
console.log(`Using ${this.superpower} internally`);
}
}

class Sidekick extends Superhero {
public useSuperheroPower() {
console.log(`${this.name} borrows power: ${this.superpower}`);
this.useSuperpowerInternal();
}
}

const batman = new Superhero("Batman", "gadgets");
const robin = new Sidekick("Robin", "acrobatics");

// console.log(batman.superpower); // Error! superpower is protected
// batman.useSuperpowerInternal(); // Error! useSuperpowerInternal() is protected

robin.useSuperheroPower(); // This works! Outputs: Robin borrows power: acrobatics Using acrobatics internally

Ở đây, Sidekick có thể truy cập các thành viên protected của Superhero, nhưng chúng ta không thể truy cập chúng trực tiếp từ bên ngoài các lớp.

Kết luận

Và đây bạn đã có, các học trò lập trình của tôi! Chúng ta đã khám phá thế giới bí mật của các modifier truy cập TypeScript. Nhớ rằng:

1. public là cho mọi người (giống như một công viên công cộng)
2. private chỉ cho lớp itself (giống như日记 cá nhân)
3. protected là cho lớp và các lớp con (giống như bí mật gia đình)

Sử dụng các modifier này một cách khôn ngoan sẽ giúp bạn tạo ra mã an toàn, tổ chức và dễ bảo trì hơn. Đó giống như là một siêu anh hùng của thế giới lập trình - bạn biết khi nào chia sẻ sức mạnh của mình và khi nào giữ chúng bí mật!

Khi bạn tập luyện với các khái niệm này, hãy tưởng tượng bạn đang thiết kế đội siêu anh hùng riêng của mình. Ai được biết gì? Bạn giữ sự cân bằng giữa sự hợp tác và bí mật như thế nào? Đó là niềm vui của lập trình - bạn được đưa ra những quyết định thú vị!

Tiếp tục lập trình, tiếp tục học hỏi, và nhớ rằng: với quyền lực lớn đi kèm với trách nhiệm... và những lớp TypeScript thực sự tuyệt vời! ??‍♂️?‍♀️

Credits: Image by storyset