---
title: "الأمر (Command)"
type: "design-pattern"
slug: "command"
url: "http://localhost:3000/ar/design-patterns/command.md"
category: "الأنماط السلوكية"
description: "الأمر (Command) هو نمط تصميم سلوكي يحوّل الطلب إلى كائن مستقل يحتوي على جميع المعلومات المتعلقة بالطلب. يتيح لك هذا التحويل تمرير الطلبات كوسائط للطرائق، وتأجيل تنفيذ الطلب أو وضعه في طابور، ودعم العمليات القابلة للتراجع."
languages: ["java", "csharp", "cpp", "go", "php", "python", "ruby", "rust", "swift", "typescript"]
---
# الأمر (Command)

> الأمر (Command) هو نمط تصميم سلوكي يحوّل الطلب إلى كائن مستقل يحتوي على جميع المعلومات المتعلقة بالطلب. يتيح لك هذا التحويل تمرير الطلبات كوسائط للطرائق، وتأجيل تنفيذ الطلب أو وضعه في طابور، ودعم العمليات القابلة للتراجع.

## Intent

**الأمر (Command)** هو نمط تصميم سلوكي يحوّل الطلب إلى كائن مستقل يحتوي على جميع المعلومات المتعلقة بالطلب. ويتيح لك هذا التحويل تمرير الطلبات كوسائط للطرائق، وتأجيل تنفيذ الطلب أو وضعه في طابور، ودعم العمليات القابلة للتراجع.

## Problem

تخيّل أنك تعمل على تطبيق محرر نصوص جديد. ومهمتك الحالية هي إنشاء شريط أدوات يضم مجموعة من الأزرار لمختلف عمليات المحرر. وقد أنشأت صنف `Button` أنيقاً جداً يمكن استخدامه لأزرار شريط الأدوات، وكذلك لأزرار عامة في مختلف نوافذ الحوار.

جميع أزرار التطبيق مشتقة من الصنف نفسه.

ومع أن كل هذه الأزرار تبدو متشابهة، فإن من المفترض أن يؤدي كلٌّ منها شيئاً مختلفاً. فأين ستضع الكود الخاص بمعالِجات النقر المختلفة لهذه الأزرار؟ أبسط حل هو إنشاء عدد هائل من الأصناف الفرعية لكل موضع يُستخدم فيه الزر. وستحتوي هذه الأصناف الفرعية على الكود الذي يجب تنفيذه عند النقر على الزر.

الكثير من الأصناف الفرعية للأزرار. ما الذي قد يسوء؟

وسرعان ما تدرك أن هذا النهج معيب بعمق. أولاً، لديك عدد هائل من الأصناف الفرعية، وهذا قد يكون مقبولاً لولا أنك تخاطر بكسر الكود في هذه الأصناف الفرعية في كل مرة تعدّل فيها صنف `Button` الأساسي. وببساطة، أصبح كود واجهتك الرسومية معتمداً على نحوٍ محرج على الكود المتقلب لمنطق العمل.

عدة أصناف تنفّذ الوظيفة نفسها.

وإليك الجزء الأسوأ. بعض العمليات، مثل نسخ/لصق النص، ستحتاج إلى استدعائها من مواضع متعددة. فمثلاً، قد ينقر المستخدم زر «نسخ» الصغير على شريط الأدوات، أو ينسخ شيئاً عبر القائمة السياقية، أو يضغط ببساطة `Ctrl+C` على لوحة المفاتيح.

في البداية، عندما كان تطبيقنا يضم شريط الأدوات فقط، كان من المقبول وضع تنفيذ مختلف العمليات داخل الأصناف الفرعية للأزرار. وبعبارة أخرى، كان وضع كود نسخ النص داخل الصنف الفرعي `CopyButton` أمراً جيداً. لكن لاحقاً، عندما تنفّذ القوائم السياقية والاختصارات وأشياء أخرى، ستضطر إما إلى تكرار كود العملية في أصناف كثيرة، أو جعل القوائم معتمدة على الأزرار، وهو خيار أسوأ.

## Solution

كثيراً ما يستند تصميم البرمجيات الجيد إلى _مبدأ فصل الاهتمامات_، الذي يؤدي عادةً إلى تقسيم التطبيق إلى طبقات. والمثال الأكثر شيوعاً: طبقة لواجهة المستخدم الرسومية وطبقة أخرى لمنطق العمل. وتكون طبقة الواجهة الرسومية مسؤولة عن رسم صورة جميلة على الشاشة، والتقاط أي مُدخلات، وعرض نتائج ما يفعله المستخدم والتطبيق. لكن حين يتعلق الأمر بفعل شيء مهم، كحساب مسار القمر أو إعداد تقرير سنوي، تفوّض طبقة الواجهة الرسومية العمل إلى الطبقة الأساسية لمنطق العمل.

وفي الكود قد يبدو ذلك هكذا: كائن واجهة رسومية يستدعي طريقة لكائن منطق عمل، مُمرِّراً إليه بعض الوسائط. وتُوصف هذه العملية عادةً بأنها كائن يرسل إلى آخر _طلباً_.

قد تصل كائنات الواجهة الرسومية إلى كائنات منطق العمل مباشرةً.

يقترح نمط الأمر ألا ترسل كائنات الواجهة الرسومية هذه الطلبات مباشرةً. وبدلاً من ذلك، ينبغي لك استخراج كل تفاصيل الطلب، مثل الكائن المُستدعى واسم الطريقة وقائمة الوسائط، إلى صنف _أمر_ منفصل بطريقة واحدة تُطلِق هذا الطلب.

تعمل كائنات الأوامر كروابط بين مختلف كائنات الواجهة الرسومية وكائنات منطق العمل. ومن الآن فصاعداً، لا يحتاج كائن الواجهة الرسومية إلى معرفة أي كائن منطق عمل سيتلقّى الطلب وكيف ستتم معالجته. فكائن الواجهة الرسومية يكتفي بإطلاق الأمر الذي يتولّى كل التفاصيل.

الوصول إلى طبقة منطق العمل عبر أمر.

الخطوة التالية هي جعل أوامرك تُنفّذ الواجهة نفسها. وعادةً ما تحتوي على طريقة تنفيذ واحدة فقط لا تأخذ أي معاملات. وتتيح لك هذه الواجهة استخدام أوامر مختلفة مع مُرسِل الطلب نفسه، دون اقترانه بأصناف أوامر محددة. وكمكافأة، يمكنك الآن تبديل كائنات الأوامر المرتبطة بالمُرسِل، فتغيّر فعلياً سلوك المُرسِل أثناء التشغيل.

ربما لاحظت قطعة ناقصة من الأحجية، وهي معاملات الطلب. فقد يكون كائن الواجهة الرسومية قد زوّد كائن طبقة العمل ببعض المعاملات. وبما أن طريقة تنفيذ الأمر لا تأخذ أي معاملات، فكيف نمرّر تفاصيل الطلب إلى المستقبِل؟ يتبيّن أن الأمر ينبغي إما أن يكون مُهيّأً مسبقاً بهذه البيانات، أو قادراً على الحصول عليها بنفسه.

كائنات الواجهة الرسومية تفوّض العمل إلى الأوامر.

لنعُد إلى محرر النصوص لدينا. فبعد تطبيق نمط الأمر، لم نعُد بحاجة إلى كل تلك الأصناف الفرعية للأزرار لتنفيذ سلوكيات النقر المختلفة. إذ يكفي وضع حقل واحد في صنف `Button` الأساسي يخزّن مرجعاً إلى كائن أمر، وجعل الزر ينفّذ ذلك الأمر عند النقر.

ستنفّذ مجموعة من أصناف الأوامر لكل عملية ممكنة وتربطها بأزرار معيّنة، تبعاً للسلوك المقصود من الأزرار.

ويمكن تنفيذ عناصر الواجهة الرسومية الأخرى، مثل القوائم أو الاختصارات أو نوافذ الحوار بأكملها، بالطريقة نفسها. إذ ستُربط بأمر يُنفَّذ عندما يتفاعل المستخدم مع عنصر الواجهة الرسومية. وكما خمّنت على الأرجح الآن، ستُربط العناصر المتعلقة بالعمليات نفسها بالأوامر نفسها، ما يمنع أي تكرار للكود.

ونتيجةً لذلك، تصبح الأوامر طبقة وسطى مريحة تقلّل الاقتران بين طبقتي الواجهة الرسومية ومنطق العمل. وهذا ليس إلا جزءاً يسيراً من الفوائد التي يقدّمها نمط الأمر!

## Structure

1. صنف **المُرسِل (Sender)** (ويُعرف أيضاً بـ _المُستدعي/invoker_) مسؤول عن بدء الطلبات. ويجب أن يحتوي هذا الصنف على حقل لتخزين مرجع إلى كائن أمر. ويُطلِق المُرسِل ذلك الأمر بدلاً من إرسال الطلب مباشرةً إلى المستقبِل. لاحظ أن المُرسِل ليس مسؤولاً عن إنشاء كائن الأمر. وعادةً ما يحصل على أمر مُنشأ مسبقاً من العميل عبر الباني.
2. واجهة **الأمر (Command)** تُعلن عادةً طريقة واحدة فقط لتنفيذ الأمر.
3. **الأوامر المحددة (Concrete Commands)** تنفّذ أنواعاً مختلفة من الطلبات. ولا يُفترض بالأمر المحدد أن ينفّذ العمل بنفسه، بل أن يمرّر الاستدعاء إلى أحد كائنات منطق العمل. غير أنه لأجل تبسيط الكود، يمكن دمج هذه الأصناف.
يمكن إعلان المعاملات اللازمة لتنفيذ طريقة على كائن مستقبِل كحقول في الأمر المحدد. ويمكنك جعل كائنات الأوامر غير قابلة للتغيير بالسماح فقط بتهيئة هذه الحقول عبر الباني.
4. صنف **المستقبِل (Receiver)** يحتوي على بعض منطق العمل. ويمكن لأي كائن تقريباً أن يؤدي دور المستقبِل. ومعظم الأوامر تتولّى فقط تفاصيل كيفية تمرير الطلب إلى المستقبِل، بينما يقوم المستقبِل نفسه بالعمل الفعلي.
5. **العميل (Client)** يُنشئ كائنات الأوامر المحددة ويهيّئها. ويجب على العميل تمرير جميع معاملات الطلب، بما في ذلك نسخة من المستقبِل، إلى باني الأمر. وبعد ذلك، يمكن ربط الأمر الناتج بمُرسِل واحد أو عدة مُرسِلات.

## Pseudocode

في هذا المثال، يساعد نمط **الأمر (Command)** على تتبّع سجلّ العمليات المنفَّذة ويجعل من الممكن التراجع عن عملية عند الحاجة.

عمليات قابلة للتراجع في محرر نصوص.

الأوامر التي تؤدي إلى تغيير حالة المحرر (مثل القص واللصق) تُنشئ نسخة احتياطية من حالة المحرر قبل تنفيذ العملية المرتبطة بالأمر. وبعد تنفيذ الأمر، يُوضع في سجلّ الأوامر (مكدّس من كائنات الأوامر) إلى جانب النسخة الاحتياطية من حالة المحرر عند تلك اللحظة. ولاحقاً، إذا احتاج المستخدم إلى التراجع عن عملية، يمكن للتطبيق أن يأخذ أحدث أمر من السجلّ، ويقرأ النسخة الاحتياطية المرتبطة بحالة المحرر، ويستعيدها.

كود العميل (عناصر الواجهة الرسومية، وسجلّ الأوامر، وغير ذلك) غير مقترن بأصناف الأوامر المحددة لأنه يتعامل مع الأوامر عبر واجهة الأمر. ويتيح لك هذا النهج إدخال أوامر جديدة إلى التطبيق دون كسر أي كود موجود.

// صنف الأمر الأساسي يُعرّف الواجهة المشتركة لجميع الأوامر المحددة.
abstract class Command is
    protected field app: Application
    protected field editor: Editor
    protected field backup: text

    constructor Command(app: Application, editor: Editor) is
        this.app = app
        this.editor = editor

    // إنشاء نسخة احتياطية من حالة المحرر.
    method saveBackup() is
        backup = editor.text

    // استعادة حالة المحرر.
    method undo() is
        editor.text = backup

    // تُعلَن طريقة التنفيذ مجردة لإجبار جميع الأوامر المحددة على تقديم تنفيذها الخاص. ويجب أن تُعيد الطريقة true أو false تبعاً لما إذا كان الأمر يغيّر حالة المحرر.
    abstract method execute()

// الأوامر المحددة تأتي هنا.
class CopyCommand extends Command is
    // لا يُحفظ أمر النسخ في السجلّ لأنه لا يغيّر حالة المحرر.
    method execute() is
        app.clipboard = editor.getSelection()
        return false

class CutCommand extends Command is
    // أمر القص يغيّر حالة المحرر فعلاً، لذا يجب حفظه في السجلّ. وسيُحفظ ما دامت الطريقة تُعيد true.
    method execute() is
        saveBackup()
        app.clipboard = editor.getSelection()
        editor.deleteSelection()
        return true

class PasteCommand extends Command is
    method execute() is
        saveBackup()
        editor.replaceSelection(app.clipboard)
        return true

// عملية التراجع هي أيضاً أمر.
class UndoCommand extends Command is
    method execute() is
        app.undo()
        return false

// سجلّ الأوامر العام ما هو إلا مكدّس.
class CommandHistory is
    private field history: array of Command

    // آخر الداخلين...
    method push(c: Command) is
        // دفع الأمر إلى نهاية مصفوفة السجلّ.

    // ...أول الخارجين
    method pop():Command is
        // الحصول على أحدث أمر من السجلّ.

// يحتوي صنف المحرر على عمليات تحرير النص الفعلية، وهو يؤدي دور المستقبِل: إذ تنتهي جميع الأوامر بتفويض التنفيذ إلى طرائق المحرر.
class Editor is
    field text: string

    method getSelection() is
        // إعادة النص المحدد.

    method deleteSelection() is
        // حذف النص المحدد.

    method replaceSelection(text) is
        // إدراج محتويات الحافظة عند الموضع الحالي.

// يُهيّئ صنف التطبيق العلاقات بين الكائنات، وهو يؤدي دور المُرسِل: فعندما يلزم تنفيذ شيء ما، يُنشئ كائن أمر وينفّذه.
class Application is
    field clipboard: string
    field editors: array of Editors
    field activeEditor: Editor
    field history: CommandHistory

    // قد يبدو الكود الذي يُسنِد الأوامر إلى كائنات الواجهة كما يلي.
    method createUI() is
        // ...
        copy = function() { executeCommand(
            new CopyCommand(this, activeEditor)) }
        copyButton.setCommand(copy)
        shortcuts.onKeyPress("Ctrl+C", copy)

        cut = function() { executeCommand(
            new CutCommand(this, activeEditor)) }
        cutButton.setCommand(cut)
        shortcuts.onKeyPress("Ctrl+X", cut)

        paste = function() { executeCommand(
            new PasteCommand(this, activeEditor)) }
        pasteButton.setCommand(paste)
        shortcuts.onKeyPress("Ctrl+V", paste)

        undo = function() { executeCommand(
            new UndoCommand(this, activeEditor)) }
        undoButton.setCommand(undo)
        shortcuts.onKeyPress("Ctrl+Z", undo)

    // تنفيذ أمر والتحقق مما إذا كان يجب إضافته إلى السجلّ.
    method executeCommand(command) is
        if (command.execute())
            history.push(command)

    // أخذ أحدث أمر من السجلّ وتشغيل طريقة التراجع الخاصة به. لاحظ أننا لا نعرف صنف ذلك الأمر، لكننا لسنا بحاجة لذلك، لأن الأمر يعرف كيف يتراجع عن فعله الخاص.
    method undo() is
        command = history.pop()
        if (command != null)
            command.undo()

