การเขียนโปรแกรมในทศวรรษล่าสุดได้พัฒนาไปไกลอย่างมาก ด้วยการนำหลักการ Object-Oriented Programming (OOP) มาใช้ในการออกแบบและพัฒนาซอฟต์แวร์ หนึ่งในแนวคิดหลักของ OOP คือ "Encapsulation" ซึ่งทำให้การจัดการกับระบบซอฟต์แวร์ที่มีความซับซ้อนกลายเป็นเรื่องที่ง่ายดายยิ่งขึ้น ในส่วนของ TypeScript, ภาษาที่เป็นซูเปอร์เซ็ตของ JavaScript, encapsulation นับเป็นกลไกพื้นฐานที่พัฒนาเว็บแอปพลิเคชันได้เป็นอย่างดี ในบทความนี้ เราจะสำรวจว่า encapsulation ทำงานอย่างไรใน TypeScript พร้อมตัวอย่างโค้ด 3 ตัวอย่างและยกตัวอย่างการใช้งานในโลกจริง
Encapsulation คือ การซ่อนรายละเอียดการทำงานภายในของออบเจ็คให้ปลอดภัยจากการเข้าถึงโดยตรงจากภายนอก หลักการนี้ช่วยให้โค้ดของเรามีความยืดหยุ่น, ง่ายต่อการบำรุงรักษา และลดการเกิดความผิดพลาด เนื่องจากผู้ใช้สามารถเปลี่ยนแปลงสถานะภายในของออบเจ็คผ่านเมธอดที่กำหนดไว้ล่วงหน้าเท่านั้น
ตัวอย่างที่ 1: คลาสพื้นฐาน
class Employee {
private name: string;
constructor(name: string) {
this.name = name;
}
public getName(): string {
return this.name;
}
}
ในตัวอย่างนี้ `name` ถูกกำหนดให้เป็น `private` ซึ่งหมายความว่ามันไม่สามารถถูกเข้าถึงโดยตรงจากภายนอกคลาส `Employee` โค้ดต่อไปนี้จะทำให้เกิดข้อผิดพลาด:
const emp = new Employee("John Doe");
console.log(emp.name); // Error: 'name' is private and only accessible within class 'Employee'.
แต่เราสามารถเข้าถึง `name` ผ่านเมธอด `getName` ที่เป็น `public` ได้:
console.log(emp.getName()); // Output: John Doe
ตัวอย่างที่ 2: เมธอด setter และ getter
class Account {
private balance: number;
constructor(initialBalance: number) {
this.balance = initialBalance;
}
setBalance(newBalance: number): void {
if (newBalance >= 0) {
this.balance = newBalance;
} else {
console.error("Invalid value for balance.");
}
}
getBalance(): number {
return this.balance;
}
deposit(amount: number): void {
this.setBalance(this.getBalance() + amount);
}
withdraw(amount: number): void {
if (amount <= this.getBalance()) {
this.setBalance(this.getBalance() - amount);
} else {
console.error("Insufficient funds.");
}
}
}
ในตัวอย่างนี้, `balance` ถูก encapsulate เอาไว้ภายในคลาส `Account` การเปลี่ยนแปลงค่าของมันจะต้องผ่านเมธอด `setBalance` ที่กำหนดเงื่อนไขว่า balance ต้องมีค่าไม่น้อยกว่า 0
ตัวอย่างที่ 3: Readonly และ Static ออบเจ็ค
class Circle {
private static PI: number = 3.14159;
private readonly radius: number;
constructor(radius: number) {
this.radius = radius;
}
calculateArea(): number {
return Circle.PI * (this.radius * this.radius);
}
}
ในตัวอย่างนี้ `PI` คือค่าคงที่ที่ไม่ต้องการให้เปลี่ยนแปลง ในขณะที่ `radius` เป็น readonly ซึ่งหมายความว่าค่านี้สามารถถูกกำหนดได้เพียงครั้งเดียวใน constructor
Encapsulation มีประโยชน์มากในการพัฒนาซอฟต์แวร์ในโลกจริง ตัวอย่างเช่น ในระบบธนาคารออนไลน์สามารถใช้ encapsulation ในการปกป้องคลาสต่างๆ เช่น `Account` ซึ่งจะรวมรักษาข้อมูลที่เกี่ยวกับยอดเงินและเมธอดที่ใช้ในการทำธุรกรรมทางการเงิน
Encapsulation ใน TypeScript เป็นหลักการที่สำคัญในการสร้างซอฟต์แวร์ที่มีคุณภาพ มันช่วยให้เราจัดการกับความซับซ้อนและแยกส่วนต่างๆ ของโค้ดได้อย่างเป็นระเบียบ หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับ encapsulation หรืออื่นๆ ใน OOP, ที่ EPT เรามีหลักสูตรที่จะช่วยคุณทำความเข้าใจเกี่ยวกับการสร้างแอพพลิเคชันด้วย TypeScript และมีโอกาสทดลองใช้งานแนวคิดเหล่านี้ในโปรเจ็กต์จริง ลงทะเบียนเรียนกับเราวันนี้และพัฒนาทักษะการเขียนโปรแกรมให้ไปอีกระดับ!
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM