תבנית הפקודה

חלק מהיחידה תכנות מונחה עצמים במסלול ה-GO של Coddy. שיעור 91 מתוך 107.

תבנית הפקודה עוטפת בקשה כאובייקט, ומאפשרת לך להגדיר פעולות באמצעות פרמטרים, להכניס אותן לתור או לתמוך בפונקציונליות של ביטול. בעוד שתבנית Strategy עוטפת אלגוריתמים, תבנית Command עוטפת פעולות שלמות יחד עם הפרמטרים שלהן.

ב-Go, אנחנו מגדירים ממשק Command עם מתודה Execute, ואז יוצרים פקודות קונקרטיות שמכילות את כל המידע הדרוש לביצוע פעולה:

type Command interface {
    Execute() string
}

type Light struct {
    IsOn bool
}

type TurnOnCommand struct {
    light *Light
}

func (c *TurnOnCommand) Execute() string {
    c.light.IsOn = true
    return "Light turned on"
}

type TurnOffCommand struct {
    light *Light
}

func (c *TurnOffCommand) Execute() string {
    c.light.IsOn = false
    return "Light turned off"
}

מפעיל מאחסן פקודות ומבצע אותן בלי לדעת מה הן עושות:

type RemoteControl struct {
    command Command
}

func (r *RemoteControl) SetCommand(c Command) {
    r.command = c
}

func (r *RemoteControl) PressButton() string {
    return r.command.Execute()
}

היוזם מנותק לחלוטין מהמקבל (האור):

light := &Light{}
remote := &RemoteControl{}

remote.SetCommand(&TurnOnCommand{light: light})
fmt.Println(remote.PressButton())  // האור נדלק

remote.SetCommand(&TurnOffCommand{light: light})
fmt.Println(remote.PressButton())  // האור כבה

תבנית Command אידיאלית למימוש מערכות ביטול/ביצוע מחדש, תורי משימות או הקלטת פקודות מאקרו, כשצריך לאחסן, לדחות או להפעיל מחדש פעולות.

אתגר

קל

בואו נבנה עורך טקסט עם יכולת ביטול באמצעות תבנית Command! תיצרו פקודות שעוטפות פעולות טקסט, ומאפשרות לעורך לבצע פעולות ולבטל אותן: זהו מקרה שימוש קלאסי שמדגים מדוע פקודות הן כלי רב־עוצמה כל כך.

תארגנו את הקוד בשלושה קבצים:

command.go: הגדירו את ממשק הפקודה ואת הפקודות הקונקרטיות לעריכת טקסט.
צרו ממשק Command עם שתי מתודות: Execute() string לביצוע הפעולה ו-Undo() string לביטולה.

ממשו שני סוגי פקודות שפועלים על *TextEditor:
- InsertCommand: מחזיקה מצביע לעורך ואת הטקסט להוספה. Execute מוסיפה את הטקסט לתוכן העורך ומחזירה Inserted: [text]. Undo מסירה את הטקסט הזה מהסוף ומחזירה Undone insert: [text]
- DeleteCommand: מחזיקה מצביע לעורך ומספר התווים להסרה מהסוף. Execute מסירה את התווים האלה (ושומרת אותם לצורך ביטול) ומחזירה Deleted: [removed text]. Undo משחזרת אותם ומחזירה Undone delete: [restored text]
editor.go: צרו את עורך הטקסט שלכם (המקבל) ואת המפעיל שמנהל את היסטוריית הפקודות.
בנו מבנה TextEditor עם שדה Content מסוג מחרוזת ועם מתודות ל-Append(text string) ול-DeleteLast(count int) string (מחזירה את הטקסט שנמחק).

בנו מבנה EditorInvoker שמחזיק פרוסה של הפקודות שבוצעו, כהיסטוריה. הוסיפו את המתודות הבאות:
- ExecuteCommand(cmd Command) string: מבצעת את הפקודה, מוסיפה אותה להיסטוריה ומחזירה את התוצאה
- UndoLast() string: מסירה את הפקודה האחרונה מההיסטוריה, קוראת למתודת Undo שלה ומחזירה את התוצאה. אם ההיסטוריה ריקה, החזירו Nothing to undo
main.go: הדגימו את מערכת הפקודות שלכם באמצעות סדרת פעולות.
קראו את מספר הפעולות. עבור כל פעולה, קראו את סוג הפעולה (insert, delete או undo). עבור insert, קראו גם את הטקסט להוספה. עבור delete, קראו את מספר התווים. בצעו כל פעולה דרך המפעיל שלכם והדפיסו את התוצאה. לאחר כל הפעולות, הדפיסו את התוכן הסופי של העורך בפורמט Final: [content].

הקלטים הבאים יינתנו:

שורה 1: מספר הפעולות
עבור כל פעולה: סוג הפעולה, ולאחר מכן נתונים נוספים אם נדרשים (טקסט עבור insert, מספר עבור delete)

לדוגמה, עבור הקלט:

5
insert
Hello
insert
 World
delete
3
undo
undo

הפלט שלכם צריך להיות:

Inserted: Hello
Inserted:  World
Deleted: rld
Undone delete: rld
Undone insert:  World
Final: Hello

ועבור הקלט:

4
insert
Go
insert
Lang
undo
insert
!

הפלט שלכם צריך להיות:

Inserted: Go
Inserted: Lang
Undone insert: Lang
Inserted: !
Final: Go!

ועבור הקלט:

2
undo
insert
Test

הפלט שלכם צריך להיות:

Nothing to undo
Inserted: Test
Final: Test

שימו לב שכל פקודה עוטפת את כל הדרוש לביצוע הפעולה שלה וגם לביטולה. המפעיל לא יודע מה הפקודות עושות. הוא רק מבצע אותן ומנהל היסטוריה כדי לאפשר ביטול!

נסו בעצמכם

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// קרא את מספר הפעולות
	line, _ := reader.ReadString('\n')
	numOps, _ := strconv.Atoi(strings.TrimSpace(line))
	
	// צור את העורך ואת מפעיל הפקודות
	editor := &TextEditor{}
	invoker := &EditorInvoker{}
	
	for i := 0; i < numOps; i++ {
		// קרא את סוג הפעולה
		opLine, _ := reader.ReadString('\n')
		opType := strings.TrimSpace(opLine)
		
		var result string
		
		switch opType {
		case "insert":
			// קרא את הטקסט להוספה
			textLine, _ := reader.ReadString('\n')
			text := strings.TrimSuffix(textLine, "\n")
			
			// TODO: צור InsertCommand והפעל אותו באמצעות מפעיל הפקודות
			_ = text
			_ = editor
			
		case "delete":
			// קרא את מספר התווים למחיקה
			countLine, _ := reader.ReadString('\n')
			count, _ := strconv.Atoi(strings.TrimSpace(countLine))
			
			// TODO: צור DeleteCommand והפעל אותו באמצעות מפעיל הפקודות
			_ = count
			
		case "undo":
			// TODO: קרא ל-UndoLast של מפעיל הפקודות
			
		}
		
		fmt.Println(result)
	}
	
	// הדפס את התוכן הסופי
	fmt.Printf("Final: %s\n", editor.Content)
}