## Applicability

استخدم نمط الأمر (Command) عندما تريد تحديد معاملات الكائنات بعمليات.

 يمكن لنمط الأمر أن يحوّل استدعاء طريقة معيّن إلى كائن مستقل. ويفتح هذا التغيير الكثير من الاستخدامات المثيرة للاهتمام: إذ يمكنك تمرير الأوامر كوسائط للطرائق، وتخزينها داخل كائنات أخرى، وتبديل الأوامر المرتبطة أثناء التشغيل، وغير ذلك.

إليك مثالاً: أنت تطوّر مكوّن واجهة رسومية مثل قائمة سياقية، وتريد أن يتمكّن مستخدموك من ضبط عناصر القائمة التي تُطلِق عمليات عندما ينقر المستخدم النهائي على عنصر.

 استخدم نمط الأمر عندما تريد وضع العمليات في طابور، أو جدولة تنفيذها، أو تنفيذها عن بُعد.

 كأي كائن آخر، يمكن إجراء تسلسل (serialization) للأمر، أي تحويله إلى سلسلة نصية يسهل كتابتها إلى ملف أو قاعدة بيانات. ولاحقاً، يمكن استعادة السلسلة النصية ككائن الأمر الأصلي. وبذلك يمكنك تأجيل تنفيذ الأمر وجدولته. لكن هناك ما هو أكثر من ذلك! وبالطريقة نفسها، يمكنك وضع الأوامر في طابور أو تسجيلها أو إرسالها عبر الشبكة.

 استخدم نمط الأمر عندما تريد تنفيذ عمليات قابلة للعكس.

 رغم وجود طرق كثيرة لتنفيذ التراجع/الإعادة (undo/redo)، فإن نمط الأمر ربما يكون الأكثر شيوعاً بينها جميعاً.

لتتمكّن من التراجع عن العمليات، تحتاج إلى تنفيذ سجلّ بالعمليات المنفَّذة. وسجلّ الأوامر هو مكدّس يحتوي على جميع كائنات الأوامر المنفَّذة إلى جانب النسخ الاحتياطية المرتبطة بحالة التطبيق.

لهذه الطريقة عيبان. أولاً، ليس من السهل حفظ حالة التطبيق لأن بعضها قد يكون خاصاً. ويمكن التخفيف من هذه المشكلة باستخدام نمط [Memento](/ar/design-patterns/memento).

ثانياً، قد تستهلك النسخ الاحتياطية للحالة قدراً كبيراً من ذاكرة الوصول العشوائي (RAM). لذلك يمكنك أحياناً اللجوء إلى تنفيذ بديل: فبدلاً من استعادة الحالة السابقة، ينفّذ الأمر العملية العكسية. لكن العملية العكسية لها ثمنها أيضاً: فقد يتبيّن أنها صعبة أو حتى مستحيلة التنفيذ.

## How to Implement

1. أعلِن واجهة الأمر بطريقة تنفيذ واحدة.
2. ابدأ باستخراج الطلبات إلى أصناف أوامر محددة تُنفّذ واجهة الأمر. ويجب أن يحتوي كل صنف على مجموعة من الحقول لتخزين وسائط الطلب إلى جانب مرجع إلى كائن المستقبِل الفعلي. ويجب تهيئة كل هذه القيم عبر باني الأمر.
3. حدّد الأصناف التي ستؤدي دور _المُرسِلات_. وأضِف إلى هذه الأصناف الحقول اللازمة لتخزين الأوامر. وينبغي أن تتواصل المُرسِلات مع أوامرها عبر واجهة الأمر فقط. وعادةً لا تُنشئ المُرسِلات كائنات الأوامر بنفسها، بل تحصل عليها من كود العميل.
4. غيّر المُرسِلات بحيث تنفّذ الأمر بدلاً من إرسال طلب إلى المستقبِل مباشرةً.
5. ينبغي للعميل تهيئة الكائنات بالترتيب التالي:

  * إنشاء المستقبِلات.
  * إنشاء الأوامر، وربطها بالمستقبِلات عند الحاجة.
  * إنشاء المُرسِلات، وربطها بأوامر محددة.

## Pros

* _مبدأ المسؤولية الواحدة_. يمكنك فصل الأصناف التي تستدعي العمليات عن الأصناف التي تنفّذ هذه العمليات.
* _مبدأ الانفتاح/الانغلاق_. يمكنك إدخال أوامر جديدة إلى التطبيق دون كسر كود العميل الموجود.
* يمكنك تنفيذ التراجع/الإعادة (undo/redo).
* يمكنك تنفيذ التأجيل لتنفيذ العمليات.
* يمكنك تجميع مجموعة من الأوامر البسيطة في أمر معقّد.

## Cons

* قد يصبح الكود أكثر تعقيداً لأنك تُدخل طبقة جديدة كاملة بين المُرسِلات والمستقبِلات.

## Relations with Other Patterns

* تتناول أنماط [Chain of Responsibility](/ar/design-patterns/chain-of-responsibility) و[Command](/ar/design-patterns/command) و[Mediator](/ar/design-patterns/mediator) و[Observer](/ar/design-patterns/observer) طرقاً مختلفة لربط مُرسِلات الطلبات بمستقبِليها:

  * _Chain of Responsibility_ يمرّر الطلب تتابعياً على طول سلسلة ديناميكية من المستقبِلات المحتملة حتى يعالجه أحدها.
  * _Command_ يُنشئ روابط أحادية الاتجاه بين المُرسِلات والمستقبِلات.
  * _Mediator_ يُزيل الروابط المباشرة بين المُرسِلات والمستقبِلات، مُجبراً إياها على التواصل بشكل غير مباشر عبر كائن وسيط.
  * _Observer_ يتيح للمستقبِلات الاشتراك في تلقّي الطلبات وإلغاء الاشتراك ديناميكياً.
* يمكن تنفيذ المعالِجات في [Chain of Responsibility](/ar/design-patterns/chain-of-responsibility) على هيئة [Commands](/ar/design-patterns/command). وفي هذه الحالة، يمكنك تنفيذ الكثير من العمليات المختلفة على كائن السياق نفسه، الذي يُمثَّل بطلب.
غير أن هناك نهجاً آخر، يكون فيه الطلب نفسه كائن _Command_. وفي هذه الحالة، يمكنك تنفيذ العملية نفسها في سلسلة من السياقات المختلفة المرتبطة في سلسلة.
* يمكنك استخدام [Command](/ar/design-patterns/command) و[Memento](/ar/design-patterns/memento) معاً عند تنفيذ «التراجع». وفي هذه الحالة، تكون الأوامر مسؤولة عن تنفيذ عمليات مختلفة على كائن هدف، بينما تحفظ الـ mementos حالة ذلك الكائن قُبيل تنفيذ الأمر مباشرةً.
* قد يبدو [Command](/ar/design-patterns/command) و[Strategy](/ar/design-patterns/strategy) متشابهين لأنه يمكنك استخدام كليهما لتحديد كائن بفعل ما كمعامل. غير أن لهما مقاصد مختلفة جداً.

  * يمكنك استخدام _Command_ لتحويل أي عملية إلى كائن. وتصبح معاملات العملية حقولاً في ذلك الكائن. ويتيح لك هذا التحويل تأجيل تنفيذ العملية، أو وضعها في طابور، أو تخزين سجلّ الأوامر، أو إرسال الأوامر إلى خدمات بعيدة، وغير ذلك.
  * من ناحية أخرى، يصف _Strategy_ عادةً طرقاً مختلفة لفعل الشيء نفسه، ما يتيح لك تبديل هذه الخوارزميات ضمن صنف سياق واحد.
* يمكن أن يساعد [Prototype](/ar/design-patterns/prototype) عندما تحتاج إلى حفظ نسخ من [Commands](/ar/design-patterns/command) في السجلّ.
* يمكنك اعتبار [Visitor](/ar/design-patterns/visitor) نسخةً قوية من نمط [Command](/ar/design-patterns/command). إذ يمكن لكائناته تنفيذ عمليات على كائنات شتى من أصناف مختلفة.
## Relations

