الأساليب

الأساليب — Methods

في Go لا توجد كلاسات (Classes) كما في Java أو Python، لكن هناك بديل أنيق وقوي: الأساليب (Methods). الأسلوب هو ببساطة دالة مرتبطة بنوع معين. هذا يعني أنك تستطيع إضافة سلوك لأي نوع تُعرّفه — سواء كان struct أو حتى نوع بسيط مثل int.

تعريف أسلوب بسيط

الفرق بين الدالة العادية والأسلوب هو وجود مُستقبِل (Receiver) بين كلمة func واسم الدالة:

// دالة عادية — Regular function
func Area(width, height float64) float64 { ... }

// أسلوب على نوع — Method on a type
func (r Rectangle) Area() float64 { ... }

المُستقبِل (r Rectangle) يربط هذا الأسلوب بالنوع Rectangle. الآن يمكنك استدعاؤه عبر rect.Area().

مثال عملي

main.go

package main

import "fmt"

// تعريف نوع المستطيل — Define Rectangle type
type Rectangle struct {
    Width  float64
    Height float64
}

// أسلوب حساب المساحة — Area method
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// أسلوب حساب المحيط — Perimeter method
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// أسلوب الوصف — Description method
func (r Rectangle) String() string {
    return fmt.Sprintf("مستطيل %.1f×%.1f", r.Width, r.Height)
}

func main() {
    rect := Rectangle{Width: 5, Height: 3}

    fmt.Println(rect.String())
    fmt.Printf("المساحة: %.1f\n", rect.Area())
    fmt.Printf("المحيط: %.1f\n", rect.Perimeter())
}

Output:

مستقبل القيمة vs مستقبل المؤشر — Value vs Pointer Receiver

هذا من أهم المفاهيم التي يجب أن تفهمها جيداً. عندما تُعرّف أسلوباً، المُستقبِل يمكن أن يكون:

مستقبل قيمة (r Rectangle) — يعمل على نسخة من القيمة
مستقبل مؤشر (r *Rectangle) — يعمل على القيمة الأصلية نفسها

القاعدة الذهبية:

إذا الأسلوب يُعدّل الكائن ← استخدم مستقبل مؤشر *T
إذا الأسلوب يقرأ فقط ← مستقبل قيمة T يكفي
إذا الـ struct كبير ← مستقبل مؤشر أفضل (تجنب النسخ)
في الممارسة: إذا أسلوب واحد يحتاج مؤشر، اجعل كل أساليب النوع بمؤشر للاتساق

main.go

package main

import "fmt"

// حساب بنكي — Bank account
type Account struct {
    Owner   string
    Balance float64
}

// إيداع — يُعدّل الرصيد لذلك نستخدم مستقبل مؤشر
// Deposit — modifies balance, needs pointer receiver
func (a *Account) Deposit(amount float64) {
    a.Balance += amount
    fmt.Printf("إيداع %.2f — الرصيد الجديد: %.2f\n", amount, a.Balance)
}

// سحب — يُعدّل الرصيد أيضاً
// Withdraw — also modifies balance
func (a *Account) Withdraw(amount float64) error {
    if amount > a.Balance {
        return fmt.Errorf("رصيد غير كافٍ: لديك %.2f وتريد سحب %.2f", a.Balance, amount)
    }
    a.Balance -= amount
    fmt.Printf("سحب %.2f — الرصيد الجديد: %.2f\n", amount, a.Balance)
    return nil
}

// عرض الرصيد — قراءة فقط لكن نستخدم مؤشر للاتساق
// Display — read-only but pointer for consistency
func (a *Account) Display() string {
    return fmt.Sprintf("حساب %s — الرصيد: %.2f ريال", a.Owner, a.Balance)
}

func main() {
    acc := &Account{Owner: "أحمد", Balance: 1000}
    fmt.Println(acc.Display())

    acc.Deposit(500)
    acc.Withdraw(200)

    err := acc.Withdraw(5000)
    if err != nil {
        fmt.Println("خطأ:", err)
    }

    fmt.Println(acc.Display())
}

Output:

الفرق العملي بين النوعين

لنرى ماذا يحدث عندما نستخدم مستقبل قيمة مع أسلوب يحاول التعديل:

main.go

package main

import "fmt"

type Counter struct {
    Value int
}

// مستقبل قيمة — يعمل على نسخة!
// Value receiver — works on a COPY!
func (c Counter) IncrementWrong() {
    c.Value++ // هذا يُعدّل النسخة فقط — This only modifies the copy
}

// مستقبل مؤشر — يعمل على الأصل
// Pointer receiver — works on the original
func (c *Counter) IncrementRight() {
    c.Value++ // هذا يُعدّل القيمة الأصلية — This modifies the original
}

func main() {
    c := Counter{Value: 0}

    c.IncrementWrong()
    c.IncrementWrong()
    c.IncrementWrong()
    fmt.Println("بعد 3 زيادات خاطئة:", c.Value) // 0! لم يتغير!

    c.IncrementRight()
    c.IncrementRight()
    c.IncrementRight()
    fmt.Println("بعد 3 زيادات صحيحة:", c.Value) // 3
}

Output:

أساليب على أنواع غير Struct

يمكنك تعريف أساليب على أي نوع تُعرّفه — ليس فقط struct:

main.go

package main

import (
    "fmt"
    "strings"
)

// نوع مخصص مبني على string — Custom type based on string
type ArabicName string

// تحويل لحروف كبيرة — Convert to uppercase
func (n ArabicName) Shout() string {
    return strings.ToUpper(string(n)) + "!"
}

// طول الاسم — Name length
func (n ArabicName) Len() int {
    return len([]rune(string(n)))
}

// نوع مخصص مبني على int — Custom type based on int
type Celsius float64

// تحويل إلى فهرنهايت — Convert to Fahrenheit
func (c Celsius) ToFahrenheit() float64 {
    return float64(c)*9/5 + 32
}

func (c Celsius) String() string {
    return fmt.Sprintf("%.1f°C", float64(c))
}

func main() {
    name := ArabicName("محمد")
    fmt.Println(name.Shout())
    fmt.Printf("طول الاسم: %d حروف\n", name.Len())

    temp := Celsius(36.6)
    fmt.Printf("%s = %.1f°F\n", temp, temp.ToFahrenheit())
}

Output:

مجموعة الأساليب — Method Sets

هذا مفهوم مهم لفهم الواجهات لاحقاً:

القيمة من نوع T تستطيع استدعاء أساليب T فقط (مستقبل قيمة)
المؤشر من نوع *T يستطيع استدعاء أساليب T و *T (كلا النوعين)

عملياً Go يقوم بتحويل تلقائي في معظم الحالات، لكن هذا يُهم عند التعامل مع الواجهات.

أخطاء شائعة

خطأ 1: نسيان أن مستقبل القيمة يعمل على نسخة

// ❌ خطأ شائع — هذا لا يُعدّل الأصل
func (u User) UpdateName(name string) {
    u.Name = name  // تعديل على نسخة!
}

// ✅ الصحيح
func (u *User) UpdateName(name string) {
    u.Name = name  // تعديل على الأصل
}

خطأ 2: محاولة تعريف أسلوب على نوع من حزمة أخرى

// ❌ لا يمكنك تعريف أسلوب على int مباشرة
func (n int) Double() int { return n * 2 }

// ✅ عرّف نوعك الخاص
type MyInt int
func (n MyInt) Double() int { return int(n) * 2 }

تحدي — Challenge

package main

import (
    "fmt"
    "math"
)

// عرّف نوع الدائرة — Define Circle type
type Circle struct {
    Radius float64
}

// أسلوب حساب المحيط — Perimeter method (2πr)
func (c Circle) Perimeter() float64 {
    // اكتب الكود هنا — احسب 2 * π * r
    return 0
}

// أسلوب حساب المساحة — Area method (πr²)
func (c Circle) Area() float64 {
    // اكتب الكود هنا — احسب π * r²
    return 0
}

func main() {
    c := Circle{Radius: 5}
    fmt.Printf("الدائرة: محيط=%.2f مساحة=%.2f\n", c.Perimeter(), c.Area())
}