Strategy pattern คืออะไร?

Question

Accepted Answer

**Strategy** pattern กำหนดกลุ่มของ**อัลกอริทึม/พฤติกรรม**ที่สลับกันได้ ห่อหุ้มแต่ละตัว และทำให้สลับกันได้ขณะ runtime มันช่วยให้คุณเลือกอัลกอริทึมแบบไดนามิกและหลีกเลี่ยงเงื่อนไขที่ซับซ้อน ส่งเสริมโค้ดที่ยืดหยุ่นและขยายได้

## Strategy pattern ทำอะไร

```text
STRATEGY → encapsulate INTERCHANGEABLE algorithms/behaviors behind a common interface:
  → define a family of strategies (each implements the same interface)
  → the context uses a strategy via the interface → can SWAP strategies at runtime
  → choose the behavior dynamically without changing the context
→ "compose" behavior instead of hardcoding it (favor composition over conditionals)
```

## ตัวอย่าง

```js
// different payment strategies, interchangeable
class CreditCardStrategy { pay(amount) { /* ... */ } }
class PayPalStrategy { pay(amount) { /* ... */ } }

class Checkout {
  constructor(strategy) { this.strategy = strategy; }   // inject a strategy
  process(amount) { this.strategy.pay(amount); }         // use it via the interface
}
new Checkout(new PayPalStrategy()).process(100);   // swap strategy easily
```

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

```text
BENEFITS:
  ✓ Swap/select algorithms at RUNTIME; add new strategies without changing the context
  ✓ Eliminates big if/else or switch on "type" (replace conditionals with strategies)
  ✓ Open/closed → extend with new strategies without modifying existing code
USES → payment methods, sorting algorithms, compression, validation rules, pricing,
  any "do X but the HOW varies" situation
```

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

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

Strategy pattern ห่อหุ้มอัลกอริทึมที่สลับกันได้ไว้หลัง interface ร่วมกัน ช่วยให้คุณสลับพฤติกรรมได้ขณะ runtime และเลือกมันแบบไดนามิก ตอบโจทย์ความต้องการที่พบบ่อยในการเปลี่ยน*วิธีการ*ทำบางสิ่งโดยไม่ต้องเปลี่ยนโค้ดที่ใช้มัน

การเข้าใจว่ามันทำอะไร (การกำหนดกลุ่มของ strategy ที่ implement interface ร่วมกัน โดย context ใช้ strategy ผ่าน interface นั้นเพื่อให้สลับ strategy ได้) เป็นความรู้แกนหลัก

การเข้าใจ**ประโยชน์**เป็นสิ่งสำคัญ มันช่วยให้คุณ**สลับหรือเลือกอัลกอริทึมขณะ runtime** **เพิ่ม strategy ใหม่โดยไม่ต้องเปลี่ยน context** (ตามหลัก open/closed คือขยายโดยไม่แก้ไข) และโดยเฉพาะ**กำจัด if/else หรือ switch ขนาดใหญ่**ตาม type (แทนที่เงื่อนไขที่กระจัดกระจายด้วย strategy ที่สลับกันได้อย่างสะอาด ซึ่งเป็นการ refactor ที่พบบ่อยและปรับปรุงโค้ดได้อย่างมาก)

ประโยชน์ข้อสุดท้ายนี้มีคุณค่าเป็นพิเศษ เพราะ Strategy pattern เป็นทางออกที่สะอาดสำหรับปัญหาที่พบบ่อยคือ logic เงื่อนไขที่เลือกพฤติกรรม

การเข้าใจ**การใช้งาน** ได้แก่ วิธีการชำระเงิน อัลกอริทึมการเรียงลำดับ การบีบอัด กฎ validation การตั้งราคา และทุกสถานการณ์ที่ "ทำ X แต่วิธีการแตกต่างกัน" ทำให้ชัดเจนถึงการนำไปใช้ได้อย่างกว้างขวาง

pattern นี้ส่งเสริม composition แทนเงื่อนไขที่ hardcode ไว้ นำไปสู่โค้ดที่ยืดหยุ่น ขยายได้ และดูแลรักษาง่ายขึ้น

เนื่องจาก Strategy pattern เป็น behavioral pattern ที่พบบ่อยและมีประโยชน์สำหรับโค้ดที่ยืดหยุ่นและขยายได้ (สลับอัลกอริทึมขณะ runtime กำจัดเงื่อนไข ตามหลัก open/closed) และเนื่องจากการเข้าใจว่ามันทำอะไร ประโยชน์ของมัน และการใช้งานของมันเกี่ยวข้องในเชิงปฏิบัติต่อการเขียนโค้ดที่ดูแลรักษาง่าย การเข้าใจ Strategy pattern จึงเป็นความรู้การออกแบบที่มีคุณค่าและนำไปใช้ได้บ่อย เป็น pattern ที่มีประโยชน์บ่อยสำหรับการเปลี่ยนพฤติกรรมอย่างยืดหยุ่น กำจัดเงื่อนไขที่กระจัดกระจาย และทำตามหลักการออกแบบที่ดี นำไปใช้ได้ในหลายสถานการณ์จริงและสำคัญต่อการเขียนโค้ดที่ขยายได้และดูแลรักษาง่าย