**Related patterns**

- [سلسلة المسؤوليات](/ar/design-patterns/chain-of-responsibility.md)
- [الوسيط](/ar/design-patterns/mediator.md)
- [المراقب](/ar/design-patterns/observer.md)
- [التذكار](/ar/design-patterns/memento.md)
- [الاستراتيجية](/ar/design-patterns/strategy.md)
- [النموذج الأولي (Prototype)](/ar/design-patterns/prototype.md)
- [الزائر](/ar/design-patterns/visitor.md)

## Code Examples

### java

```java
package refactoring_guru.command.example.commands;

import refactoring_guru.command.example.editor.Editor;

public abstract class Command {
    public Editor editor;
    private String backup;

    Command(Editor editor) {
        this.editor = editor;
    }

    void backup() {
        backup = editor.textField.getText();
    }

    public void undo() {
        editor.textField.setText(backup);
    }

    public abstract boolean execute();
}

package refactoring_guru.command.example.commands;

import refactoring_guru.command.example.editor.Editor;

public class CopyCommand extends Command {

    public CopyCommand(Editor editor) {
        super(editor);
    }

    @Override
    public boolean execute() {
        editor.clipboard = editor.textField.getSelectedText();
        return false;
    }
}

package refactoring_guru.command.example.commands;

import refactoring_guru.command.example.editor.Editor;

public class PasteCommand extends Command {

    public PasteCommand(Editor editor) {
        super(editor);
    }

    @Override
    public boolean execute() {
        if (editor.clipboard == null || editor.clipboard.isEmpty()) return false;

        backup();
        editor.textField.insert(editor.clipboard, editor.textField.getCaretPosition());
        return true;
    }
}

package refactoring_guru.command.example.commands;

import refactoring_guru.command.example.editor.Editor;

public class CutCommand extends Command {

    public CutCommand(Editor editor) {
        super(editor);
    }

    @Override
    public boolean execute() {
        if (editor.textField.getSelectedText().isEmpty()) return false;

        backup();
        String source = editor.textField.getText();
        editor.clipboard = editor.textField.getSelectedText();
        editor.textField.setText(cutString(source));
        return true;
    }

    private String cutString(String source) {
        String start = source.substring(0, editor.textField.getSelectionStart());
        String end = source.substring(editor.textField.getSelectionEnd());
        return start + end;
    }
}

package refactoring_guru.command.example.commands;

import java.util.Stack;

public class CommandHistory {
    private Stack<Command> history = new Stack<>();

    public void push(Command c) {
        history.push(c);
    }

    public Command pop() {
        return history.pop();
    }

    public boolean isEmpty() { return history.isEmpty(); }
}

package refactoring_guru.command.example.editor;

import refactoring_guru.command.example.commands.*;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Editor {
    public JTextArea textField;
    public String clipboard;
    private CommandHistory history = new CommandHistory();

    public void init() {
        JFrame frame = new JFrame("Text editor (type & use buttons, Luke!)");
        JPanel content = new JPanel();
        frame.setContentPane(content);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        content.setLayout(new BoxLayout(content, BoxLayout.Y_AXIS));
        textField = new JTextArea();
        textField.setLineWrap(true);
        content.add(textField);
        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.CENTER));
        JButton ctrlC = new JButton("Ctrl+C");
        JButton ctrlX = new JButton("Ctrl+X");
        JButton ctrlV = new JButton("Ctrl+V");
        JButton ctrlZ = new JButton("Ctrl+Z");
        Editor editor = this;
        ctrlC.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                executeCommand(new CopyCommand(editor));
            }
        });
        ctrlX.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                executeCommand(new CutCommand(editor));
            }
        });
        ctrlV.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                executeCommand(new PasteCommand(editor));
            }
        });
        ctrlZ.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                undo();
            }
        });
        buttons.add(ctrlC);
        buttons.add(ctrlX);
        buttons.add(ctrlV);
        buttons.add(ctrlZ);
        content.add(buttons);
        frame.setSize(450, 200);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    private void executeCommand(Command command) {
        if (command.execute()) {
            history.push(command);
        }
    }

    private void undo() {
        if (history.isEmpty()) return;

        Command command = history.pop();
        if (command != null) {
            command.undo();
        }
    }
}

package refactoring_guru.command.example;

import refactoring_guru.command.example.editor.Editor;

public class Demo {
    public static void main(String[] args) {
        Editor editor = new Editor();
        editor.init();
    }
}
```

### csharp

```csharp
using System;

namespace RefactoringGuru.DesignPatterns.Command.Conceptual
{
    // واجهة Command تُعلن طريقة لتنفيذ أمر.
    public interface ICommand
    {
        void Execute();
    }

    // يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
    class SimpleCommand : ICommand
    {
        private string _payload = string.Empty;

        public SimpleCommand(string payload)
        {
            this._payload = payload;
        }

        public void Execute()
        {
            Console.WriteLine($"SimpleCommand: See, I can do simple things like printing ({this._payload})");
        }
    }

    // غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
    class ComplexCommand : ICommand
    {
        private Receiver _receiver;

        // بيانات السياق اللازمة لاستدعاء طرائق المستقبِل.
        private string _a;

        private string _b;

        // يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
        public ComplexCommand(Receiver receiver, string a, string b)
        {
            this._receiver = receiver;
            this._a = a;
            this._b = b;
        }

        // يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
        public void Execute()
        {
            Console.WriteLine("ComplexCommand: Complex stuff should be done by a receiver object.");
            this._receiver.DoSomething(this._a);
            this._receiver.DoSomethingElse(this._b);
        }
    }

    // تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
    class Receiver
    {
        public void DoSomething(string a)
        {
            Console.WriteLine($"Receiver: Working on ({a}.)");
        }

        public void DoSomethingElse(string b)
        {
            Console.WriteLine($"Receiver: Also working on ({b}.)");
        }
    }

    // يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
    class Invoker
    {
        private ICommand _onStart;

        private ICommand _onFinish;

        // تهيئة الأوامر.
        public void SetOnStart(ICommand command)
        {
            this._onStart = command;
        }

        public void SetOnFinish(ICommand command)
        {
            this._onFinish = command;
        }

        // لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
        public void DoSomethingImportant()
        {
            Console.WriteLine("Invoker: Does anybody want something done before I begin?");
            if (this._onStart is ICommand)
            {
                this._onStart.Execute();
            }
            
            Console.WriteLine("Invoker: ...doing something really important...");
            
            Console.WriteLine("Invoker: Does anybody want something done after I finish?");
            if (this._onFinish is ICommand)
            {
                this._onFinish.Execute();
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.
            Invoker invoker = new Invoker();
            invoker.SetOnStart(new SimpleCommand("Say Hi!"));
            Receiver receiver = new Receiver();
            invoker.SetOnFinish(new ComplexCommand(receiver, "Send email", "Save report"));

            invoker.DoSomethingImportant();
        }
    }
}

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object.
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)
```

### cpp

