כימוס ברמת החבילה

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

בעוד שהשיעור הקודם עסק בנראות ברמת השדה, הכימוס ב-Go פועל למעשה ברמת החבילה. כל מה שנמצא באותה חבילה, ללא קשר לקובץ שבו הוא נמצא, יכול לגשת לשדות ולפונקציות שאינם מיוצאים.

נבחן חבילה עם כמה קבצים:

// account/account.go
package account

type Account struct {
    balance int  // לא מיוצא
}

func (a *Account) Deposit(amount int) {
    a.balance += amount
}

// account/helper.go
package account

func ResetAccount(a *Account) {
    a.balance = 0  // עובד - אותה חבילה
}

שני הקבצים שייכים לחבילה account, ולכן helper.go יכול לגשת ישירות לשדה הלא מיוצא balance. הדבר נעשה בכוונה. כך אפשר לפצל את הלוגיקה של החבילה בין קבצים, תוך שמירה על גישה פנימית.

עם זאת, קוד מחוץ לחבילה אינו יכול לגשת לחברים שלא יוצאו:

// main.go
package main

import "account"

func main() {
    acc := &account.Account{}
    acc.Deposit(100)        // עובד - מתודה מיוצאת
    // acc.balance = 50     // שגיאה - שדה שאינו מיוצא
    // account.ResetAccount // היה עובד אילו ResetAccount הייתה מיוצאת
}

גבול ברמת החבילה הוא מנגנון הכימוס העיקרי של Go. מתכננים חבילות כיחידות מלוכדות, שבהן קוד פנימי משתף פעולה בחופשיות, בעוד שקוד חיצוני מתקשר רק דרך ה-API המיוצא. חשבו על כל חבילה כעל מודול עצמאי עם ממשק ציבורי ברור.

אתגר

קל

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

תיצרו שלושה קבצים שפועלים יחד בחבילה main:

product.go: הגדירו מבנה Product עם שדה מיוצא Name ושדה לא מיוצא quantity (מסוג int). הוסיפו מתודה מיוצאת Info() string שמחזירה את התבנית: [Name]: [quantity] in stock
inventory.go: צרו פונקציות עזר שעובדות עם מוצרים באמצעות גישה ישירה לשדה הלא מיוצא quantity (הדבר אפשרי משום שהן נמצאות באותה חבילה). ממשו:
- Restock(p *Product, amount int) - מוסיפה את הכמות לכמות של המוצר
- Sell(p *Product, amount int) bool - מפחיתה את הכמות מ-quantity אם יש מספיק מלאי, ומחזירה true אם הפעולה הצליחה או false אם אין מספיק מלאי
- NewProduct(name string, initialQty int) *Product - פונקציית יצירה שיוצרת מוצר עם השם והכמות ההתחלתית שסופקו
main.go: קראו את פרטי המוצר מהקלט, צרו מוצר באמצעות פונקציית היצירה, בצעו פעולות על המלאי והציגו את התוצאות. אחרי כל פעולה, הדפיסו את פרטי המוצר כדי להציג את מצבו המעודכן.

הקלטים הבאים יסופקו:

שורה 1: שם המוצר
שורה 2: כמות התחלתית (מספר שלם)
שורה 3: כמות למילוי המלאי (מספר שלם)
שורה 4: כמות למכירה (מספר שלם)

לאחר יצירת המוצר, הדפיסו את פרטיו ההתחלתיים. לאחר מכן מלאו את המלאי והדפיסו שוב את הפרטים. לבסוף, נסו למכור והדפיסו את הפרטים המעודכנים (אם הפעולה הצליחה) או את Sale failed: insufficient stock (אם אין מספיק כמות).

לדוגמה, עבור Laptop, 10, 5 ו-8, הפלט שלכם צריך להיות:

Laptop: 10 in stock
Laptop: 15 in stock
Laptop: 7 in stock

ועבור Phone, 3, 2 ו-10, הפלט שלכם צריך להיות:

Phone: 3 in stock
Phone: 5 in stock
Sale failed: insufficient stock

התובנה המרכזית כאן היא ש-inventory.go יכול לקרוא ולשנות ישירות את השדה הלא מיוצא quantity, משום שהוא נמצא באותה חבילה כמו product.go. זוהי כמוסה ברמת החבילה בפעולה: שיתוף פעולה פנימי מתאפשר בחופשיות, ובו בזמן הנתונים מוגנים מפני חבילות חיצוניות.

נסו בעצמכם

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	// קרא את שם המוצר
	name, _ := reader.ReadString('\n')
	name = strings.TrimSpace(name)

	// קרא את הכמות ההתחלתית
	initialQtyStr, _ := reader.ReadString('\n')
	initialQty, _ := strconv.Atoi(strings.TrimSpace(initialQtyStr))

	// קרא את כמות המלאי להוספה
	restockStr, _ := reader.ReadString('\n')
	restockAmount, _ := strconv.Atoi(strings.TrimSpace(restockStr))

	// קרא את הכמות למכירה
	sellStr, _ := reader.ReadString('\n')
	sellAmount, _ := strconv.Atoi(strings.TrimSpace(sellStr))

	// TODO: צור מוצר חדש באמצעות הבנאי NewProduct

	// TODO: הדפס את פרטי המוצר ההתחלתיים

	// TODO: הוסף מלאי למוצר והדפס את פרטיו

	// TODO: נסה למכור והדפס את התוצאה
	// אם המכירה מצליחה, הדפס את הפרטים המעודכנים
	// אם המכירה נכשלת, הדפס "Sale failed: insufficient stock"

	fmt.Println() // החלף בפלט הרצוי
}