OOP ใน JavaScript - การสร้าง Object ด้วย Constructor Function

 

ในการเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming: OOP) ในภาษา JavaScript สิ่งที่สำคัญอย่างยิ่งก็คือความสามารถในการสร้างและจัดการกับวัตถุ (Object) ได้อย่างมีประสิทธิภาพ In OOP, วัตถุเป็นหน่วยพื้นฐานที่ประกอบด้วยข้อมูลและฟังก์ชันที่ทำงานบนข้อมูลนั้น ๆ JavaScript มีวิธีการหลากหลายในการสร้างวัตถุ โดยวิธีหนึ่งที่น่าสนใจและถูกใช้อย่างแพร่หลายคือการใช้ Constructor Function

 

Constructor Function คืออะไร?

Constructor Function เป็นรูปแบบหนึ่งในการสร้างและกำหนดคุณสมบัติของวัตถุใน JavaScript โดยใช้ฟังก์ชันธรรมดาที่ทำหน้าที่เหมือนเทมเพลตในการสร้างวัตถุใหม่ Constructor Function มีความสามารถในการกำหนดค่าเริ่มต้นและวิธีการของวัตถุที่ถูกสร้างขึ้น

 

การสร้าง Constructor Function

เพื่อเริ่มต้นสร้าง Constructor Function เราจะต้องสร้างฟังก์ชันทั่วไปและใช้งานคำสั่ง `new` ร่วมด้วย ตัวอย่างเช่น ลองพิจารณาฟังก์ชันที่ชื่อว่า `Car` ที่ใช้สร้างวัตถุรถยนต์แต่ละคัน

function Car(brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
}

let myCar = new Car('Toyota', 'Corolla', 2021);
console.log(myCar.brand); // Output: Toyota

ในตัวอย่างข้างต้น ฟังก์ชัน `Car` ทำหน้าที่เป็น Constructor Function ที่กำหนดคุณสมบัติ `brand`, `model`, และ `year` เมื่อใช้คำสั่ง `new Car()` จะสร้างวัตถุใหม่ที่มีคุณสมบัติตามที่ระบุในฟังก์ชัน

 

ข้อดีของการใช้ Constructor Function

1. สร้างวัตถุหลายชิ้นได้ง่าย: ด้วย Constructor Function นักพัฒนาสามารถสร้างหลาย ๆ วัตถุที่มีโครงสร้างและคุณสมบัติเดียวกันได้ง่าย เพียงแค่การเปลี่ยนค่าพารามิเตอร์

2. โค้ดมีความกระชับและอ่านง่ายขึ้น: การใช้ Constructor Function ทำให้โค้ดดูเป็นระเบียบ และลดความซ้ำซ้อน

3. Encapsulation: สามารถสร้างและจัดการคุณสมบัติและวิธีการของวัตถุทั้งหมดได้ภายในฟังก์ชันเดียว เพิ่มความสามารถในการจัดการและดูแลรักษาโค้ด

 

กรณีศึกษา: การจัดการสินค้าที่ร้านค้า

ลองมาดูกรณีศึกษาการสร้างระบบจัดการสินค้าภายในร้านค้า โดยใช้ Constructor Function ในการสร้างวัตถุสินค้า

function Product(name, price, category) {
    this.name = name;
    this.price = price;
    this.category = category;
}

Product.prototype.discount = function(percent) {
    this.price = this.price * (1 - percent / 100);
    return this.price;
}

let laptop = new Product('Laptop', 1500, 'Electronics');
console.log(laptop.price); // Output: 1500

laptop.discount(10);
console.log(laptop.price); // Output: 1350

จากตัวอย่างข้างต้น เราได้สร้างฟังก์ชัน `Product` สำหรับสร้างวัตถุที่แทนสินค้า และเพิ่มเมธอด `discount` ให้กับ Prototype ของฟังก์ชันนั้น ๆ เพื่อที่จะลดราคาสินค้าได้

 

ข้อควรระวังในการใช้ Constructor Function

1. ข้อผิดพลาดจากการลืมใช้ `new`: หากเรียกใช้ฟังก์ชัน Constructor โดยไม่ใส่ `new` ระบบจะคืนค่าประเภท `undefined` หรือ `window` ซึ่งอาจก่อให้เกิดข้อผิดพลาดที่ยากในการตรวจสอบ

2. การใช้หน่วยความจำ: เมธอดที่กำหนดภายในฟังก์ชัน Constructor จะถูกสร้างขึ้นใหม่ทุกครั้งที่เรียกใช้ซึ่งอาจทำให้กลายเป็นปัญหาเรื่องการใช้หน่วยความจำในกรณีที่มีวัตถุบางรูปแบบเดียวกันจำนวนมาก

 

สรุป

การใช้ Constructor Function ใน JavaScript เป็นพื้นฐานที่แข็งแกร่งในการเข้าใจ OOP ด้วยความยืดหยุ่นและสะดวกในการใช้งาน Constructor Function ช่วยให้การสร้างวัตถุที่มีโครงสร้างซับซ้อนง่ายขึ้น นอกจากนี้ยังสนับสนุนแนวคิด Encapsulation ที่เป็นส่วนสำคัญใน OOP

การเขียนและใช้งาน OOP ใน JavaScript ด้วย Constructor Function สามารถเป็นอีกหนึ่งความท้าทายที่นักพัฒนาซอฟต์แวร์ควรศึกษาและเข้าใจอย่างลึกซึ้ง และสำหรับผู้ที่สนใจที่จะเรียนรู้เกี่ยวกับการเขียนโปรแกรมเพิ่มเติม การสนใจศึกษาการเขียนโปรแกรมที่ Expert-Programming-Tutor (EPT) ก็เป็นอีกทางเลือกหนึ่งในการพัฒนาทักษะได้อย่างมีประสิทธิภาพ

 

 

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

หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/