```cpp
/**
 * واجهة Command تُعلن طريقة لتنفيذ أمر.
 */
class Command {
 public:
  virtual ~Command() {
  }
  virtual void Execute() const = 0;
};
/**
 * يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
 */
class SimpleCommand : public Command {
 private:
  std::string pay_load_;

 public:
  explicit SimpleCommand(std::string pay_load) : pay_load_(pay_load) {
  }
  void Execute() const override {
    std::cout << "SimpleCommand: See, I can do simple things like printing (" << this->pay_load_ << ")\n";
  }
};

/**
 * تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
 */
class Receiver {
 public:
  void DoSomething(const std::string &a) {
    std::cout << "Receiver: Working on (" << a << ".)\n";
  }
  void DoSomethingElse(const std::string &b) {
    std::cout << "Receiver: Also working on (" << b << ".)\n";
  }
};

/**
 * غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
 */
class ComplexCommand : public Command {
  /**
   * @var Receiver
   */
 private:
  Receiver *receiver_;
  /**
   * بيانات السياق اللازمة لاستدعاء طرائق المستقبِل.
   */
  std::string a_;
  std::string b_;
  /**
   * يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
   */
 public:
  ComplexCommand(Receiver *receiver, std::string a, std::string b) : receiver_(receiver), a_(a), b_(b) {
  }
  /**
   * يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
   */
  void Execute() const override {
    std::cout << "ComplexCommand: Complex stuff should be done by a receiver object.\n";
    this->receiver_->DoSomething(this->a_);
    this->receiver_->DoSomethingElse(this->b_);
  }
};

/**
 * يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
 */
class Invoker {
  /**
   * @var Command
   */
 private:
  Command *on_start_;
  /**
   * @var Command
   */
  Command *on_finish_;
  /**
   * تهيئة الأوامر.
   */
 public:
  ~Invoker() {
    delete on_start_;
    delete on_finish_;
  }

  void SetOnStart(Command *command) {
    this->on_start_ = command;
  }
  void SetOnFinish(Command *command) {
    this->on_finish_ = command;
  }
  /**
   * لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
   */
  void DoSomethingImportant() {
    std::cout << "Invoker: Does anybody want something done before I begin?\n";
    if (this->on_start_) {
      this->on_start_->Execute();
    }
    std::cout << "Invoker: ...doing something really important...\n";
    std::cout << "Invoker: Does anybody want something done after I finish?\n";
    if (this->on_finish_) {
      this->on_finish_->Execute();
    }
  }
};
/**
 * يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.
 */

int main() {
  Invoker *invoker = new Invoker;
  invoker->SetOnStart(new SimpleCommand("Say Hi!"));
  Receiver *receiver = new Receiver;
  invoker->SetOnFinish(new ComplexCommand(receiver, "Send email", "Save report"));
  invoker->DoSomethingImportant();

  delete invoker;
  delete receiver;

  return 0;
}

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object.
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)
```

### go

```go
package main

type Button struct {
	command Command
}

func (b *Button) press() {
	b.command.execute()
}

package main

type Command interface {
	execute()
}

package main

type OnCommand struct {
	device Device
}

func (c *OnCommand) execute() {
	c.device.on()
}

package main

type OffCommand struct {
	device Device
}

func (c *OffCommand) execute() {
	c.device.off()
}

package main

type Device interface {
	on()
	off()
}

package main

import "fmt"

type Tv struct {
	isRunning bool
}

func (t *Tv) on() {
	t.isRunning = true
	fmt.Println("Turning tv on")
}

func (t *Tv) off() {
	t.isRunning = false
	fmt.Println("Turning tv off")
}

package main

func main() {
	tv := &Tv{}

	onCommand := &OnCommand{
		device: tv,
	}

	offCommand := &OffCommand{
		device: tv,
	}

	onButton := &Button{
		command: onCommand,
	}
	onButton.press()

	offButton := &Button{
		command: offCommand,
	}
	offButton.press()
}

Turning tv on
Turning tv off
```

### php

