أنواع البيانات

أنواع البيانات — Data Types

Go لغة ذات أنواع ثابتة (statically typed) — كل متغير له نوع محدد لا يتغير. هذا يجعل الكود أكثر أماناً وأسرع في التنفيذ.

الأنواع الأساسية

الأعداد الصحيحة (Integers)

النوع	الحجم	المدى
`int8`	8 بت	-128 إلى 127
`int16`	16 بت	-32,768 إلى 32,767
`int32`	32 بت	±2 مليار
`int64`	64 بت	±9.2 كوينتيليون
`int`	32/64 بت	حسب النظام
`uint`	32/64 بت	أعداد موجبة فقط
`byte`	8 بت	اسم مستعار لـ uint8

في معظم الحالات، استخدم int وخلاص — Go يختار الحجم المناسب.

الأعداد العشرية (Floats)

النوع	الدقة
`float32`	~7 خانات عشرية
`float64`	~15 خانة عشرية (الافتراضي)

النصوص (Strings)

النصوص في Go هي غير قابلة للتغيير (immutable) ومُشفّرة بـ UTF-8 — يعني تدعم العربي بشكل ممتاز!

القيم المنطقية (Booleans)

bool — إما true أو false.

main.go

package main

import "fmt"

func main() {
    // الأعداد الصحيحة — Integers
    var age int = 25
    var year int64 = 2026
    var temperature int = -5
    
    // الأعداد العشرية — Floats
    var pi float64 = 3.14159
    var grade float32 = 95.5
    
    // النصوص — Strings
    var name string = "عزيز"
    var greeting string = "مرحباً يا " + name
    
    // المنطقية — Booleans
    var isActive bool = true
    var isDeleted bool = false
    
    fmt.Println("العمر:", age)
    fmt.Println("السنة:", year)
    fmt.Println("الحرارة:", temperature)
    fmt.Printf("π = %.5f\n", pi)
    fmt.Println("الدرجة:", grade)
    fmt.Println("التحية:", greeting)
    fmt.Println("نشط:", isActive, "| محذوف:", isDeleted)
    
    // حجم النوع — Type info
    fmt.Printf("\nنوع age: %T\n", age)
    fmt.Printf("نوع pi: %T\n", pi)
    fmt.Printf("نوع name: %T\n", name)
}

Output:

النصوص بالتفصيل (Strings)

النصوص في Go تدعم UTF-8 أصلاً — العربي يعمل بدون أي إعداد خاص:

main.go

package main

import (
    "fmt"
    "strings"
)

func main() {
    // عمليات على النصوص — String operations
    s := "بسم الله الرحمن الرحيم"
    
    fmt.Println("النص:", s)
    fmt.Println("الطول (بالبايت):", len(s))
    
    // عد الأحرف الفعلية (الرونات) — Count actual characters (runes)
    runes := []rune(s)
    fmt.Println("عدد الأحرف:", len(runes))
    
    // دمج النصوص — Concatenation
    first := "مرحبا"
    last := "Go"
    full := first + " يا " + last
    fmt.Println(full)
    
    // دوال حزمة strings
    fmt.Println("يحتوي على 'الله':", strings.Contains(s, "الله"))
    fmt.Println("يبدأ بـ 'بسم':", strings.HasPrefix(s, "بسم"))
    fmt.Println("بأحرف كبيرة:", strings.ToUpper("hello go"))
    fmt.Println("تكرار:", strings.Repeat("Go! ", 3))
    fmt.Println("استبدال:", strings.Replace("aaa", "a", "b", 2))
}

Output:

تحويل الأنواع (Type Conversion)

Go لا تُحوّل الأنواع ضمنياً — يجب أن تكون صريحاً. هذا تصميم مقصود لمنع الأخطاء:

var x int = 42
var y float64 = float64(x)  // ✅ تحويل صريح
var z int = int(y)           // ✅ تحويل صريح

var a int32 = 100
var b int64 = int64(a)       // ✅ حتى بين أنواع int المختلفة

main.go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // تحويل بين الأنواع العددية — Numeric conversions
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(i)
    
    fmt.Printf("int: %d → float64: %f → uint: %d\n", i, f, u)
    
    // تحويل عدد إلى نص — Int to string
    numStr := strconv.Itoa(42)
    fmt.Println("العدد كنص:", numStr)
    
    // تحويل نص إلى عدد — String to int
    num, err := strconv.Atoi("123")
    if err != nil {
        fmt.Println("خطأ:", err)
    } else {
        fmt.Println("النص كعدد:", num)
    }
    
    // تحويل فاشل — Failed conversion
    _, err2 := strconv.Atoi("ليس عدد")
    if err2 != nil {
        fmt.Println("خطأ متوقع:", err2)
    }
    
    // تحويل float إلى string
    floatStr := fmt.Sprintf("%.2f", 3.14159)
    fmt.Println("عشري كنص:", floatStr)
}

Output:

Rune — الأحرف

في Go، الحرف الواحد يُمثَّل بـ rune (اسم مستعار لـ int32). هذا مهم خاصة مع العربي:

main.go

package main

import "fmt"

func main() {
    // حرف واحد — Single character (rune)
    var letter rune = 'ع'
    fmt.Printf("الحرف: %c, القيمة: %d\n", letter, letter)
    
    // المرور على أحرف نص عربي — Iterate Arabic string
    text := "سلام"
    fmt.Println("الأحرف:")
    for i, ch := range text {
        fmt.Printf("  الموضع %d: %c (Unicode: %U)\n", i, ch, ch)
    }
    
    // طول البايتات vs عدد الأحرف — Bytes vs runes
    arabic := "مرحبا"
    fmt.Printf("\n'%s' — بايتات: %d, أحرف: %d\n", arabic, len(arabic), len([]rune(arabic)))
    
    english := "hello"
    fmt.Printf("'%s' — بايتات: %d, أحرف: %d\n", english, len(english), len([]rune(english)))
}

Output:

القيم الصفرية (Zero Values)

كل نوع في Go له قيمة افتراضية:

النوع	القيمة الصفرية
`int`, `float64`	`0`
`string`	`""` (نص فارغ)
`bool`	`false`
`pointer`	`nil`

تحدي — Challenge

package main

import "fmt"

func main() {
    // عرّف name (string) و age (int)
    // ثم اطبع: مرحبا عزيز! عمرك 25 سنة
    // اكتب الكود هنا
}