Menene Command pattern?

Question

Accepted Answer

The **Command** pattern encapsulates a **request as an object** — turning an action into a standalone object with all its information. This enables queuing, logging, undo/redo, and decoupling the requester from the executor.

## Abin da Command pattern ya ke yi

```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
```

## Example

```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
```

## Abin da ya ke ba da damar

```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
```

## Me ya sa aikin

Ganin Command pattern yana da kyau saboda yana da **bambanci a halaye" da ya ba da damar mahimma kamar undo/redo da queuing, saboda haka yana da alaka da ilmin zane.

Command pattern yana encapsulates request a matsayin object — yana canza wani aiki zuwa object mai tsaye tare da bayananciinsa da execute method, yana nisanta requester daga executor.

Ganin abin da ya ke yi (wakiltar aiki a matsayin object wanda ya sani abin da ya ke yi, tare da invoker yana aiwatar da commands ba tare da sani ba bayanancinsu) shine babbar ilmi.

Ganin **abin da ya ke ba da damar** shine babbar daraja: **undo/redo** (ajiye kakannun da aka aiwatar da kira undo/redo, tare da kowane command yana sani yadda zai juyoji kansa — haka gaske, karfin amfani ga edita da aikace-aikace), **queuing** (ajiye commands don aiwatar gida, tsattsari, ko batch), **logging** (logging commands don sake gabatarwa, bincike, ko kasuwance), da **decoupling** (invoker ba shi sani da aiwatar command).

Wanan iya — musamman undo/redo da queuing — suna da gatari gaske da kazo a sake aiwatar jiya ba tare da Command pattern ba.

Ganin **amfani** — undo/redo a editta, ajiye aiki da bita aiki, aiwatar kasuwance, aiki object (kamar Redux actions, bambanci mai amfani na jiya), recording macro, da GUI element yana aiwatar commands — yana bayyana ainihinsa ga ainihi.

Command pattern shine tsarin jiya don aiwatar undo/redo, queuing, da aiwatar aiki.

Don Command pattern yana ba da damar mahimma (undo/redo, queuing, logging, decoupling) wanda ke da daraja da kazo a sake aiwatar jiya haka, kuma don yana bayyana a tsarin gaske (edita, queuing aiki, Redux actions), kuma don ganin abin da ya ke yi da ba da damar yana da alaka don aiwatar wadannan iya, ganin Command pattern yana da daraja, kuma ainihinsa ilmin zane — bambanci mai amfani yana ba da damar undo/redo, queuing, da aiwatar aiki (kamar Redux actions), tsarin jiya don aiwatar wadannan iya mahimma, da mahimmanci ilmin zane don aiki wanda bukatar a ajiye, queuing, logging, ko juyoji.