```php
<?php

namespace RefactoringGuru\Command\Conceptual;

/**
 * واجهة Command تُعلن طريقة لتنفيذ أمر.
 */
interface Command
{
    public function execute(): void;
}

/**
 * يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
 */
class SimpleCommand implements Command
{
    private $payload;

    public function __construct(string $payload)
    {
        $this->payload = $payload;
    }

    public function execute(): void
    {
        echo "SimpleCommand: See, I can do simple things like printing (" . $this->payload . ")\n";
    }
}

/**
 * غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
 */
class ComplexCommand implements Command
{
    /**
     * @var Receiver
     */
    private $receiver;

    /**
     * بيانات السياق اللازمة لاستدعاء طرائق المستقبِل.
     */
    private $a;

    private $b;

    /**
     * يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
     */
    public function __construct(Receiver $receiver, string $a, string $b)
    {
        $this->receiver = $receiver;
        $this->a = $a;
        $this->b = $b;
    }

    /**
     * يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
     */
    public function execute(): void
    {
        echo "ComplexCommand: Complex stuff should be done by a receiver object.\n";
        $this->receiver->doSomething($this->a);
        $this->receiver->doSomethingElse($this->b);
    }
}

/**
 * تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
 */
class Receiver
{
    public function doSomething(string $a): void
    {
        echo "Receiver: Working on (" . $a . ".)\n";
    }

    public function doSomethingElse(string $b): void
    {
        echo "Receiver: Also working on (" . $b . ".)\n";
    }
}

/**
 * يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
 */
class Invoker
{
    /**
     * @var Command
     */
    private $onStart;

    /**
     * @var Command
     */
    private $onFinish;

    /**
     * تهيئة الأوامر.
     */
    public function setOnStart(Command $command): void
    {
        $this->onStart = $command;
    }

    public function setOnFinish(Command $command): void
    {
        $this->onFinish = $command;
    }

    /**
     * لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
     */
    public function doSomethingImportant(): void
    {
        echo "Invoker: Does anybody want something done before I begin?\n";
        if ($this->onStart instanceof Command) {
            $this->onStart->execute();
        }

        echo "Invoker: ...doing something really important...\n";

        echo "Invoker: Does anybody want something done after I finish?\n";
        if ($this->onFinish instanceof Command) {
            $this->onFinish->execute();
        }
    }
}

/**
 * يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.
 */
$invoker = new Invoker();
$invoker->setOnStart(new SimpleCommand("Say Hi!"));
$receiver = new Receiver();
$invoker->setOnFinish(new ComplexCommand($receiver, "Send email", "Save report"));

$invoker->doSomethingImportant();

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object.
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)

<?php

namespace RefactoringGuru\Command\RealWorld;

/**
 * واجهة Command تُعلن طريقة التنفيذ الرئيسية إضافةً إلى عدة طرائق مساعدة لاسترجاع البيانات الوصفية للأمر.
 */
interface Command
{
    public function execute(): void;

    public function getId(): int;

    public function getStatus(): int;
}

/**
 * أمر كشط الويب الأساسي يُعرّف البنية التحتية الأساسية للتنزيل، المشتركة بين جميع أوامر كشط الويب المحددة.
 */
abstract class WebScrapingCommand implements Command
{
    public $id;

    public $status = 0;

    /**
     * @var string URL for scraping.
     */
    public $url;

    public function __construct(string $url)
    {
        $this->url = $url;
    }

    public function getId(): int
    {
        return $this->id;
    }

    public function getStatus(): int
    {
        return $this->status;
    }

    public function getURL(): string
    {
        return $this->url;
    }

    /**
     * بما أن طرائق التنفيذ لجميع أوامر كشط الويب متشابهة جداً، يمكننا تقديم تنفيذ افتراضي والسماح للأصناف الفرعية بتجاوزه عند الحاجة.
     *
     * تنبيه! قد يلاحظ القارئ المُدقّق نمطاً سلوكياً آخر يعمل هنا.
     */
    public function execute(): void
    {
        $html = $this->download();
        $this->parse($html);
        $this->complete();
    }

    public function download(): string
    {
        $html = file_get_contents($this->getURL());
        echo "WebScrapingCommand: Downloaded {$this->url}\n";

        return $html;
    }

    abstract public function parse(string $html): void;

    public function complete(): void
    {
        $this->status = 1;
        Queue::get()->completeCommand($this);
    }
}

/**
 * الأمر المحدد لكشط قائمة أنواع الأفلام.
 */
class IMDBGenresScrapingCommand extends WebScrapingCommand
{
    public function __construct()
    {
        $this->url = "https://www.imdb.com/feature/genre/";
    }

    /**
     * استخراج جميع الأنواع وعناوين البحث الخاصة بها من الصفحة:
     * https://www.imdb.com/feature/genre/
     */
    public function parse($html): void
    {
        preg_match_all("|href=\"(https://www.imdb.com/search/title\?genres=.*?)\"|", $html, $matches);
        echo "IMDBGenresScrapingCommand: Discovered " . count($matches[1]) . " genres.\n";

        foreach ($matches[1] as $genre) {
            Queue::get()->add(new IMDBGenrePageScrapingCommand($genre));
        }
    }
}

/**
 * الأمر المحدد لكشط قائمة الأفلام ضمن نوع معيّن.
 */
class IMDBGenrePageScrapingCommand extends WebScrapingCommand
{
    private $page;

    public function __construct(string $url, int $page = 1)
    {
        parent::__construct($url);
        $this->page = $page;
    }

    public function getURL(): string
    {
        return $this->url . '?page=' . $this->page;
    }

    /**
     * استخراج جميع الأفلام من صفحة كهذه:
     * https://www.imdb.com/search/title?genres=sci-fi&explore=title_type,genres
     */
    public function parse(string $html): void
    {
        preg_match_all("|href=\"(/title/.*?/)\?ref_=adv_li_tt\"|", $html, $matches);
        echo "IMDBGenrePageScrapingCommand: Discovered " . count($matches[1]) . " movies.\n";

        foreach ($matches[1] as $moviePath) {
            $url = "https://www.imdb.com" . $moviePath;
            Queue::get()->add(new IMDBMovieScrapingCommand($url));
        }

        // تحليل عنوان الصفحة التالية.
        if (preg_match("|Next &#187;</a>|", $html)) {
            Queue::get()->add(new IMDBGenrePageScrapingCommand($this->url, $this->page + 1));
        }
    }
}

/**
 * الأمر المحدد لكشط تفاصيل الفيلم.
 */
class IMDBMovieScrapingCommand extends WebScrapingCommand
{
    /**
     * الحصول على معلومات الفيلم من صفحة كهذه:
     * https://www.imdb.com/title/tt4154756/
     */
    public function parse(string $html): void
    {
        if (preg_match("|<h1 itemprop=\"name\" class=\"\">(.*?)</h1>|", $html, $matches)) {
            $title = $matches[1];
        }
        echo "IMDBMovieScrapingCommand: Parsed movie $title.\n";
    }
}

/**
 * يؤدي الصنف Queue دور المُستدعي. فهو يكدّس كائنات الأوامر وينفّذها واحداً تلو الآخر. وإذا أُنهي تنفيذ السكربت فجأةً، يمكن استعادة الطابور وجميع أوامره بسهولة، ولن تحتاج إلى إعادة تنفيذ كل الأوامر المنفَّذة.
 *
 * لاحظ أن هذا تنفيذ بدائي جداً لطابور الأوامر، إذ يخزّن الأوامر في قاعدة بيانات SQLite محلية. وهناك عشرات الحلول القوية للطوابير المتاحة للاستخدام في التطبيقات الحقيقية.
 */
class Queue
{
    private $db;

    public function __construct()
    {
        $this->db = new \SQLite3(
            __DIR__ . '/commands.sqlite',
            SQLITE3_OPEN_CREATE | SQLITE3_OPEN_READWRITE
        );

        $this->db->query('CREATE TABLE IF NOT EXISTS "commands" (
            "id" INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
            "command" TEXT,
            "status" INTEGER
        )');
    }

    public function isEmpty(): bool
    {
        $query = 'SELECT COUNT("id") FROM "commands" WHERE status = 0';

        return $this->db->querySingle($query) === 0;
    }

    public function add(Command $command): void
    {
        $query = 'INSERT INTO commands (command, status) VALUES (:command, :status)';
        $statement = $this->db->prepare($query);
        $statement->bindValue(':command', base64_encode(serialize($command)));
        $statement->bindValue(':status', $command->getStatus());
        $statement->execute();
    }

    public function getCommand(): Command
    {
        $query = 'SELECT * FROM "commands" WHERE "status" = 0 LIMIT 1';
        $record = $this->db->querySingle($query, true);
        $command = unserialize(base64_decode($record["command"]));
        $command->id = $record['id'];

        return $command;
    }

    public function completeCommand(Command $command): void
    {
        $query = 'UPDATE commands SET status = :status WHERE id = :id';
        $statement = $this->db->prepare($query);
        $statement->bindValue(':status', $command->getStatus());
        $statement->bindValue(':id', $command->getId());
        $statement->execute();
    }

    public function work(): void
    {
        while (!$this->isEmpty()) {
            $command = $this->getCommand();
            $command->execute();
        }
    }

    /**
     * لتسهيل الأمر علينا، يكون كائن Queue مفرداً (Singleton).
     */
    public static function get(): Queue
    {
        static $instance;
        if (!$instance) {
            $instance = new Queue();
        }

        return $instance;
    }
}

/**
 * كود العميل.
 */

$queue = Queue::get();

if ($queue->isEmpty()) {
    $queue->add(new IMDBGenresScrapingCommand());
}

$queue->work();

WebScrapingCommand: Downloaded https://www.imdb.com/feature/genre/
IMDBGenresScrapingCommand: Discovered 14 genres.
WebScrapingCommand: Downloaded https://www.imdb.com/search/title?genres=comedy
IMDBGenrePageScrapingCommand: Discovered 50 movies.
WebScrapingCommand: Downloaded https://www.imdb.com/search/title?genres=sci-fi
IMDBGenrePageScrapingCommand: Discovered 50 movies.
WebScrapingCommand: Downloaded https://www.imdb.com/search/title?genres=horror
IMDBGenrePageScrapingCommand: Discovered 50 movies.
WebScrapingCommand: Downloaded https://www.imdb.com/search/title?genres=romance
IMDBGenrePageScrapingCommand: Discovered 50 movies.
...
```

### python

```python
from __future__ import annotations
from abc import ABC, abstractmethod


class Command(ABC):
    """
    واجهة Command تُعلن طريقة لتنفيذ أمر.
    """

    @abstractmethod
    def execute(self) -> None:
        pass


class SimpleCommand(Command):
    """
    يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
    """

    def __init__(self, payload: str) -> None:
        self._payload = payload

    def execute(self) -> None:
        print(f"SimpleCommand: See, I can do simple things like printing"
              f"({self._payload})")


class ComplexCommand(Command):
    """
    غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
    """

    def __init__(self, receiver: Receiver, a: str, b: str) -> None:
        """
        يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
        """

        self._receiver = receiver
        self._a = a
        self._b = b

    def execute(self) -> None:
        """
        يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
        """

        print("ComplexCommand: Complex stuff should be done by a receiver object", end="")
        self._receiver.do_something(self._a)
        self._receiver.do_something_else(self._b)


class Receiver:
    """
    تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
    """

    def do_something(self, a: str) -> None:
        print(f"\nReceiver: Working on ({a}.)", end="")

    def do_something_else(self, b: str) -> None:
        print(f"\nReceiver: Also working on ({b}.)", end="")


class Invoker:
    """
    يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
    """

    _on_start = None
    _on_finish = None

    """
    تهيئة الأوامر.
    """

    def set_on_start(self, command: Command):
        self._on_start = command

    def set_on_finish(self, command: Command):
        self._on_finish = command

    def do_something_important(self) -> None:
        """
        لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
        """

        print("Invoker: Does anybody want something done before I begin?")
        if isinstance(self._on_start, Command):
            self._on_start.execute()

        print("Invoker: ...doing something really important...")

        print("Invoker: Does anybody want something done after I finish?")
        if isinstance(self._on_finish, Command):
            self._on_finish.execute()


if __name__ == "__main__":
    """
    يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.
    """

    invoker = Invoker()
    invoker.set_on_start(SimpleCommand("Say Hi!"))
    receiver = Receiver()
    invoker.set_on_finish(ComplexCommand(
        receiver, "Send email", "Save report"))

    invoker.do_something_important()

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)
```

### ruby

