Builder pattern คืออะไร?

Question

Accepted Answer

**Builder** pattern สร้างอ็อบเจ็กต์ที่ซับซ้อน**ทีละขั้น** โดยแยกการสร้างออกจากการแสดงผล มันมีประโยชน์เป็นพิเศษสำหรับอ็อบเจ็กต์ที่มี parameter หรือส่วนที่ไม่บังคับจำนวนมาก ทำให้การสร้างอ็อบเจ็กต์อ่านง่ายและยืดหยุ่นแทนที่จะเป็น constructor ที่เทอะทะ

## ปัญหาที่ Builder แก้

```text
Objects with MANY parameters (especially optional ones) lead to problems:
  ✗ huge constructors: new Pizza('large', true, false, true, 'thin', false, ...) →
    unreadable (which boolean is what?); hard to use; error-prone
  ✗ many constructor overloads (telescoping constructors) → messy
→ Builder provides a clean, readable, step-by-step way to construct such objects.
```

## Builder ทำงานอย่างไร

```js
// build step-by-step with named, chainable methods
const pizza = new PizzaBuilder()
  .setSize('large')
  .addTopping('cheese')
  .addTopping('mushroom')
  .setThinCrust(true)
  .build();                    // produce the final object
// → readable; only set what you need; flexible construction
```

แต่ละเมธอดกำหนดค่าส่วนหนึ่งของอ็อบเจ็กต์และคืน builder กลับมา (chaining) ส่วน `build()` สร้างอ็อบเจ็กต์สุดท้าย

## ประโยชน์และการใช้งาน

```text
BENEFITS:
  ✓ READABLE → named methods (clear what each value is) vs positional constructor args
  ✓ FLEXIBLE → set only the parts you need (handles optional parameters cleanly)
  ✓ Can enforce VALIDATION / required fields in build(); immutable result
  ✓ Avoids telescoping constructors / huge parameter lists
USES → complex configuration objects, query builders (SQL), HTTP request builders, objects
  with many optional fields; common in many libraries/APIs (fluent interfaces)
```

## ทำไมจึงสำคัญ

การเข้าใจ Builder pattern มีคุณค่า เพราะมันเป็น **creational pattern ที่ใช้งานได้จริงและมีประโยชน์บ่อย** สำหรับการสร้างอ็อบเจ็กต์ที่ซับซ้อนอย่างสะอาด จึงเป็นความรู้การออกแบบที่เกี่ยวข้อง

Builder pattern ตอบโจทย์ปัญหาจริงที่พบบ่อย คืออ็อบเจ็กต์ที่มี **parameter จำนวนมาก (โดยเฉพาะที่ไม่บังคับ)** นำไปสู่การสร้างที่อ่านยากและเกิดข้อผิดพลาดง่าย ได้แก่ constructor ที่เทอะทะซึ่งไม่ชัดเจนว่า argument แต่ละตำแหน่งหมายถึงอะไร (`new Pizza('large', true, false, true, ...)`) หรือ constructor overload แบบ telescoping ที่ยุ่งเหยิง

Builder แก้ปัญหานี้ด้วย**การสร้างทีละขั้น**โดยใช้เมธอดที่มีชื่อและ chain ได้ ทำให้การสร้างอ็อบเจ็กต์อ่านง่ายและยืดหยุ่น

การเข้าใจว่ามันทำงานอย่างไร (เมธอดที่ chain ได้กำหนดค่าส่วนต่าง ๆ ของอ็อบเจ็กต์ โดยมี `build()` สร้างผลลัพธ์สุดท้าย) เป็นความรู้แกนหลัก

การเข้าใจ**ประโยชน์**เป็นสิ่งสำคัญ ได้แก่ **ความอ่านง่าย** (เมธอดที่มีชื่อทำให้ชัดเจนว่าแต่ละค่าคืออะไร แทน argument ตามตำแหน่งที่คลุมเครือ), **ความยืดหยุ่น** (กำหนดเฉพาะส่วนที่คุณต้องการ จัดการ parameter ที่ไม่บังคับได้อย่างสะอาด), ความสามารถในการ**บังคับ validation และ field ที่จำเป็น**ใน `build()` (และสร้างผลลัพธ์แบบ immutable) และการหลีกเลี่ยง telescoping constructor

สิ่งเหล่านี้ทำให้ Builder ใช้งานได้จริงอย่างแท้จริงสำหรับปัญหาที่พบบ่อย

การเข้าใจ**การใช้งาน** ได้แก่ configuration object ที่ซับซ้อน, query builder (SQL), HTTP request builder และอ็อบเจ็กต์ที่มี field ไม่บังคับจำนวนมาก (มักพบในรูปแบบ fluent interface ใน library และ API จำนวนมาก) ทำให้ชัดเจนถึงการนำไปใช้ในโลกจริงอย่างกว้างขวาง

Builder pattern เป็นหนึ่งใน pattern ที่ใช้งานได้จริงมากกว่าตัวอื่น ปรากฏบ่อยใน API จริงเพราะอ็อบเจ็กต์ที่มี parameter ไม่บังคับจำนวนมากพบได้บ่อย

เนื่องจาก Builder pattern เป็น creational pattern ที่ใช้งานได้จริงและมีประโยชน์บ่อยที่แก้ปัญหาจริงของการสร้างอ็อบเจ็กต์ที่มี parameter จำนวนมากได้อย่างสะอาด (การสร้างทีละขั้นที่อ่านง่ายและยืดหยุ่นโดยหลีกเลี่ยง constructor ที่เทอะทะ) และเนื่องจากการเข้าใจมัน ประโยชน์ของมัน และการใช้งานของมันเกี่ยวข้องต่อการเขียนการสร้างอ็อบเจ็กต์ที่สะอาด การเข้าใจ Builder pattern จึงเป็นความรู้การออกแบบที่มีคุณค่าและเกี่ยวข้องในเชิงปฏิบัติ เป็น pattern ที่มีประโยชน์อย่างแท้จริงสำหรับปัญหาที่พบบ่อยของการสร้างอ็อบเจ็กต์ที่ซับซ้อน พบบ่อยใน API จริงในรูปแบบ fluent interface และเป็นความรู้การออกแบบที่สำคัญสำหรับการสร้างอ็อบเจ็กต์ที่มี parameter จำนวนมากให้อ่านง่ายและยืดหยุ่น