การใช้งาน polymorphism in OOP concept ในภาษา Node.js แบบง่ายๆ พร้อมตัวอย่าง CODE 3 ตัวอย่าง และอธิบายการทำงาน และยกตัวอย่าง usecase ในโลกจริง

### บทความ: การใช้งาน Polymorphism ใน OOP ด้วยภาษา Node.js พร้อมตัวอย่างการประยุกต์ใช้งานในโลกจริง

การโปรแกรมมิ่งเป็นงานศิลปะที่ผสมผสานระหว่างความคิดสร้างสรรค์และหลักการที่เป็นระเบียบ หนึ่งในหลักการนั้นคือ หลักการ Object-Oriented Programming (OOP) ที่ช่วยให้การพัฒนาโปรแกรมมีความยืดหยุ่นและสามารถดูแลรักษาได้ง่ายขึ้น หนึ่งในหลักการสำคัญของ OOP คือการใช้งาน Polymorphism วันนี้เราจะมาพูดถึงการใช้งาน Polymorphism ใน Node.js ที่เป็นภาษาที่มีความยืดหยุ่นและได้รับความนิยมสูง เพื่อพัฒนาการเขียนโปรแกรมให้มีความเป็นมืออาชีพยิ่งขึ้น และสำหรับเพื่อนๆ ที่มองหาโอกาสในการศึกษาเพิ่มเติม เชิญชวนให้มาเป็นส่วนหนึ่งกับเราที่ Expert-Programming-Tutor (EPT) ด้วยนะครับ!

#### Polymorphism คืออะไร?

Polymorphism ในโลกของ OOP หมายถึงความสามารถของโอบเจกต์ที่สามารถรับหลายรูปแบบ ยกตัวอย่างเช่น ฟังก์ชันที่สามารถจัดการกับข้อมูลประเภทต่างๆ โดยการส่งข้อมูลที่มีรูปแบบแตกต่างกันเข้ามา ใน Node.js ซึ่งเป็น runtime สำหรับเรียกใช้ JavaScript นอกเบราว์เซอร์ การใช้งาน Polymorphism ทำให้โค้ดที่เราเขียนสามารถมีความยืดหยุ่นและสามารถนำกลับมาใช้ได้หลายครั้ง

#### ตัวอย่างการประยุกต์ใช้งาน Polymorphism ใน Node.js

ในการสร้างระบบที่ต้องจัดการกับข้อมูลรูปทรงเรขาคณิตต่างๆ เช่น วงกลม, สี่เหลี่ยม, สามเหลี่ยม เราสามารถสร้าง base class ที่เรียกว่า `Shape` และให้ตระกูลของรูปทรงทั้งหมด extends มาจาก class นี้ ใน base class เราสามารถกำหนด method ที่เราต้องการให้ทุกรูปทรงต้องมี เช่น `area()` และ `perimeter()`

```javascript

class Shape {

area() {

throw new Error("This method must be overwritten!");

}

perimeter() {

throw new Error("This method must be overwritten!");

}

}

class Circle extends Shape {

constructor(radius) {

super();

this.radius = radius;

}

area() {

return Math.PI * this.radius ** 2;

}

perimeter() {

return 2 * Math.PI * this.radius;

}

}

class Rectangle extends Shape {

constructor(width, height) {

super();

this.width = width;

this.height = height;

}

area() {

return this.width * this.height;

}

perimeter() {

return 2 * (this.width + this.height);

}

}

// การใช้งาน

const shapes = [new Circle(10), new Rectangle(10, 20)];

shapes.forEach(shape => {

console.log(`Area: ${shape.area()}, Perimeter: ${shape.perimeter()}`);

});

```

จากโค้ดข้างต้น เราสามารถเห็น polymorphism ที่เกิดขึ้นภายในวงกลมและสี่เหลี่ยมที่ทั้งสองสามารถเรียกใช้เมธอด `area()` และ `perimeter()` ได้โดยไม่ต้องสนใจว่าเป็นรูปทรงประเภทไหน