```ruby
# واجهة Command تُعلن طريقة لتنفيذ أمر.
class Command
  # @abstract
  def execute
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

# يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
class SimpleCommand < Command
  # @param [String] payload
  def initialize(payload)
    @payload = payload
  end

  def execute
    puts "SimpleCommand: See, I can do simple things like printing (#{@payload})"
  end
end

# غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
class ComplexCommand < Command
  # يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
  def initialize(receiver, a, b)
    @receiver = receiver
    @a = a
    @b = b
  end

  # يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
  def execute
    print 'ComplexCommand: Complex stuff should be done by a receiver object'
    @receiver.do_something(@a)
    @receiver.do_something_else(@b)
  end
end

# تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
class Receiver
  # @param [String] a
  def do_something(a)
    print "\nReceiver: Working on (#{a}.)"
  end

  # @param [String] b
  def do_something_else(b)
    print "\nReceiver: Also working on (#{b}.)"
  end
end

# يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
class Invoker
  # تهيئة الأوامر.

  # @param [Command] command
  def on_start=(command)
    @on_start = command
  end

  # @param [Command] command
  def on_finish=(command)
    @on_finish = command
  end

  # لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
  def do_something_important
    puts 'Invoker: Does anybody want something done before I begin?'
    @on_start.execute if @on_start.is_a? Command

    puts 'Invoker: ...doing something really important...'

    puts 'Invoker: Does anybody want something done after I finish?'
    @on_finish.execute if @on_finish.is_a? Command
  end
end

# يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.
invoker = Invoker.new
invoker.on_start = SimpleCommand.new('Say Hi!')
receiver = Receiver.new
invoker.on_finish = ComplexCommand.new(receiver, 'Send email', 'Save report')

invoker.do_something_important

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)
```

### rust

```rust
mod copy;
mod cut;
mod paste;

pub use copy::CopyCommand;
pub use cut::CutCommand;
pub use paste::PasteCommand;

/// تُعلن طريقة لتنفيذ أمر (والتراجع عنه).
///
/// يستقبل كل أمر سياق التطبيق للوصول إلى المكوّنات المرئية (مثل منطقة التحرير) والحافظة.
pub trait Command {
    fn execute(&mut self, app: &mut cursive::Cursive) -> bool;
    fn undo(&mut self, app: &mut cursive::Cursive);
}

use cursive::{views::EditView, Cursive};

use super::Command;
use crate::AppContext;

#[derive(Default)]
pub struct CopyCommand;

impl Command for CopyCommand {
    fn execute(&mut self, app: &mut Cursive) -> bool {
        let editor = app.find_name::<EditView>("Editor").unwrap();
        let mut context = app.take_user_data::<AppContext>().unwrap();

        context.clipboard = editor.get_content().to_string();

        app.set_user_data(context);
        false
    }

    fn undo(&mut self, _: &mut Cursive) {}
}

use cursive::{views::EditView, Cursive};

use super::Command;
use crate::AppContext;

#[derive(Default)]
pub struct CutCommand {
    backup: String,
}

impl Command for CutCommand {
    fn execute(&mut self, app: &mut Cursive) -> bool {
        let mut editor = app.find_name::<EditView>("Editor").unwrap();

        app.with_user_data(|context: &mut AppContext| {
            self.backup = editor.get_content().to_string();
            context.clipboard = self.backup.clone();
            editor.set_content("".to_string());
        });

        true
    }

    fn undo(&mut self, app: &mut Cursive) {
        let mut editor = app.find_name::<EditView>("Editor").unwrap();
        editor.set_content(&self.backup);
    }
}

use cursive::{views::EditView, Cursive};

use super::Command;
use crate::AppContext;

#[derive(Default)]
pub struct PasteCommand {
    backup: String,
}

impl Command for PasteCommand {
    fn execute(&mut self, app: &mut Cursive) -> bool {
        let mut editor = app.find_name::<EditView>("Editor").unwrap();

        app.with_user_data(|context: &mut AppContext| {
            self.backup = editor.get_content().to_string();
            editor.set_content(context.clipboard.clone());
        });

        true
    }

    fn undo(&mut self, app: &mut Cursive) {
        let mut editor = app.find_name::<EditView>("Editor").unwrap();
        editor.set_content(&self.backup);
    }
}

mod command;

use cursive::{
    traits::Nameable,
    views::{Dialog, EditView},
    Cursive,
};

use command::{Command, CopyCommand, CutCommand, PasteCommand};

/// سياق تطبيق يُمرَّر إلى ردود نداء المكوّنات المرئية. يحتوي على حافظة وسجلّ بالأوامر القابلة للتراجع عنها.
#[derive(Default)]
struct AppContext {
    clipboard: String,
    history: Vec<Box<dyn Command>>,
}

fn main() {
    let mut app = cursive::default();

    app.set_user_data(AppContext::default());
    app.add_layer(
        Dialog::around(EditView::default().with_name("Editor"))
            .title("Type and use buttons")
            .button("Copy", |s| execute(s, CopyCommand))
            .button("Cut", |s| execute(s, CutCommand::default()))
            .button("Paste", |s| execute(s, PasteCommand::default()))
            .button("Undo", undo)
            .button("Quit", |s| s.quit()),
    );

    app.run();
}

/// ينفّذ أمراً ثم يدفعه إلى مصفوفة السجلّ.
fn execute(app: &mut Cursive, mut command: impl Command + 'static) {
    if command.execute(app) {
        app.with_user_data(|context: &mut AppContext| {
            context.history.push(Box::new(command));
        });
    }
}

/// يسحب آخر أمر وينفّذ عملية تراجع.
fn undo(app: &mut Cursive) {
    let mut context = app.take_user_data::<AppContext>().unwrap();
    if let Some(mut command) = context.history.pop() {
        command.undo(app)
    }
    app.set_user_data(context);
}
```

### swift

