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.

## 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 ਜਿਵੇ ਮਹੱਤਵਪੂਰਨ ਸਮਰੱਥਾ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ relevant design knowledge ਹੈ।

Command pattern ਇਕ request ਨੂੰ object ਵਜੋਂ encapsulate ਕਰਦਾ ਹੈ — ਇਕ action ਨੂੰ ਇਕ standalone object ਵਿੱਚ ਬਦਲਦੇ ਹੋ ਇਸਦੇ data ਅਤੇ execute method ਦੇ ਨਾਲ, requester ਨੂੰ executor ਤੋਂ decoupling ਕਰਦੇ ਹੋ।

ਸਮਝਣਾ ਕਿ ਇਹ ਕੀ ਕਰਦਾ ਹੈ (ਇਕ action ਨੂੰ object ਵਜੋਂ represent ਕਰਨਾ ਜੋ ਜਾਣਦਾ ਹੈ ਕੀ ਕਰਨਾ ਹੈ, invoker ਦੇ ਨਾਲ commands ਨੂੰ trigger ਕਰਦੇ ਹੋ ਉਹਨਾਂ ਦੇ ਵਿਕਰਣਾ ਬਿਨਾ ਜਾਣਦੇ) core knowledge ਹੈ।

**ਇਹ ਕੀ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ** ਸਮਝਣਾ key value ਹੈ: **undo/redo** (executed commands ਨੂੰ store ਕਰਨਾ ਅਤੇ undo/redo ਨੂੰ call ਕਰਨਾ, ਹਰ command ਆਪਣੇ ਆਪ ਨੂੰ reverse ਕਰਨਾ ਜਾਣਦਾ ਹੈ — classic, powerful use case editors ਅਤੇ applications ਲਈ), **queuing** (commands ਨੂੰ queue ਕਰਨਾ later execute ਕਰਨ, schedule ਕਰਨ, ਜਾਂ batch ਕਰਨ ਲਈ), **logging** (commands ਨੂੰ log ਕਰਨਾ replay, audit, ਜਾਂ transactions ਲਈ), ਅਤੇ **decoupling** (invoker ਨੂੰ command ਦੀ implementation ਬਿਨਾ ਜਾਣਦੇ)।

ਇਹ ਸਮਰੱਥਾ — ਖਾਸ ਕਰਕੇ undo/redo ਅਤੇ queuing — genuinely valuable ਹਨ ਅਤੇ Command pattern ਬਿਨਾ cleanly implement ਕਰਨ ਮਸ਼ਕਲ ਹਨ।

**ਵਰਤਮਾਨਿਕਤਾ** ਨੂੰ ਸਮਝਣਾ — editors ਵਿੱਚ undo/redo, task queues ਅਤੇ background jobs, transactional operations, action objects (like Redux actions, ਇਕ widely-used modern example), macro recording, ਅਤੇ GUI elements triggering commands — ਇਸ ਦੀ real-world applicability ਨੂੰ ਸਪਸ਼ਟ ਕਰਦਾ ਹੈ।

Command pattern undo/redo, queuing, ਅਤੇ action-based architectures ਨੂੰ implement ਕਰਨ ਦਾ ਸਾਫ਼ ਤਰੀਕਾ ਹੈ।

ਕਿਉਂਕਿ Command pattern important capabilities (undo/redo, queuing, logging, decoupling) ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ ਜੋ valuable ਹਨ ਅਤੇ otherwise cleanly implement ਕਰਨ ਮਸ਼ਕਲ ਹਨ, ਅਤੇ ਕਿਉਂਕਿ ਇਹ real systems ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ (editors, task queues, Redux actions), ਅਤੇ ਕਿਉਂਕਿ ਇਹ ਸਮਝਣਾ ਕਿ ਇਹ ਕੀ ਕਰਦਾ ਅਤੇ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ relevant ਹੈ ਇਹਨਾਂ ਸਮਰੱਥਾ ਨੂੰ implement ਕਰਨ ਲਈ, Command pattern ਨੂੰ ਸਮਝਣਾ valuable, practically-relevant design knowledge ਹੈ — undo/redo, queuing, ਅਤੇ action-based architectures (like Redux actions) ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਵਾਲਾ ਇਕ ਉਪਯੋਗੀ pattern, ਇਹਨਾਂ valuable ਸਮਰੱਥਾ ਨੂੰ implement ਕਰਨ ਦਾ ਸਾਫ਼ ਤਰੀਕਾ, ਅਤੇ important design knowledge actions ਲਈ ਜੋ store, queue, log, ਜਾਂ undo ਹੋਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ।