שדות מיוצאים לעומת שדות לא מיוצאים

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

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

שדות שמתחילים באות גדולה הם מיוצאים: נגישים מכל חבילה. שדות שמתחילים באות קטנה הם לא מיוצאים: נגישים רק מתוך אותה חבילה:

// בחבילה "user"
type User struct {
    Name     string  // מיוצא - נגיש מכל מקום
    Email    string  // מיוצא - נגיש מכל מקום
    password string  // לא מיוצא - נגיש רק בחבילה "user"
    age      int     // לא מיוצא - נגיש רק בחבילה "user"
}

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

// בחבילה "main"
import "user"

func main() {
    u := user.User{
        Name:  "Alice",      // עובד
        Email: "a@mail.com", // עובד
        // password: "secret", // שגיאת קומפילציה: שדה לא מוכר
    }
    
    fmt.Println(u.Name)     // עובד
    // fmt.Println(u.password) // שגיאת קומפילציה: אי אפשר לגשת לשדה שלא יוצא
}

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

אתגר

קל

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

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

account.go: צרו מבנה BankAccount בחבילה main, שמייצג חשבון בנק אמיתי עם הגנה מתאימה על הנתונים:
- HolderName (מיוצא) - שם בעל החשבון, בטוח להצגה בפומבי
- AccountType (מיוצא) - סוג החשבון (למשל, "Savings", "Checking")
- balance (לא מיוצא) - היתרה בפועל, שעליה להיות מוגנת
- pin (לא מיוצא) - קוד ה-PIN של החשבון, נתון רגיש במיוחד
הוסיפו פונקציית בנאי NewBankAccount שמקבלת שם בעל חשבון, סוג חשבון, יתרה ראשונית וקוד PIN, ואז מחזירה מצביע ל-BankAccount חדש. הוסיפו גם מתודה GetPublicInfo() string שמחזירה את התבנית: Account: [HolderName] ([AccountType])
main.go: קראו את פרטי החשבון מהקלט, צרו BankAccount באמצעות הבנאי, והדגימו את הכימוס. הדפיסו את המידע הציבורי באמצעות המתודה, ואז גשו ישירות לכל אחד מהשדות המיוצאים והדפיסו אותם בשורות נפרדות. השדות הלא מיוצאים (balance ו-pin) מוגנים. אפשר להגדיר אותם רק באמצעות הבנאי.

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

שורה 1: שם בעל החשבון
שורה 2: סוג החשבון
שורה 3: יתרה ראשונית (כמספר עשרוני)
שורה 4: קוד PIN

לדוגמה, עבור Alice Johnson, Savings, 5000.50 ו-1234, הפלט שלכם אמור להיות:

Account: Alice Johnson (Savings)
Holder: Alice Johnson
Type: Savings

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

נסו בעצמכם

package main

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

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

	// קרא את שם בעל החשבון
	holderName, _ := reader.ReadString('\n')
	holderName = strings.TrimSpace(holderName)

	// קרא את סוג החשבון
	accountType, _ := reader.ReadString('\n')
	accountType = strings.TrimSpace(accountType)

	// קרא את היתרה ההתחלתית
	balanceStr, _ := reader.ReadString('\n')
	balanceStr = strings.TrimSpace(balanceStr)
	balance, _ := strconv.ParseFloat(balanceStr, 64)

	// קרא את ה-PIN
	pinStr, _ := reader.ReadString('\n')
	pin := strings.TrimSpace(pinStr)

	// TODO: צור BankAccount חדש באמצעות הבנאי
	// account := NewBankAccount(...)

	// TODO: הדפס את המידע הציבורי באמצעות המתודה GetPublicInfo()

	// TODO: הדפס את שם בעל החשבון באמצעות גישה ישירה לשדה המיוצא
	// fmt.Println("Holder:", ...)

	// TODO: הדפס את סוג החשבון באמצעות גישה ישירה לשדה המיוצא
	// fmt.Println("Type:", ...)

	// הערה: balance ו-pin אינם מיוצאים — אי אפשר לגשת אליהם ישירות כאן
	// הם מאוכמסלים באופן בטוח בתוך ה-struct

	_ = balance // הסירו את השורה הזו כשאתם משתמשים ב-balance
	_ = pin     // הסירו את השורה הזו כשאתם משתמשים ב-pin
}