Command pattern คืออะไร?

Question

Accepted Answer

**Command** pattern ห่อหุ้ม **คำขอ (request) ให้เป็นออบเจ็กต์** โดยเปลี่ยนการกระทำให้เป็นออบเจ็กต์ที่เป็นอิสระพร้อมข้อมูลทั้งหมดของมัน สิ่งนี้ช่วยให้ทำ queuing, logging, undo/redo และลดการผูกติดระหว่างผู้ร้องขอกับผู้ดำเนินการได้

## Command pattern ทำอะไร

```text
COMMAND → encapsulate an action/request as an OBJECT (with its data and an execute method):
  → a command object knows WHAT to do and has the info to do it
  → the invoker triggers commands without knowing their details
  → decouples the object that INVOKES from the object that PERFORMS the action
→ "turn an action into an object" → store, pass, queue, log, undo it
```

## ตัวอย่าง

```js
// commands encapsulate actions
class AddTextCommand {
  constructor(doc, text) { this.doc = doc; this.text = text; }
  execute() { this.doc.add(this.text); }
  undo() { this.doc.remove(this.text); }   // commands can support undo
}
// invoker executes and tracks commands (for undo/redo)
const cmd = new AddTextCommand(doc, 'hello');
cmd.execute();
cmd.undo();   // reverse it
```

## มันช่วยให้ทำอะไรได้

```text
✓ UNDO/REDO → store executed commands; call undo()/redo() (each command knows how to reverse)
✓ QUEUING → queue commands to execute later; schedule; batch
✓ LOGGING → log commands (e.g. for replay, audit, transactions)
✓ DECOUPLING → invoker doesn't know the command's implementation (just calls execute())
USES → undo/redo (editors), task queues/jobs, transactional operations, action objects
  (e.g. Redux actions), macro recording, GUI buttons/menu items triggering commands
```

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

การเข้าใจ Command pattern มีคุณค่าเพราะมันเป็น **behavioral pattern ที่มีประโยชน์** ซึ่งเปิดทางให้ความสามารถสำคัญอย่าง undo/redo และ queuing จึงเป็นความรู้ด้านการออกแบบที่เกี่ยวข้อง

Command pattern ห่อหุ้มคำขอให้เป็นออบเจ็กต์ โดยเปลี่ยนการกระทำให้เป็นออบเจ็กต์อิสระที่มีข้อมูลของมันและ method execute ลดการผูกติดระหว่างผู้ร้องขอกับผู้ดำเนินการ

การเข้าใจว่ามันทำอะไร (แทนการกระทำเป็นออบเจ็กต์ที่รู้ว่าต้องทำอะไร โดย invoker กระตุ้น commands โดยไม่รู้รายละเอียดของมัน) คือความรู้แกนหลัก

การเข้าใจ **ว่ามันช่วยให้ทำอะไรได้** คือคุณค่าหลัก: **undo/redo** (เก็บ commands ที่ดำเนินการแล้วและเรียก undo/redo โดยแต่ละ command รู้วิธีย้อนกลับตัวเอง ซึ่งเป็นกรณีใช้งานคลาสสิกที่ทรงพลังสำหรับ editors และแอปพลิเคชัน), **queuing** (จัดคิว commands ให้ดำเนินการภายหลัง จัดตารางเวลา หรือทำเป็น batch), **logging** (บันทึก commands สำหรับ replay, audit หรือ transactions) และ **decoupling** (invoker ไม่รู้การ implement ของ command)

ความสามารถเหล่านี้ โดยเฉพาะ undo/redo และ queuing มีคุณค่าอย่างแท้จริงและ implement ให้สะอาดได้ยากหากไม่มี Command pattern

การเข้าใจ **การใช้งาน** ได้แก่ undo/redo ใน editors, task queues และ background jobs, transactional operations, action objects (เช่น Redux actions ซึ่งเป็นตัวอย่างสมัยใหม่ที่ใช้กันแพร่หลาย), การบันทึก macro และองค์ประกอบ GUI ที่กระตุ้น commands ช่วยให้เห็นการนำไปใช้ในโลกจริง

Command pattern เป็นวิธีที่สะอาดในการ implement undo/redo, queuing และสถาปัตยกรรมแบบอิงการกระทำ (action-based)

เนื่องจาก Command pattern เปิดทางให้ความสามารถสำคัญ (undo/redo, queuing, logging, decoupling) ที่มีคุณค่าและ implement ให้สะอาดได้ยากด้วยวิธีอื่น และเนื่องจากมันปรากฏในระบบจริง (editors, task queues, Redux actions) และเนื่องจากการเข้าใจว่ามันทำอะไรและช่วยให้ทำอะไรได้มีความเกี่ยวข้องต่อการ implement ความสามารถเหล่านี้ การเข้าใจ Command pattern จึงเป็นความรู้ด้านการออกแบบที่มีคุณค่าและเกี่ยวข้องในทางปฏิบัติ คือ pattern ที่มีประโยชน์ซึ่งเปิดทางให้ undo/redo, queuing และสถาปัตยกรรมแบบอิงการกระทำ (เช่น Redux actions) เป็นวิธีที่สะอาดในการ implement ความสามารถอันมีค่าเหล่านี้ และเป็นความรู้ด้านการออกแบบที่สำคัญสำหรับการกระทำที่ต้องถูกเก็บ จัดคิว บันทึก หรือยกเลิก