```swift
import XCTest

/// واجهة Command تُعلن طريقة لتنفيذ أمر.
protocol Command {

    func execute()
}

/// يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
class SimpleCommand: Command {

    private var payload: String

    init(_ payload: String) {
        self.payload = payload
    }

    func execute() {
        print("SimpleCommand: See, I can do simple things like printing (" + payload + ")")
    }
}

/// غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
class ComplexCommand: Command {

    private var receiver: Receiver

    /// بيانات السياق اللازمة لاستدعاء طرائق المستقبِل.
    private var a: String
    private var b: String

    /// يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
    init(_ receiver: Receiver, _ a: String, _ b: String) {
        self.receiver = receiver
        self.a = a
        self.b = b
    }

    /// يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
    func execute() {
        print("ComplexCommand: Complex stuff should be done by a receiver object.\n")
        receiver.doSomething(a)
        receiver.doSomethingElse(b)
    }
}

/// تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
class Receiver {

    func doSomething(_ a: String) {
        print("Receiver: Working on (" + a + ")\n")
    }

    func doSomethingElse(_ b: String) {
        print("Receiver: Also working on (" + b + ")\n")
    }
}

/// يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
class Invoker {

    private var onStart: Command?

    private var onFinish: Command?

    /// تهيئة الأوامر.
    func setOnStart(_ command: Command) {
        onStart = command
    }

    func setOnFinish(_ command: Command) {
        onFinish = command
    }

    /// لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
    func doSomethingImportant() {

        print("Invoker: Does anybody want something done before I begin?")

        onStart?.execute()

        print("Invoker: ...doing something really important...")
        print("Invoker: Does anybody want something done after I finish?")

        onFinish?.execute()
    }
}

/// لنرَ كيف يتجمّع كل ذلك معاً.
class CommandConceptual: XCTestCase {

    func test() {
        /// يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.

        let invoker = Invoker()
        invoker.setOnStart(SimpleCommand("Say Hi!"))

        let receiver = Receiver()
        invoker.setOnFinish(ComplexCommand(receiver, "Send email", "Save report"))
        invoker.doSomethingImportant()
    }
}

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object.

Receiver: Working on (Send email)

Receiver: Also working on (Save report)

import Foundation
import XCTest


class DelayedOperation: Operation, @unchecked Sendable {

    private var delay: TimeInterval

    init(_ delay: TimeInterval = 0) {
        self.delay = delay
    }

    override var isExecuting : Bool {
        get { return _executing }
        set {
            willChangeValue(forKey: "isExecuting")
            _executing = newValue
            didChangeValue(forKey: "isExecuting")
        }
    }
    private var _executing : Bool = false

    override var isFinished : Bool {
        get { return _finished }
        set {
            willChangeValue(forKey: "isFinished")
            _finished = newValue
            didChangeValue(forKey: "isFinished")
        }
    }
    private var _finished : Bool = false

    override func start() {

        guard delay > 0 else {
            _start()
            return
        }

        let deadline = DispatchTime.now() + delay
        DispatchQueue(label: "").asyncAfter(deadline: deadline) {
            self._start()
        }
    }

    private func _start() {

        guard !self.isCancelled else {
            print("\(self): operation is canceled")
            self.isFinished = true
            return
        }

        self.isExecuting = true
        self.main()
        self.isExecuting = false
        self.isFinished = true
    }
}

class WindowOperation: DelayedOperation, @unchecked Sendable {

    override func main() {
        print("\(self): Windows are closed via HomeKit.")
    }

    override var description: String { return "WindowOperation" }
}

class DoorOperation: DelayedOperation, @unchecked Sendable {

    override func main() {
        print("\(self): Doors are closed via HomeKit.")
    }

    override var description: String { return "DoorOperation" }
}

class TaxiOperation: DelayedOperation, @unchecked Sendable {

    override func main() {
        print("\(self): Taxi is ordered via Uber")
    }

    override var description: String { return "TaxiOperation" }
}



class CommandRealWorld: XCTestCase {

    func testCommandRealWorld() {
        prepareTestEnvironment {

            let siri = SiriShortcuts.shared

            print("User: Hey Siri, I am leaving my home")
            siri.perform(.leaveHome)

            print("User: Hey Siri, I am leaving my work in 3 minutes")
            siri.perform(.leaveWork, delay: 3) /// للتبسيط، نستخدم الثواني

            print("User: Hey Siri, I am still working")
            siri.cancel(.leaveWork)
        }
    }
}

extension CommandRealWorld {

    struct ExecutionTime {
        static let max: TimeInterval = 5
        static let waiting: TimeInterval = 4
    }

    func prepareTestEnvironment(_ execution: () -> ()) {

        /// هذه الطريقة تُخبر Xcode بالانتظار للعمليات غير المتزامنة، وإلا فإن الاختبار الرئيسي ينتهي فوراً.

        let expectation = self.expectation(description: "Expectation for async operations")

        let deadline = DispatchTime.now() + ExecutionTime.waiting
        DispatchQueue.main.asyncAfter(deadline: deadline) { expectation.fulfill() }

        execution()

        wait(for: [expectation], timeout: ExecutionTime.max)
    }
}

class SiriShortcuts {

    static let shared = SiriShortcuts()
    private lazy var queue = OperationQueue()

    private init() {}

    enum Action: String {
        case leaveHome
        case leaveWork
    }

    func perform(_ action: Action, delay: TimeInterval = 0) {
        print("Siri: performing \(action)-action\n")
        switch action {
        case .leaveHome:
            add(operation: WindowOperation(delay))
            add(operation: DoorOperation(delay))
        case .leaveWork:
            add(operation: TaxiOperation(delay))
        }
    }

    func cancel(_ action: Action) {
        print("Siri: canceling \(action)-action\n")
        switch action {
        case .leaveHome:
            cancelOperation(with: WindowOperation.self)
            cancelOperation(with: DoorOperation.self)
        case .leaveWork:
            cancelOperation(with: TaxiOperation.self)
        }
    }

    private func cancelOperation(with operationType: Operation.Type) {
        queue.operations.filter { operation in
            return type(of: operation) == operationType
        }.forEach({ $0.cancel() })
    }

    private func add(operation: Operation) {
        queue.addOperation(operation)
    }
}

User: Hey Siri, I am leaving my home
Siri: performing leaveHome-action

User: Hey Siri, I am leaving my work in 3 minutes
Siri: performing leaveWork-action

User: Hey Siri, I am still working
Siri: canceling leaveWork-action

DoorOperation: Doors are closed via HomeKit.
WindowOperation: Windows are closed via HomeKit.
TaxiOperation: operation is canceled
```

### typescript

```typescript
/**
 * واجهة Command تُعلن طريقة لتنفيذ أمر.
 */
interface Command {
    execute(): void;
}

/**
 * يمكن لبعض الأوامر تنفيذ عمليات بسيطة بنفسها.
 */
class SimpleCommand implements Command {
    private payload: string;

    constructor(payload: string) {
        this.payload = payload;
    }

    public execute(): void {
        console.log(`SimpleCommand: See, I can do simple things like printing (${this.payload})`);
    }
}

/**
 * غير أن بعض الأوامر يمكنها تفويض عمليات أكثر تعقيداً إلى كائنات أخرى تُسمى «المستقبِلات» (receivers).
 */
class ComplexCommand implements Command {
    private receiver: Receiver;

    /**
     * بيانات السياق اللازمة لاستدعاء طرائق المستقبِل.
     */
    private a: string;

    private b: string;

    /**
     * يمكن للأوامر المعقدة أن تستقبل كائن مستقبِل واحداً أو أكثر مع أي بيانات سياق عبر الباني (constructor).
     */
    constructor(receiver: Receiver, a: string, b: string) {
        this.receiver = receiver;
        this.a = a;
        this.b = b;
    }

    /**
     * يمكن للأوامر أن تفوّض العمل إلى أي طريقة من طرائق المستقبِل.
     */
    public execute(): void {
        console.log('ComplexCommand: Complex stuff should be done by a receiver object.');
        this.receiver.doSomething(this.a);
        this.receiver.doSomethingElse(this.b);
    }
}

/**
 * تحتوي أصناف المستقبِل (Receiver) على منطق عمل مهم. وهي تعرف كيفية تنفيذ جميع أنواع العمليات المرتبطة بتلبية طلب ما. وفي الواقع، يمكن لأي صنف أن يؤدي دور المستقبِل.
 */
class Receiver {
    public doSomething(a: string): void {
        console.log(`Receiver: Working on (${a}.)`);
    }

    public doSomethingElse(b: string): void {
        console.log(`Receiver: Also working on (${b}.)`);
    }
}

/**
 * يرتبط المُستدعي (Invoker) بأمر واحد أو عدة أوامر، وهو يرسل طلباً إلى الأمر.
 */
class Invoker {
    private onStart: Command;

    private onFinish: Command;

    /**
     * تهيئة الأوامر.
     */
    public setOnStart(command: Command): void {
        this.onStart = command;
    }

    public setOnFinish(command: Command): void {
        this.onFinish = command;
    }

    /**
     * لا يعتمد المُستدعي على أصناف الأوامر أو المستقبِلات المحددة، بل يمرّر الطلب إلى المستقبِل بشكل غير مباشر عبر تنفيذ أمر.
     */
    public doSomethingImportant(): void {
        console.log('Invoker: Does anybody want something done before I begin?');
        if (this.isCommand(this.onStart)) {
            this.onStart.execute();
        }

        console.log('Invoker: ...doing something really important...');

        console.log('Invoker: Does anybody want something done after I finish?');
        if (this.isCommand(this.onFinish)) {
            this.onFinish.execute();
        }
    }

    private isCommand(object): object is Command {
        return object.execute !== undefined;
    }
}

/**
 * يمكن لكود العميل أن يزوّد المُستدعي بأي أوامر.
 */
const invoker = new Invoker();
invoker.setOnStart(new SimpleCommand('Say Hi!'));
const receiver = new Receiver();
invoker.setOnFinish(new ComplexCommand(receiver, 'Send email', 'Save report'));

invoker.doSomethingImportant();

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object.
Receiver: Working on (Send email.)
Receiver: Also working on (Save report.)
```