JavaScript OOP - การสร้าง Objects ด้วย Constructors

การเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming: OOP) เป็นหนึ่งในแนวคิดการเขียนโปรแกรมที่ได้รับความนิยมอย่างแพร่หลาย และ JavaScript เองก็รองรับ OOP ด้วยเช่นกัน หนึ่งในจุดที่สำคัญของ OOP คือการสร้างและจัดการกับวัตถุ (Objects) โดยใช้ Constructors ซึ่งจะช่วยในการออกแบบโปรแกรมให้มีโครงสร้างที่ดี และง่ายต่อการดูแลรักษา

พื้นฐาน OOP ใน JavaScript

ใน JavaScript วัตถุ (Objects) เป็นสิ่งที่สร้างขึ้นมาจากฟังก์ชันที่เรียกว่า Constructors ซึ่งให้ความสามารถในการสร้างพิมพ์เขียว (Blueprint) ของวัตถุที่เราต้องการใช้งาน

Constructor คืออะไร?

Constructor ใน JavaScript เป็นฟังก์ชันชนิดพิเศษที่ใช้สำหรับสร้างและกำหนดค่าเริ่มต้นให้กับวัตถุใหม่ โดยทั่วไปการเรียกใช้งาน Constructor จะทำด้วยการใช้คำสั่ง `new` ตามด้วยฟังก์ชันที่ทำหน้าที่เป็น Constructor

การสร้าง Constructor ใน JavaScript

ลองพิจารณาตัวอย่างการสร้างวัตถุโดยใช้ Constructor:

// ฟังก์ชัน Constructor สำหรับสร้างวัตถุประเภท Car
function Car(brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
}

// การสร้างวัตถุใหม่จากฟังก์ชัน Constructor
const myCar = new Car('Toyota', 'Camry', 2021);

console.log(myCar.brand); // Output: Toyota
console.log(myCar.model); // Output: Camry
console.log(myCar.year);  // Output: 2021

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

การใช้ Prototype ร่วมกับ Constructor

ใน JavaScript ทุกฟังก์ชัน Constructor จะมี Property ชื่อ `prototype` ซึ่งใช้สำหรับกำหนดเมทอดที่สมาชิกทุกคนของประเภทนี้สามารถเข้าถึงได้ ตัวอย่างเช่น:

// การเพิ่มเมทอดผ่าน Prototype
Car.prototype.getFullDescription = function() {
    return `${this.brand} ${this.model} (${this.year})`;
};

console.log(myCar.getFullDescription()); // Output: Toyota Camry (2021)

การใช้ `prototype` สามารถช่วยประหยัดหน่วยความจำ เพราะทุกวัตถุที่สร้างขึ้นจาก Constructor เดียวกันจะใช้เมทอดเดียวกันโดยไม่ต้องทำการ copy เมทอดนั้นให้กับทุก ๆ วัตถุ

Use Case ของการใช้ Constructor

การใช้ Constructor ในการสร้างวัตถุเหมาะสมกับกรณีที่ต้องการสร้างวัตถุที่คล้ายกันหลาย ๆ ตัว เช่น ในแอปพลิเคชันการบริหารจัดการรถยนต์ เราอาจต้องการสร้างรายการรถยนต์ที่มีลักษณะและคุณสมบัติพื้นฐานคล้ายกัน Constructor ช่วยให้การสร้างและบริหารจัดการวัตถุเหล่านี้ง่ายขึ้นและมีระเบียบมากขึ้น

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

---

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

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

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