จินตนาการถึงฟังก์ชันที่เรียกว่า `printDetails` ซึ่งสามารถรับ object ที่มีประเภทต่างๆ ไม่ว่าจะเป็น `Employee`, `Product` หรือ `Service` และแต่ละประเภท object สามารถมี method เฉพาะที่ชื่อ `getDetails` ที่ส่งกลับข้อมูลรายละเอียดของ object นั้นได้

```javascript

class Employee {

constructor(name, position) {

this.name = name;

this.position = position;

}

getDetails() {

return `${this.name} works as a ${this.position}.`;

}

}

class Product {

constructor(name, price) {

this.name = name;

this.price = price;

}

getDetails() {

return `The product ${this.name} costs ${this.price}$.`;

}

}

function printDetails(obj) {

console.log(obj.getDetails());

}

// การใช้งาน

const emp = new Employee("John", "Developer");

const prod = new Product("Laptop", 1500);

printDetails(emp);

printDetails(prod);

```

จากโค้ดเราเห็นว่า `printDetails` สามารถ handle ได้ทั้ง `Employee` และ `Product` โดยไม่จำเป็นต้องรู้ว่า object นั้นเป็นประเภทไหน นี่คือตัวอย่างของการใช้ polymorphism ในการเขียนโค้ดที่ reusable และสามารถต่อยอดได้

ในการพัฒนาโปรแกรมที่มี module หรือ plugin ที่สามารถเพิ่มเติมได้ตามต้องการ เราสามารถใช้ Polymorphism เพื่อสร้าง interface ร่วมที่ทุก plugin ต้อง implement สมมติว่าเรามี `LoggerPlugin` ที่ทุก plugin จะต้องเขียน method `logMessage`

```javascript

class LoggerPlugin {

logMessage(message) {

throw new Error("You must implement this method.");

}

}

class ConsoleLogger extends LoggerPlugin {

logMessage(message) {

console.log(message);

}

}

class FileLogger extends LoggerPlugin {

logMessage(message) {

// Code for logging to a file...

}

}

const loggerInstances = [new ConsoleLogger(), new FileLogger()];

loggerInstances.forEach(logger => {

logger.logMessage("This is a polymorphic call to log.");

});

```

ตัวอย่างนี้แสดงให้เห็นการใช้งาน Polymorphism ในการสร้าง architecture ที่เปิดกว้างสำหรับการขยายโปรแกรมโดยไม่ขึ้นกับรายละเอียดภายในของแต่ละ plugin

#### Usecase ในโลกจริง

Polymorphism ในโลกจริงมีความสำคัญอย่างมากในการพัฒนาซอฟต์แวร์ เช่นในระบบ e-commerce ที่จำเป็นต้องจัดการกับหลากหลายประเภทสินค้า หรือระบบจัดการพนักงานที่ประกอบไปด้วยหลายตำแหน่งงานต่างๆ การใช้งาน Polymorphism ช่วยให้โค้ดของเราสามารถจัดการกับข้อมูลที่หลากหลายในรูปแบบที่ทำให้เราไม่ต้องเขียนโค้ดซ้ำซ้อน และยังช่วยในการทำให้โค้ดของเราสามารถนำกลับมาใช้ใหม่ได้ง่ายขึ้น

ในการที่จะเข้าใจวิธีการใช้งาน Polymorphism และหลักการอื่นๆ ของ OOP ได้อย่างถูกต้องและเข้าใจลึกซึ้งมากยิ่งขึ้น การมาเรียนรู้ที่ Expert-Programming-Tutor (EPT) คือโอกาสที่จะช่วยเปิดมุมมองใหม่ๆ ในการเขียนโค้ดของคุณ ร่วมกันพัฒนาการเขียนโปรแกรมให้มีคุณภาพและมีความมั่นคงในอาชีพนี้กับเราได้เลย!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง