AzLearn — منصة التعلّم من عزيز ويرز

Docker

Mon, 01 Jan 0001 00:00:00 +0000

Docker — حاويات Go

Go من أفضل اللغات لـ Docker — لأنها تُنتج ملفاً تنفيذياً واحداً بدون اعتماديات. هذا يعني صور Docker صغيرة جداً وآمنة.

لماذا Go + Docker = ❤️

ملف تنفيذي واحد (static binary) — لا تحتاج runtime
يمكن استخدام صورة scratch (فارغة!) — أصغر صورة ممكنة
البناء سريع مع cache الوحدات
Cross-compilation مدمج

Dockerfile بسيط

main.go

package main

import "fmt"

func main() {
 fmt.Println(`# ❌ Dockerfile بسيط (غير مُحسّن)
FROM golang:1.22

WORKDIR /app
COPY . .
RUN go build -o server .

CMD ["./server"]

# الحجم: ~1.2GB! 😱
# يحتوي كل أدوات Go + نظام تشغيل كامل`)

 fmt.Println()

 fmt.Println(`# ✅ Dockerfile متعدد المراحل (مُحسّن)
FROM golang:1.22-alpine AS builder

WORKDIR /app

# نسخ ملفات الوحدة أولاً للاستفادة من cache
COPY go.mod go.sum ./
RUN go mod download

# نسخ الكود والبناء
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o server .

# المرحلة النهائية — صورة scratch فارغة!
FROM scratch

# نسخ شهادات SSL (للاتصال HTTPS)
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=builder /app/server /server

EXPOSE 8080
CMD ["/server"]

# الحجم: ~10-15MB! 🚀`)
}

Output:

شرح البناء المتعدد المراحل

main.go

package main

import "fmt"

func main() {
 fmt.Println("=== مراحل البناء ===\n")

 stages := []struct {
 stage string
 desc string
 size string
 }{
 {"golang:1.22-alpine", "مرحلة البناء — تحتوي كل الأدوات", "~300MB"},
 {"scratch", "المرحلة النهائية — فارغة تماماً!", "0MB"},
 {"الصورة النهائية", "الملف التنفيذي + شهادات SSL فقط", "~10-15MB"},
 }

 for i, s := range stages {
 fmt.Printf("%d. %s\n %s (الحجم: %s)\n\n", i+1, s.stage, s.desc, s.size)
 }

 fmt.Println("=== الأعلام المهمة ===")
 fmt.Println("CGO_ENABLED=0 → بناء ثابت بدون اعتماديات C")
 fmt.Println("GOOS=linux → بناء لنظام Linux")
 fmt.Println("-ldflags=\"-s -w\" → حذف معلومات التصحيح (أصغر)")
 fmt.Println("-trimpath → حذف مسارات الملفات المحلية")

 fmt.Println("\n=== بدائل scratch ===")
 fmt.Println("scratch → 0MB (لا shell، لا أدوات)")
 fmt.Println("alpine → ~5MB (shell + أدوات أساسية)")
 fmt.Println("distroless → ~2MB (أمان + شهادات)")
}

Output:

Docker Compose

main.go

package main

import "fmt"

func main() {
 fmt.Println(`# docker-compose.yml
version: "3.9"

services:
 app:
 build: .
 ports:
 - "8080:8080"
 environment:
 - DATABASE_URL=postgres://user:pass@db:5432/mydb?sslmode=disable
 - ENV=production
 depends_on:
 db:
 condition: service_healthy
 restart: unless-stopped

 db:
 image: postgres:16-alpine
 environment:
 POSTGRES_USER: user
 POSTGRES_PASSWORD: pass
 POSTGRES_DB: mydb
 volumes:
 - pgdata:/var/lib/postgresql/data
 healthcheck:
 test: ["CMD-SHELL", "pg_isready -U user"]
 interval: 5s
 timeout: 5s
 retries: 5

 redis:
 image: redis:7-alpine
 ports:
 - "6379:6379"

volumes:
 pgdata:`)

 fmt.Println("\n=== الأوامر ===")
 fmt.Println("docker compose up -d → تشغيل في الخلفية")
 fmt.Println("docker compose logs -f app → عرض السجلات")
 fmt.Println("docker compose down → إيقاف وحذف")
 fmt.Println("docker compose build --no-cache → إعادة البناء")
}

Output:

.dockerignore

.git
.gitignore
README.md
Makefile
*.md
vendor/
tmp/
.env

أفضل ممارسات Docker + Go

main.go

package main

import "fmt"

func main() {
 tips := []struct {
 tip string
 why string
 }{
 {"استخدم multi-stage build", "حجم أصغر 100x"},
 {"CGO_ENABLED=0 دائماً", "بناء ثابت بدون مشاكل"},
 {"انسخ go.mod أولاً", "cache أفضل للاعتماديات"},
 {"استخدم scratch أو distroless", "أقل سطح هجوم"},
 {"لا تشغّل كـ root", "أمان أفضل"},
 {"أضف healthcheck", "Kubernetes/compose يعرف الحالة"},
 {"استخدم .dockerignore", "بناء أسرع"},
 }

 fmt.Println("=== أفضل ممارسات Docker + Go ===\n")
 for i, t := range tips {
 fmt.Printf("%d. %s\n → %s\n\n", i+1, t.tip, t.why)
 }
}

Output:

إضافة مستخدم غير root

FROM scratch

# إضافة مستخدم — Add non-root user
COPY --from=builder /etc/passwd /etc/passwd
COPY --from=builder /app/server /server

USER nobody
CMD ["/server"]

تحدي — Challenge

package main

import "fmt"

func main() {
 // اطبع ملخص استراتيجية Docker لـ Go:
 // المرحلة 1, المرحلة 2, الحجم, الأمان
 // اكتب الكود هنا
}

أساسيات HTTP

Mon, 01 Jan 0001 00:00:00 +0000

أساسيات HTTP — HTTP Basics

من أعظم نقاط قوة Go أن مكتبتها القياسية تحتوي على خادم HTTP إنتاجي — لا تحتاج Express أو Flask أو أي framework. حزمة net/http وحدها كافية لبناء خوادم تخدم ملايين الطلبات.

ملاحظة مهمة: أمثلة HTTP لا يمكن تشغيلها على Go Playground لأنها تحتاج شبكة. اقرأ الكود وافهمه، ثم جرّبه على جهازك المحلي.

أبسط خادم HTTP

main.go

package main

import (
 "fmt"
 "net/http"
)

func main() {
 // معالج بسيط — Simple handler
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "مرحباً بالعالم! 🌍")
 })

 http.HandleFunc("/salam", func(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "السلام عليكم ورحمة الله وبركاته")
 })

 fmt.Println("الخادم يعمل على http://localhost:8080")
 // شغّل هذا على جهازك — Run this locally
 // http.ListenAndServe(":8080", nil)
}

Output:

واجهة http.Handler

كل شيء في net/http يدور حول هذه الواجهة:

أساسيات SQL

Mon, 01 Jan 0001 00:00:00 +0000

أساسيات SQL — SQL Basics

حزمة database/sql هي الواجهة الموحدة للتعامل مع قواعد البيانات العلائقية في Go. التصميم ذكي: الحزمة تُعرّف الواجهة، والمشغّلات (drivers) تُنفّذها لكل قاعدة بيانات.

ملاحظة: أمثلة قواعد البيانات لا يمكن تشغيلها مباشرة على Go Playground لأنها تحتاج قاعدة بيانات فعلية. الكود هنا للقراءة والفهم — جرّبه محلياً.

بنية الحزمة

database/sql (الواجهة — Interface)
 ↓
مشغّل (Driver)
 ↓
قاعدة البيانات (PostgreSQL / MySQL / SQLite)

المشغّلات الشائعة:

أساسيات الأخطاء

Mon, 01 Jan 0001 00:00:00 +0000

أساسيات الأخطاء — Error Basics

في أغلب اللغات، الأخطاء تُعالج عبر الاستثناءات (exceptions) — تُرمى في مكان وتُلتقط في مكان آخر. Go اختارت طريقاً مختلفاً تماماً: الأخطاء قيم عادية.

هذا يعني أنك تتعامل مع الخطأ كما تتعامل مع أي قيمة — تفحصه، تمرره، تغلّفه، أو تتجاهله (وهذا خطأ!).

واجهة error

error هو نوع مُدمج في Go — واجهة بأسلوب واحد:

type error interface {
 Error() string
}

أي نوع يُنفّذ Error() string يُعتبر خطأ. بهذه البساطة.

أساسيات الاختبار

Mon, 01 Jan 0001 00:00:00 +0000

أساسيات الاختبار — Testing Basics

الاختبارات في Go مواطنون من الدرجة الأولى — مدمجة في اللغة والأدوات. لا تحتاج Jest أو pytest أو JUnit. كل ما تحتاجه هو ملف ينتهي بـ _test.go وأمر go test.

القواعد الأساسية

ملف الاختبار يجب أن ينتهي بـ _test.go
دوال الاختبار تبدأ بـ Test مع حرف كبير
تأخذ معامل واحد: *testing.T
لا تُرجع شيئاً

main.go

package main

import (
 "fmt"
 "strings"
)

// الدوال المُختبرة — Functions to test
func Add(a, b int) int {
 return a + b
}

func IsEven(n int) bool {
 return n%2 == 0
}

func Reverse(s string) string {
 runes := []rune(s)
 for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
 runes[i], runes[j] = runes[j], runes[i]
 }
 return string(runes)
}

func ToTitle(s string) string {
 // ملاحظة: strings.Title مهملة منذ Go 1.18، استخدم golang.org/x/text/cases بدلاً منها
 // Note: strings.Title is deprecated since Go 1.18, use golang.org/x/text/cases instead
 return strings.Title(strings.ToLower(s))
}

// محاكاة الاختبارات — Simulated tests
func testAdd() {
 if Add(2, 3) != 5 {
 fmt.Println("❌ FAIL: TestAdd — 2+3 يجب أن يكون 5")
 } else {
 fmt.Println("✅ PASS: TestAdd")
 }
}

func testIsEven() {
 cases := []struct{ n int; want bool }{
 {0, true}, {1, false}, {2, true}, {-4, true}, {7, false},
 }
 allPassed := true
 for _, c := range cases {
 if IsEven(c.n) != c.want {
 fmt.Printf("❌ FAIL: IsEven(%d) = %v، المتوقع %v\n", c.n, !c.want, c.want)
 allPassed = false
 }
 }
 if allPassed {
 fmt.Println("✅ PASS: TestIsEven")
 }
}

func testReverse() {
 result := Reverse("مرحبا")
 if result != "ابحرم" {
 fmt.Printf("❌ FAIL: Reverse — حصلت على %q\n", result)
 } else {
 fmt.Println("✅ PASS: TestReverse")
 }
}

func main() {
 fmt.Println("=== تشغيل الاختبارات ===\n")
 testAdd()
 testIsEven()
 testReverse()

 fmt.Println("\n=== في الملف الحقيقي ===")
 fmt.Println("الملف: math_test.go")
 fmt.Println("التشغيل: go test ./...")
}

Output:

ملف الاختبار الحقيقي

هكذا يبدو ملف اختبار Go الفعلي:

الأساليب

Mon, 01 Jan 0001 00:00:00 +0000

الأساليب — 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().

السياق

Mon, 01 Jan 0001 00:00:00 +0000

السياق — Context

context.Context هي واحدة من أهم واجهات Go — تُستخدم لإلغاء العمليات، تحديد المهل الزمنية، وتمرير بيانات عبر طبقات البرنامج. كل طلب HTTP، كل استعلام قاعدة بيانات، كل عملية طويلة — يجب أن تأخذ context.

لماذا Context؟

تخيّل مستخدم فتح صفحة ثم أغلق المتصفح. بدون context، الخادم يستمر في المعالجة بلا فائدة! مع context، الخادم يعرف أن العميل رحل ويتوقف فوراً.

أنواع Context

main.go

package main

import (
 "context"
 "fmt"
 "time"
)

func main() {
 // 1. context.Background — الجذر — Root context
 ctx := context.Background()
 fmt.Printf("Background: %v\n", ctx)

 // 2. context.TODO — مؤقت حتى تقرر ماذا تستخدم
 todoCtx := context.TODO()
 fmt.Printf("TODO: %v\n", todoCtx)

 // 3. WithCancel — إلغاء يدوي — Manual cancellation
 cancelCtx, cancel := context.WithCancel(ctx)
 fmt.Printf("WithCancel: %v (Err: %v)\n", cancelCtx, cancelCtx.Err())
 cancel() // إلغاء!
 fmt.Printf("بعد الإلغاء: Err = %v\n", cancelCtx.Err())

 // 4. WithTimeout — إلغاء بعد مدة — Auto-cancel after duration
 timeoutCtx, timeoutCancel := context.WithTimeout(ctx, 100*time.Millisecond)
 defer timeoutCancel()
 fmt.Printf("WithTimeout: deadline in 100ms\n")

 // 5. WithDeadline — إلغاء في وقت محدد
 deadline := time.Now().Add(5 * time.Second)
 deadlineCtx, deadlineCancel := context.WithDeadline(ctx, deadline)
 defer deadlineCancel()
 d, _ := deadlineCtx.Deadline()
 fmt.Printf("WithDeadline: %v\n", d.Format("15:04:05"))

 _ = timeoutCtx
}

Output:

الإلغاء — Cancellation

main.go

package main

import (
 "context"
 "fmt"
 "time"
)

// عملية طويلة قابلة للإلغاء — Long operation with cancellation
func longOperation(ctx context.Context, name string) {
 for i := 1; i <= 10; i++ {
 select {
 case <-ctx.Done():
 fmt.Printf("[%s] ⛔ تم الإلغاء عند الخطوة %d: %v\n", name, i, ctx.Err())
 return
 default:
 fmt.Printf("[%s] الخطوة %d\n", name, i)
 time.Sleep(50 * time.Millisecond)
 }
 }
 fmt.Printf("[%s] ✅ اكتمل!\n", name)
}

func main() {
 // إلغاء يدوي بعد 150ms — Cancel manually after 150ms
 ctx, cancel := context.WithCancel(context.Background())

 go longOperation(ctx, "عملية-1")

 time.Sleep(150 * time.Millisecond)
 cancel() // إلغاء!
 time.Sleep(50 * time.Millisecond)

 fmt.Println("\n--- المهلة الزمنية ---")

 // مهلة 120ms — Timeout after 120ms
 timeoutCtx, timeoutCancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
 defer timeoutCancel()

 longOperation(timeoutCtx, "عملية-2")
}

Output:

WithValue — تمرير بيانات

main.go

package main

import (
 "context"
 "fmt"
)

// مفاتيح مخصصة — Custom keys (تجنّب string!)
type contextKey string

const (
 userIDKey contextKey = "userID"
 requestIDKey contextKey = "requestID"
)

// دالة تقرأ من Context — Read from context
func processRequest(ctx context.Context) {
 userID, ok := ctx.Value(userIDKey).(int)
 if !ok {
 fmt.Println("❌ لا يوجد userID في السياق")
 return
 }

 requestID, _ := ctx.Value(requestIDKey).(string)
 fmt.Printf("معالجة الطلب %s للمستخدم %d\n", requestID, userID)
}

func main() {
 ctx := context.Background()

 // إضافة قيم — Add values
 ctx = context.WithValue(ctx, userIDKey, 42)
 ctx = context.WithValue(ctx, requestIDKey, "req-abc-123")

 processRequest(ctx)

 // سياق بدون userID — Context without userID
 emptyCtx := context.Background()
 processRequest(emptyCtx)
}

Output:

تحذير: لا تستخدم WithValue لتمرير معاملات الدوال! استخدمها فقط للبيانات العابرة (request ID, auth token, trace ID).

الغوروتينات

Mon, 01 Jan 0001 00:00:00 +0000

الغوروتينات — Goroutines

تخيّل أنك في مطعم. في النموذج التقليدي، هناك نادل واحد يخدم طاولة واحدة في كل مرة — إذا طاولة طلبت شيئاً يأخذ وقتاً، كل الطاولات الأخرى تنتظر. في نموذج Go، هناك عشرات النوادل الخفيفين يخدمون كل الطاولات بالتوازي — وكل نادل لا يكلّف شيئاً تقريباً.

هذا هو مفهوم goroutine: خيط تنفيذ خفيف الوزن يعمل بالتزامن مع باقي البرنامج.

ما هي الـ goroutine؟

هي دالة تعمل بشكل متزامن مع دوال أخرى
أخف بكثير من خيوط نظام التشغيل (thread) — حوالي 2KB من الذاكرة مقابل ~1MB للخيط
يمكنك تشغيل آلاف أو ملايين منها بدون مشاكل
Go runtime يدير جدولتها (scheduling) تلقائياً

كلمة go

لتشغيل goroutine، أضف كلمة go قبل استدعاء الدالة:

المتغيرات والثوابت

Mon, 01 Jan 0001 00:00:00 +0000

المتغيرات والثوابت — Variables & Constants

المتغيرات هي صناديق تخزين البيانات في أي لغة برمجة. في Go، هناك عدة طرق لتعريف المتغيرات، وكل طريقة لها استخدامها المناسب.

تعريف المتغيرات بـ `var`

الطريقة الكلاسيكية لتعريف متغير:

var name string = "عزيز"
var age int = 25
var isStudent bool = true

الصيغة: var اسم_المتغير نوع_البيانات = القيمة

يمكنك حذف النوع إذا أعطيت قيمة — Go يستنتج النوع تلقائياً (type inference):

var name = "عزيز" // Go يعرف أنها string
var age = 25 // Go يعرف أنها int

ويمكنك التعريف بدون قيمة — ستأخذ القيمة الصفرية (zero value):

المصفوفات والشرائح

Mon, 01 Jan 0001 00:00:00 +0000

المصفوفات والشرائح — Arrays & Slices

في Go هناك نوعان لتخزين مجموعة عناصر: المصفوفات (Arrays) ذات الحجم الثابت، والشرائح (Slices) ذات الحجم المتغير. في الممارسة العملية، الشرائح هي ما ستستخدمه ٩٩٪ من الوقت.

المصفوفات (Arrays)

المصفوفة لها حجم ثابت يُحدد عند التعريف ولا يمكن تغييره:

main.go

package main

import "fmt"

func main() {
 // تعريف مصفوفة — Declare an array
 var numbers [5]int
 numbers[0] = 10
 numbers[1] = 20
 numbers[4] = 50
 fmt.Println("المصفوفة:", numbers)
 fmt.Println("الطول:", len(numbers))
 
 // تعريف مع قيم — Array literal
 fruits := [3]string{"تفاح", "موز", "برتقال"}
 fmt.Println("الفواكه:", fruits)
 
 // Go يحسب الحجم — Let Go count
 colors := [...]string{"أحمر", "أخضر", "أزرق"}
 fmt.Println("الألوان:", colors)
 fmt.Println("العدد:", len(colors))
 
 // المرور على المصفوفة — Iterate
 for i, fruit := range fruits {
 fmt.Printf(" %d: %s\n", i, fruit)
 }
}

Output:

قيود المصفوفات:

الوحدات

Mon, 01 Jan 0001 00:00:00 +0000

الوحدات — Modules

الوحدات (Modules) هي نظام إدارة الاعتماديات في Go منذ الإصدار 1.11. قبلها كان هناك GOPATH الذي كان مصدر إحباط للكثيرين. الآن النظام بسيط ومنظم.

ما هي الوحدة؟

الوحدة = مجموعة من الحزم Go ذات العلاقة، تُدار كوحدة واحدة. كل وحدة لها ملف go.mod في الجذر.

إنشاء وحدة جديدة

main.go

package main

import "fmt"

func main() {
 fmt.Println("=== إنشاء وحدة جديدة ===\n")

 steps := []struct {
 cmd string
 desc string
 }{
 {"mkdir myproject && cd myproject", "إنشاء مجلد المشروع"},
 {"go mod init github.com/user/myproject", "تهيئة الوحدة"},
 {"# يُنشئ ملف go.mod", ""},
 }

 for _, s := range steps {
 if s.desc != "" {
 fmt.Printf("$ %s\n → %s\n\n", s.cmd, s.desc)
 }
 }

 fmt.Println("=== ملف go.mod ===")
 fmt.Println(`module github.com/user/myproject

go 1.22

require (
 github.com/gin-gonic/gin v1.9.1
 github.com/lib/pq v1.10.9
)

require (
 // اعتماديات غير مباشرة — Indirect dependencies
 golang.org/x/net v0.17.0 // indirect
)`)
}

Output:

مسار الوحدة — Module Path

مسار الوحدة يُحدد هوية مشروعك:

بناء أداة CLI

Mon, 01 Jan 0001 00:00:00 +0000

بناء أداة CLI — Building a CLI Tool

أحد أقوى استخدامات Go هو بناء أدوات سطر الأوامر (CLI tools). Go تُنتج ملفاً تنفيذياً واحداً — لا تبعيات، لا runtime — وهذا مثالي لأدوات CLI.

os.Args — المعاملات البسيطة

أبسط طريقة لقراءة معاملات سطر الأوامر:

main.go

package main

import (
 "fmt"
 "os"
)

func main() {
 // os.Args شريحة تحتوي كل المعاملات
 // os.Args[0] = اسم البرنامج
 // os.Args[1:] = المعاملات
 
 args := os.Args
 fmt.Println("كل المعاملات:", args)
 fmt.Println("اسم البرنامج:", args[0])
 
 if len(args) > 1 {
 fmt.Println("المعاملات:", args[1:])
 for i, arg := range args[1:] {
 fmt.Printf(" معامل %d: %s\n", i+1, arg)
 }
 } else {
 fmt.Println("لم تُمرر أي معاملات!")
 fmt.Println("الاستخدام: البرنامج <اسم> [خيارات...]")
 }
}

Output:

حزمة flag — خيارات متقدمة

flag تُسهّل تعريف خيارات مثل --name أحمد --age 25:

ما هي لغة Go؟

Mon, 01 Jan 0001 00:00:00 +0000

ما هي لغة Go؟ — What is Go?

لغة Go (وتُعرف أيضاً بـ Golang) هي لغة برمجة مفتوحة المصدر طورتها شركة Google عام 2009. صُممت Go لتكون بسيطة وسريعة وفعالة — خاصة لبناء الأنظمة الخلفية (backend systems) والخدمات السحابية.

القصة وراء Go

في عام 2007، كان ثلاثة مهندسين في Google — روبرت غريسمر (Robert Griesemer) وروب بايك (Rob Pike) وكين تومبسون (Ken Thompson) — يعانون من بطء الترجمة (compilation) في المشاريع الضخمة وتعقيد اللغات المتوفرة مثل C++ وJava.

أنماط الأخطاء المتقدمة

Mon, 01 Jan 0001 00:00:00 +0000

أنماط الأخطاء المتقدمة — Advanced Error Patterns

بعد فهم الأساسيات، حان وقت الأنماط المتقدمة. هذه الأنماط تُستخدم في المشاريع الكبيرة حيث تحتاج تصنيف الأخطاء والتعامل مع كل نوع بشكل مختلف.

الأخطاء الحارسة — Sentinel Errors

أخطاء مُعرّفة كمتغيرات على مستوى الحزمة، تُستخدم للمقارنة:

main.go

package main

import (
 "errors"
 "fmt"
)

// أخطاء حارسة — Sentinel errors
var (
 ErrNotFound = errors.New("غير موجود")
 ErrUnauthorized = errors.New("غير مصرح")
 ErrForbidden = errors.New("ممنوع الوصول")
)

// محاكاة طلب — Simulate request
func getResource(id int, role string) (string, error) {
 if role == "" {
 return "", ErrUnauthorized
 }
 if role != "admin" {
 return "", ErrForbidden
 }
 if id > 100 {
 return "", ErrNotFound
 }
 return fmt.Sprintf("مورد #%d", id), nil
}

func main() {
 cases := []struct {
 id int
 role string
 }{
 {1, "admin"},
 {1, ""},
 {1, "user"},
 {999, "admin"},
 }

 for _, c := range cases {
 result, err := getResource(c.id, c.role)
 switch {
 case err == nil:
 fmt.Printf("✅ النتيجة: %s\n", result)
 case errors.Is(err, ErrUnauthorized):
 fmt.Println("🔐 يجب تسجيل الدخول أولاً")
 case errors.Is(err, ErrForbidden):
 fmt.Println("🚫 ليس لديك صلاحيات كافية")
 case errors.Is(err, ErrNotFound):
 fmt.Println("❓ المورد غير موجود")
 default:
 fmt.Println("❌ خطأ غير متوقع:", err)
 }
 }
}

Output:

أنواع أخطاء مخصصة — Custom Error Types

عندما تحتاج أن يحمل الخطأ بيانات إضافية:

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

Mon, 01 Jan 0001 00:00:00 +0000

أنواع البيانات — 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 يختار الحجم المناسب.

الأنواع المعممة

Mon, 01 Jan 0001 00:00:00 +0000

الأنواع المعممة — Generics

قبل Go 1.18، إذا أردت دالة تعمل مع أنواع مختلفة كنت تحتاج إما interface{} (تفقد أمان الأنواع) أو كتابة نفس الدالة لكل نوع. الأنواع المعممة (Generics) تحل هذه المشكلة بأناقة.

المشكلة بدون Generics

main.go

package main

import "fmt"

// بدون generics — نحتاج دالة لكل نوع!
// Without generics — need a function per type!
func MaxInt(a, b int) int {
 if a > b { return a }
 return b
}

func MaxFloat(a, b float64) float64 {
 if a > b { return a }
 return b
}

func MaxString(a, b string) string {
 if a > b { return a }
 return b
}

func main() {
 fmt.Println("أكبر int:", MaxInt(3, 7))
 fmt.Println("أكبر float:", MaxFloat(3.14, 2.71))
 fmt.Println("أكبر string:", MaxString("أحمد", "زيد"))
 fmt.Println("\n😤 ثلاث دوال لنفس المنطق!")
}

Output:

الحل مع Generics

main.go

package main

import (
 "cmp"
 "fmt"
)

// دالة معممة واحدة تعمل مع كل الأنواع القابلة للترتيب!
// One generic function works with all ordered types!
func Max[T cmp.Ordered](a, b T) T {
 if a > b {
 return a
 }
 return b
}

// دالة معممة أخرى — Another generic function
func Contains[T comparable](slice []T, target T) bool {
 for _, v := range slice {
 if v == target {
 return true
 }
 }
 return false
}

func main() {
 // نفس الدالة مع أنواع مختلفة — Same function, different types
 fmt.Println("أكبر int:", Max(3, 7))
 fmt.Println("أكبر float:", Max(3.14, 2.71))
 fmt.Println("أكبر string:", Max("أحمد", "زيد"))

 fmt.Println()

 // Contains مع أنواع مختلفة — Contains with different types
 nums := []int{1, 2, 3, 4, 5}
 fmt.Println("يحتوي 3؟", Contains(nums, 3))
 fmt.Println("يحتوي 9؟", Contains(nums, 9))

 names := []string{"أحمد", "فاطمة", "عمر"}
 fmt.Println("يحتوي فاطمة؟", Contains(names, "فاطمة"))
}

Output:

القيود — Constraints

القيود تُحدد ما يمكن أن يكون عليه النوع المعمم:

الاختبارات الجدولية

Mon, 01 Jan 0001 00:00:00 +0000

الاختبارات الجدولية — Table-Driven Tests

الاختبارات الجدولية هي نمط Go المميز (idiomatic) — ستجده في كل مشروع Go احترافي، بما في ذلك الكود المصدري لـ Go نفسها. الفكرة: بدلاً من كتابة دالة اختبار لكل حالة، تضع كل الحالات في جدول وتتكرر عليها.

لماذا الاختبارات الجدولية؟

// ❌ بدون جدول — تكرار ممل
func TestAdd1(t *testing.T) {
 if Add(1, 2) != 3 { t.Error("failed") }
}
func TestAdd2(t *testing.T) {
 if Add(0, 0) != 0 { t.Error("failed") }
}
func TestAdd3(t *testing.T) {
 if Add(-1, 1) != 0 { t.Error("failed") }
}

// ✅ مع جدول — نظيف وقابل للتوسع
func TestAdd(t *testing.T) {
 tests := []struct{ a, b, want int }{
 {1, 2, 3},
 {0, 0, 0},
 {-1, 1, 0},
 }
 for _, tt := range tests {
 got := Add(tt.a, tt.b)
 if got != tt.want {
 t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
 }
 }
}

مثال كامل

main.go

package main

import (
 "fmt"
 "strings"
 "unicode"
)

// الدوال المُختبرة — Functions under test
func IsPalindrome(s string) bool {
 s = strings.ToLower(s)
 runes := []rune(s)
 for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
 if runes[i] != runes[j] {
 return false
 }
 }
 return true
}

func CountDigits(s string) int {
 count := 0
 for _, r := range s {
 if unicode.IsDigit(r) {
 count++
 }
 }
 return count
}

func Truncate(s string, maxLen int) string {
 runes := []rune(s)
 if len(runes) <= maxLen {
 return s
 }
 if maxLen <= 3 {
 return string(runes[:maxLen])
 }
 return string(runes[:maxLen-3]) + "..."
}

func main() {
 // اختبار IsPalindrome — Test IsPalindrome
 fmt.Println("=== IsPalindrome ===")
 palindromeTests := []struct {
 name string
 input string
 want bool
 }{
 {"كلمة متماثلة", "level", true},
 {"كلمة عادية", "hello", false},
 {"حرف واحد", "a", true},
 {"فارغ", "", true},
 {"حالة مختلطة", "Racecar", true},
 }

 for _, tt := range palindromeTests {
 got := IsPalindrome(tt.input)
 status := "✅"
 if got != tt.want {
 status = "❌"
 }
 fmt.Printf(" %s %s: IsPalindrome(%q) = %v\n", status, tt.name, tt.input, got)
 }

 // اختبار Truncate — Test Truncate
 fmt.Println("\n=== Truncate ===")
 truncateTests := []struct {
 name string
 input string
 maxLen int
 want string
 }{
 {"نص قصير", "مرحبا", 10, "مرحبا"},
 {"نص طويل", "مرحبا بالعالم", 8, "مرحب..."},
 {"الحد الأدنى", "abcdef", 3, "abc"},
 {"مساوي للحد", "abc", 3, "abc"},
 }

 for _, tt := range truncateTests {
 got := Truncate(tt.input, tt.maxLen)
 status := "✅"
 if got != tt.want {
 status = "❌"
 }
 fmt.Printf(" %s %s: Truncate(%q, %d) = %q\n", status, tt.name, tt.input, tt.maxLen, got)
 }
}

Output:

الاختبارات الفرعية — Subtests مع t.Run

t.Run يُنشئ اختبارات فرعية مُسمّاة — مفيد للتصفية والتنظيم:

التسجيل المهيكل

Mon, 01 Jan 0001 00:00:00 +0000

التسجيل المهيكل — Structured Logging

التسجيل العادي (fmt.Println أو log.Println) لا يكفي في الإنتاج. تحتاج تسجيلاً مهيكلاً — بيانات مُنظّمة يمكن البحث فيها وتحليلها.

منذ Go 1.21، المكتبة القياسية تحتوي log/slog — تسجيل مهيكل احترافي بدون مكتبات خارجية.

المشكلة مع التسجيل العادي

main.go

package main

import (
 "fmt"
 "log"
 "time"
)

func main() {
 // التسجيل العادي — Regular logging
 log.Println("المستخدم سجّل دخوله")
 log.Printf("خطأ: فشل الاتصال بقاعدة البيانات (محاولة %d)", 3)

 fmt.Println("\n❌ المشاكل:")
 fmt.Println("1. لا مستويات (info vs error)")
 fmt.Println("2. لا بنية — نص حر يصعب تحليله")
 fmt.Println("3. لا بيانات إضافية مُنظّمة")
 fmt.Println("4. لا يعمل مع أدوات المراقبة (Grafana, ELK)")

 fmt.Println("\n✅ الحل: log/slog")
 fmt.Println(`slog.Info("المستخدم سجّل دخوله",
 "user_id", 42,
 "ip", "192.168.1.1",
 "duration_ms", 150,
)`)
 fmt.Println("\n→ يُنتج JSON أو نص مُنظّم يمكن تحليله")
}

Output:

أساسيات slog

main.go

package main

import (
 "log/slog"
 "os"
)

func main() {
 // المُسجّل الافتراضي — Default logger (text format)
 slog.Info("بدء التطبيق", "version", "1.0.0", "env", "production")
 slog.Warn("الذاكرة منخفضة", "available_mb", 128)
 slog.Error("فشل الاتصال", "host", "db.example.com", "error", "connection refused")

 // تنسيق JSON — JSON format
 jsonLogger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 jsonLogger.Info("طلب HTTP",
 "method", "GET",
 "path", "/api/users",
 "status", 200,
 "duration_ms", 45,
 )
}

Output:

مستويات التسجيل — Log Levels

main.go

package main

import (
 "log/slog"
 "os"
)

func main() {
 // إعداد المستوى الأدنى — Set minimum level
 handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 Level: slog.LevelInfo, // تجاهل Debug — Ignore Debug
 })
 logger := slog.New(handler)

 logger.Debug("تفاصيل تصحيح", "key", "value") // ⬜ لن يظهر
 logger.Info("معلومة عامة", "user", "أحمد") // ✅ يظهر
 logger.Warn("تحذير", "disk_usage", "85%") // ✅ يظهر
 logger.Error("خطأ!", "err", "timeout") // ✅ يظهر

 slog.Info("\nالمستويات:", "Debug", -4, "Info", 0, "Warn", 4, "Error", 8)
}

Output:

المجموعات والسمات — Groups & Attributes

main.go

package main

import (
 "log/slog"
 "os"
)

func main() {
 logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

 // مجموعة — Group
 logger.Info("طلب HTTP",
 slog.Group("request",
 slog.String("method", "POST"),
 slog.String("path", "/api/users"),
 slog.Int("size", 256),
 ),
 slog.Group("response",
 slog.Int("status", 201),
 slog.Int("duration_ms", 89),
 ),
 )

 // مُسجّل فرعي مع سمات ثابتة — Sub-logger with fixed attributes
 reqLogger := logger.With("request_id", "req-abc-123", "user_id", 42)
 reqLogger.Info("بدء المعالجة")
 reqLogger.Info("استعلام قاعدة البيانات", "query", "SELECT *", "rows", 15)
 reqLogger.Info("انتهاء المعالجة")
}

Output:

معرّف الطلب — Request ID / Correlation ID

main.go

package main

import (
 "fmt"
 "math/rand"
 "time"
)

// توليد معرّف طلب — Generate request ID
func generateRequestID() string {
 const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
 b := make([]byte, 8)
 for i := range b {
 b[i] = chars[rand.Intn(len(chars))]
 }
 return fmt.Sprintf("req-%s", string(b))
}

func main() {
 // محاكاة طلبات — Simulate requests
 for i := 0; i < 3; i++ {
 reqID := generateRequestID()
 start := time.Now()

 // كل رسالة تسجيل تحمل نفس المعرّف
 fmt.Printf("[%s] → بدء الطلب\n", reqID)
 time.Sleep(time.Duration(50+rand.Intn(100)) * time.Millisecond)
 fmt.Printf("[%s] → استعلام قاعدة البيانات\n", reqID)
 time.Sleep(time.Duration(20+rand.Intn(50)) * time.Millisecond)
 fmt.Printf("[%s] → انتهى (%v)\n", reqID, time.Since(start).Round(time.Millisecond))
 fmt.Println()
 }

 fmt.Println("💡 المعرّف يسمح بتتبع طلب واحد عبر كل الطبقات")
 fmt.Println(" في أدوات مثل Grafana/Kibana، ابحث بـ request_id")
}

Output:

مُسجّل مخصص للإنتاج

main.go

package main

import (
 "log/slog"
 "os"
)

func main() {
 // إعداد احترافي — Production setup
 var handler slog.Handler

 env := "production"

 if env == "production" {
 // JSON في الإنتاج — JSON in production
 handler = slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
 Level: slog.LevelInfo,
 AddSource: true, // أضف اسم الملف ورقم السطر
 })
 } else {
 // نص مقروء في التطوير — Human-readable in development
 handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 Level: slog.LevelDebug,
 })
 }

 logger := slog.New(handler)
 slog.SetDefault(logger) // اجعله الافتراضي — Set as default

 slog.Info("التطبيق بدأ",
 "env", env,
 "port", 8080,
 "version", "2.1.0",
 )

 slog.Error("مثال خطأ",
 "error", "connection timeout",
 "host", "db.example.com",
 "retry_in", "5s",
 )
}

Output:

مقارنة مكتبات التسجيل

المكتبة	المميزات	متى تستخدمها
`log/slog`	مدمجة، مهيكلة، كافية	معظم المشاريع
`zerolog`	سريعة جداً، صفر تخصيص	أداء حرج
`zap`	من Uber، مرنة، سريعة	مشاريع كبيرة

تحدي — Challenge

package main

import (
 "log/slog"
 "os"
)

func main() {
 handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 Level: slog.LevelInfo,
 ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
 if a.Key == slog.TimeKey {
 return slog.Attr{}
 }
 return a
 },
 })
 logger := slog.New(handler)

 // سجّل رسالة Info مع port و env، ورسالة Error مع host و error
 // اكتب الكود هنا
 _ = logger
}

الخرائط

Mon, 01 Jan 0001 00:00:00 +0000

الخرائط — Maps

الخريطة (Map) هي بنية بيانات تخزن أزواج مفتاح-قيمة (key-value pairs). تُعرف في لغات أخرى بـ dictionary (Python) أو HashMap (Java) أو Object (JavaScript).

إنشاء خريطة

main.go

package main

import "fmt"

func main() {
 // الطريقة الأولى: make — Create with make
 ages := make(map[string]int)
 ages["أحمد"] = 25
 ages["سارة"] = 30
 ages["عمر"] = 22
 
 fmt.Println("الأعمار:", ages)
 fmt.Println("عمر أحمد:", ages["أحمد"])
 
 // الطريقة الثانية: القيمة المباشرة — Map literal
 capitals := map[string]string{
 "السعودية": "الرياض",
 "مصر": "القاهرة",
 "الأردن": "عمّان",
 "المغرب": "الرباط",
 }
 
 fmt.Println("\nالعواصم:", capitals)
 fmt.Println("عاصمة السعودية:", capitals["السعودية"])
}

Output:

الوصول والتحقق

عند الوصول لمفتاح غير موجود، Go يُرجع القيمة الصفرية. لذلك نستخدم صيغة القيمتين:

القنوات

Mon, 01 Jan 0001 00:00:00 +0000

القنوات — Channels

القنوات هي الطريقة الرسمية للتواصل بين goroutines في Go. تخيّلها كأنابيب: goroutine واحد يُرسل قيمة من طرف، و goroutine آخر يستقبلها من الطرف الآخر.

القنوات تحل مشكلتين:

التواصل — تمرير البيانات بين goroutines
التزامن — ضمان ترتيب العمليات

إنشاء قناة واستخدامها

main.go

package main

import "fmt"

func main() {
 // إنشاء قناة — Create a channel
 ch := make(chan string)

 // إرسال من goroutine — Send from goroutine
 go func() {
 ch <- "السلام عليكم من goroutine!"
 }()

 // استقبال في main — Receive in main
 msg := <-ch
 fmt.Println(msg)
}

Output:

كيف تعمل القناة غير المُخزّنة — Unbuffered Channel

القناة غير المُخزّنة (الافتراضية) تعمل كنقطة تسليم مباشرة:

الواجهات

Mon, 01 Jan 0001 00:00:00 +0000

الواجهات — Interfaces

الواجهات هي من أجمل مفاهيم Go وأكثرها أناقة. الفكرة بسيطة لكنها عميقة: الواجهة تُعرّف سلوكاً، لا بنية. أي نوع يُنفّذ أساليب الواجهة يُحقق تلك الواجهة تلقائياً — بدون كلمة implements ولا تسجيل صريح.

هذا المبدأ يُعرف بـ التنفيذ الضمني (Implicit Implementation)، وهو ما يجعل Go مختلفة عن أغلب اللغات.

تعريف واجهة

الواجهة هي مجموعة من توقيعات الأساليب (method signatures):

// واجهة الشكل — Shape interface
type Shape interface {
 Area() float64
 Perimeter() float64
}

أي نوع يملك أسلوبي Area() و Perimeter() بنفس التوقيعات يُحقق واجهة Shape — تلقائياً!

تثبيت Go

Mon, 01 Jan 0001 00:00:00 +0000

تثبيت Go — Installing Go

قبل أن نبدأ البرمجة بجدية، نحتاج تثبيت Go على جهازك. العملية بسيطة جداً ولا تستغرق أكثر من ٥ دقائق.

ملاحظة: يمكنك تنفيذ الأمثلة في هذه الدروس مباشرة عبر بيئة التشغيل المدمجة (Go Playground) بدون تثبيت أي شيء. لكن للمشاريع الحقيقية، ستحتاج التثبيت المحلي.

الخطوة ١: تحميل Go

اذهب إلى الموقع الرسمي: go.dev/dl

اختر النسخة المناسبة لنظام تشغيلك:

على Windows

حمّل ملف .msi من صفحة التحميل
شغّل الملف واتبع خطوات التثبيت (Next → Next → Install)
Go سيُثبت تلقائياً في C:\Go
المُثبّت يُضيف Go تلقائياً إلى PATH

بعد التثبيت، افتح Command Prompt أو PowerShell وتحقق:

تصميم الحزم

Mon, 01 Jan 0001 00:00:00 +0000

تصميم الحزم — Package Design

الحزمة (Package) هي وحدة التنظيم الأساسية في Go. كل مجلد = حزمة واحدة. تصميم الحزم بشكل جيد هو ما يفرق بين مشروع Go مبتدئ ومحترف.

التصدير — Exported vs Unexported

في Go، الحرف الأول يُحدد هل الشيء مرئي خارج الحزمة:

main.go

package main

import "fmt"

// مُصدّر — يبدأ بحرف كبير — Exported
type User struct {
 Name string // مُصدّر — Exported
 Email string // مُصدّر — Exported
 age int // خاص — Unexported
}

// مُصدّر — Exported function
func NewUser(name, email string, age int) *User {
 return &User{Name: name, Email: email, age: age}
}

// خاص — Unexported function
func validateEmail(email string) bool {
 for _, ch := range email {
 if ch == '@' {
 return true
 }
 }
 return false
}

// مُصدّر يستدعي خاص — Exported calls unexported
func (u *User) IsValid() bool {
 return u.Name != "" && validateEmail(u.Email)
}

func main() {
 u := NewUser("أحمد", "ahmed@example.com", 28)
 fmt.Printf("الاسم: %s\n", u.Name) // ✅ مُصدّر
 fmt.Printf("البريد: %s\n", u.Email) // ✅ مُصدّر
 // fmt.Println(u.age) // ❌ خاص (في حزمة أخرى)
 fmt.Printf("صالح: %v\n", u.IsValid())

 fmt.Println("\n=== قواعد التصدير ===")
 fmt.Println("User → مُصدّر (حرف كبير)")
 fmt.Println("user → خاص (حرف صغير)")
 fmt.Println("NewUser → مُصدّر")
 fmt.Println("validate → خاص")
 fmt.Println("Name → حقل مُصدّر")
 fmt.Println("age → حقل خاص")
}

Output:

مجلد internal/ — الحزم الداخلية

internal/ هو مجلد خاص في Go — الحزم داخله لا يمكن استيرادها إلا من الحزم الأم:

عمليات CRUD

Mon, 01 Jan 0001 00:00:00 +0000

عمليات CRUD — CRUD Operations

CRUD هي العمليات الأربع الأساسية لأي تطبيق يتعامل مع بيانات: الإنشاء (Create)، القراءة (Read)، التحديث (Update)، والحذف (Delete). سنتعلم كيف ننفذها في Go بطريقة آمنة واحترافية.

بنية المشروع النموذجية

main.go

package main

import "fmt"

// نموذج المنتج — Product model
type Product struct {
 ID int
 Name string
 Price float64
 Category string
 InStock bool
}

// محاكاة قاعدة بيانات — Simulated database
var products = []Product{
 {ID: 1, Name: "لابتوب", Price: 3500, Category: "إلكترونيات", InStock: true},
 {ID: 2, Name: "كتاب Go", Price: 75, Category: "كتب", InStock: true},
 {ID: 3, Name: "سماعات", Price: 250, Category: "إلكترونيات", InStock: false},
}
var nextID = 4

// إنشاء — Create
func createProduct(name string, price float64, category string) Product {
 p := Product{ID: nextID, Name: name, Price: price, Category: category, InStock: true}
 nextID++
 products = append(products, p)
 return p
}

// قراءة واحد — Read one
func getProduct(id int) (Product, bool) {
 for _, p := range products {
 if p.ID == id {
 return p, true
 }
 }
 return Product{}, false
}

// تحديث — Update
func updateProduct(id int, name string, price float64) bool {
 for i := range products {
 if products[i].ID == id {
 products[i].Name = name
 products[i].Price = price
 return true
 }
 }
 return false
}

// حذف — Delete
func deleteProduct(id int) bool {
 for i, p := range products {
 if p.ID == id {
 products = append(products[:i], products[i+1:]...)
 return true
 }
 }
 return false
}

func main() {
 // Create
 newProduct := createProduct("ماوس", 120, "إلكترونيات")
 fmt.Printf("✅ إنشاء: %s (ID: %d)\n", newProduct.Name, newProduct.ID)

 // Read
 p, found := getProduct(2)
 if found {
 fmt.Printf("📖 قراءة: %s — %.0f ريال\n", p.Name, p.Price)
 }

 // Update
 if updateProduct(2, "كتاب Go المتقدم", 95) {
 fmt.Println("✏️ تحديث: تم تحديث المنتج 2")
 }

 // Delete
 if deleteProduct(3) {
 fmt.Println("🗑️ حذف: تم حذف المنتج 3")
 }

 // قائمة المنتجات — List products
 fmt.Println("\nالمنتجات النهائية:")
 for _, p := range products {
 fmt.Printf(" #%d: %s — %.0f ريال\n", p.ID, p.Name, p.Price)
 }
}

Output:

العبارات المُعدّة — Prepared Statements

العبارات المُعدّة تُحسّن الأداء عند تكرار نفس الاستعلام مع قيم مختلفة:

قراءة وكتابة الملفات

Mon, 01 Jan 0001 00:00:00 +0000

قراءة وكتابة الملفات — File I/O

التعامل مع الملفات مهارة أساسية في أي لغة. Go توفر حزماً قوية وبسيطة: os للعمليات الأساسية، bufio للقراءة المُخزنة، وio لعمليات الإدخال/الإخراج العامة.

قراءة ملف كاملاً

أبسط طريقة لقراءة ملف:

main.go

package main

import (
 "fmt"
 "os"
)

func main() {
 // سنُحاكي قراءة ملف — Simulating file read
 // في الواقع: data, err := os.ReadFile("config.txt")
 
 // لنكتب ملف أولاً ثم نقرأه — Write then read
 content := []byte("بسم الله الرحمن الرحيم\nهذا ملف تجريبي\nسطر ثالث")
 
 // كتابة — Write file
 err := os.WriteFile("/tmp/test.txt", content, 0644)
 if err != nil {
 fmt.Println("خطأ في الكتابة:", err)
 return
 }
 fmt.Println("✅ كُتب الملف بنجاح")
 
 // قراءة — Read file
 data, err := os.ReadFile("/tmp/test.txt")
 if err != nil {
 fmt.Println("خطأ في القراءة:", err)
 return
 }
 
 fmt.Println("\n📄 محتوى الملف:")
 fmt.Println(string(data))
 
 // حذف — Cleanup
 os.Remove("/tmp/test.txt")
}

Output:

القراءة سطراً بسطر

للملفات الكبيرة، القراءة سطراً بسطر أفضل من تحميل الملف كاملاً:

واجهات JSON

Mon, 01 Jan 0001 00:00:00 +0000

واجهات JSON — JSON APIs

معظم التطبيقات الحديثة تتواصل عبر JSON. Go تأتي مع حزمة encoding/json قوية تُحوّل بين Go structs و JSON بسلاسة.

تشفير JSON — Marshal

main.go

package main

import (
 "encoding/json"
 "fmt"
)

// مستخدم — User
type User struct {
 ID int `json:"id"`
 Name string `json:"name"`
 Email string `json:"email"`
 Age int `json:"age,omitempty"` // يُحذف إذا صفر — Omit if zero
 Password string `json:"-"` // لا يظهر في JSON أبداً — Never in JSON
 Tags []string `json:"tags,omitempty"`
}

func main() {
 user := User{
 ID: 1,
 Name: "أحمد",
 Email: "ahmed@example.com",
 Age: 28,
 Password: "secret123",
 Tags: []string{"مطور", "Go"},
 }

 // تحويل إلى JSON — Convert to JSON
 data, err := json.Marshal(user)
 if err != nil {
 fmt.Println("خطأ:", err)
 return
 }
 fmt.Println("JSON:", string(data))

 // تنسيق جميل — Pretty print
 pretty, _ := json.MarshalIndent(user, "", " ")
 fmt.Println("\nJSON مُنسّق:")
 fmt.Println(string(pretty))

 // بدون عمر — Without age (omitempty)
 user2 := User{ID: 2, Name: "فاطمة", Email: "fatima@example.com"}
 data2, _ := json.Marshal(user2)
 fmt.Println("\nبدون عمر:", string(data2))
}

Output:

فك تشفير JSON — Unmarshal

main.go

package main

import (
 "encoding/json"
 "fmt"
)

type Product struct {
 ID int `json:"id"`
 Name string `json:"name"`
 Price float64 `json:"price"`
 InStock bool `json:"in_stock"`
}

func main() {
 // JSON → struct
 jsonStr := `{"id": 1, "name": "كتاب Go", "price": 49.99, "in_stock": true}`

 var product Product
 err := json.Unmarshal([]byte(jsonStr), &product)
 if err != nil {
 fmt.Println("خطأ:", err)
 return
 }
 fmt.Printf("المنتج: %+v\n", product)
 fmt.Printf("الاسم: %s، السعر: %.2f\n", product.Name, product.Price)

 // مصفوفة JSON — JSON array
 jsonArray := `[
 {"id": 1, "name": "قلم", "price": 5.0, "in_stock": true},
 {"id": 2, "name": "دفتر", "price": 12.5, "in_stock": false}
 ]`

 var products []Product
 json.Unmarshal([]byte(jsonArray), &products)
 for _, p := range products {
 status := "متوفر ✅"
 if !p.InStock {
 status = "غير متوفر ❌"
 }
 fmt.Printf(" %s — %.2f ريال — %s\n", p.Name, p.Price, status)
 }

 // JSON ديناميكي — Dynamic JSON
 dynamic := `{"key": "value", "number": 42, "nested": {"a": 1}}`
 var result map[string]interface{}
 json.Unmarshal([]byte(dynamic), &result)
 fmt.Printf("\nJSON ديناميكي: %v\n", result)
}

Output:

بناء REST API كامل

main.go

package main

import (
 "encoding/json"
 "fmt"
 "net/http"
 "strings"
)

// نموذج المهمة — Task model
type Task struct {
 ID int `json:"id"`
 Title string `json:"title"`
 Done bool `json:"done"`
}

// استجابة API — API response
type APIResponse struct {
 Success bool `json:"success"`
 Data interface{} `json:"data,omitempty"`
 Error string `json:"error,omitempty"`
}

// مخزن بسيط — Simple store
var tasks = []Task{
 {ID: 1, Title: "تعلم Go", Done: true},
 {ID: 2, Title: "بناء API", Done: false},
 {ID: 3, Title: "نشر المشروع", Done: false},
}

// دالة مساعدة للـ JSON — JSON helper
func writeJSON(w http.ResponseWriter, status int, data interface{}) {
 w.Header().Set("Content-Type", "application/json; charset=utf-8")
 w.WriteHeader(status)
 json.NewEncoder(w).Encode(data)
}

// معالج المهام — Task handler
func taskHandler(w http.ResponseWriter, r *http.Request) {
 switch r.Method {
 case "GET":
 writeJSON(w, http.StatusOK, APIResponse{
 Success: true,
 Data: tasks,
 })
 case "POST":
 var newTask Task
 if err := json.NewDecoder(r.Body).Decode(&newTask); err != nil {
 writeJSON(w, http.StatusBadRequest, APIResponse{
 Success: false,
 Error: "بيانات غير صالحة",
 })
 return
 }
 newTask.ID = len(tasks) + 1
 tasks = append(tasks, newTask)
 writeJSON(w, http.StatusCreated, APIResponse{
 Success: true,
 Data: newTask,
 })
 default:
 writeJSON(w, http.StatusMethodNotAllowed, APIResponse{
 Success: false,
 Error: "أسلوب غير مسموح",
 })
 }
}

func main() {
 // محاكاة الاستجابة — Simulate response
 resp := APIResponse{
 Success: true,
 Data: tasks,
 }
 data, _ := json.MarshalIndent(resp, "", " ")
 fmt.Println("GET /api/tasks:")
 fmt.Println(string(data))

 // محاكاة إنشاء مهمة — Simulate creating task
 newTaskJSON := `{"title": "كتابة اختبارات", "done": false}`
 var newTask Task
 json.NewDecoder(strings.NewReader(newTaskJSON)).Decode(&newTask)
 newTask.ID = len(tasks) + 1
 tasks = append(tasks, newTask)

 fmt.Printf("\nPOST /api/tasks → أُنشئت مهمة %d: %s\n", newTask.ID, newTask.Title)
 fmt.Printf("المجموع الآن: %d مهام\n", len(tasks))

 _ = taskHandler // مُعرّف للاستخدام مع http.HandleFunc
}

Output:

وسوم JSON المهمة — JSON Tags

type Example struct {
 Field1 string `json:"field_1"` // اسم مخصص
 Field2 int `json:"field_2,omitempty"` // حذف إذا صفر
 Field3 bool `json:"-"` // تجاهل تماماً
 Field4 string `json:"field_4,string"` // تشفير كنص
}

json.Encoder vs json.Marshal

// Marshal — يُنتج []byte — عندما تحتاج النتيجة كنص
data, err := json.Marshal(obj)

// Encoder — يكتب مباشرة لـ io.Writer — أفضل للـ HTTP
json.NewEncoder(w).Encode(obj)

// Decoder — يقرأ من io.Reader — أفضل لقراءة الطلب
json.NewDecoder(r.Body).Decode(&obj)

تحدي — Challenge

package main

import (
 "encoding/json"
 "fmt"
)

type Product struct {
 Name string `json:"name"`
 Price float64 `json:"price"`
 InStock bool `json:"in_stock"`
}

func main() {
 data := `{"name": "كتاب Go", "price": 49.99, "in_stock": true}`

 var p Product
 // فك تشفير JSON إلى p باستخدام json.Unmarshal — اكتب الكود هنا

 status := "متوفر"
 if !p.InStock {
 status = "غير متوفر"
 }
 fmt.Printf("المنتج: %s (%.2f ريال) - %s\n", p.Name, p.Price, status)
}

أنماط التصميم

Mon, 01 Jan 0001 00:00:00 +0000

أنماط التصميم — Design Patterns

Go ليست لغة OOP تقليدية، لكنها تملك أنماط تصميم خاصة بها نشأت من الممارسة. هذه الأنماط ستجدها في كل مشروع Go احترافي.

نمط الخيارات الوظيفية — Functional Options

هذا النمط يحل مشكلة الدوال التي تقبل إعدادات كثيرة اختيارية:

main.go

package main

import "fmt"

// الخادم — Server
type Server struct {
 Host string
 Port int
 MaxConns int
 ReadTimeout int // بالثواني
 WriteTimeout int
 TLS bool
}

// نوع الخيار — Option type
type Option func(*Server)

// خيارات — Options
func WithPort(port int) Option {
 return func(s *Server) { s.Port = port }
}

func WithMaxConns(n int) Option {
 return func(s *Server) { s.MaxConns = n }
}

func WithTLS(enabled bool) Option {
 return func(s *Server) { s.TLS = enabled }
}

func WithTimeouts(read, write int) Option {
 return func(s *Server) {
 s.ReadTimeout = read
 s.WriteTimeout = write
 }
}

// المُنشئ — Constructor
func NewServer(host string, opts ...Option) *Server {
 // القيم الافتراضية — Defaults
 s := &Server{
 Host: host,
 Port: 8080,
 MaxConns: 100,
 ReadTimeout: 30,
 WriteTimeout: 30,
 TLS: false,
 }

 // تطبيق الخيارات — Apply options
 for _, opt := range opts {
 opt(s)
 }

 return s
}

func main() {
 // خادم بالإعدادات الافتراضية — Server with defaults
 s1 := NewServer("localhost")
 fmt.Printf("افتراضي: %s:%d (TLS: %v, MaxConns: %d)\n",
 s1.Host, s1.Port, s1.TLS, s1.MaxConns)

 // خادم مخصص — Custom server
 s2 := NewServer("api.example.com",
 WithPort(443),
 WithTLS(true),
 WithMaxConns(1000),
 WithTimeouts(60, 60),
 )
 fmt.Printf("مخصص: %s:%d (TLS: %v, MaxConns: %d)\n",
 s2.Host, s2.Port, s2.TLS, s2.MaxConns)
}

Output:

لماذا هذا النمط مميز:

أنماط قواعد البيانات

Mon, 01 Jan 0001 00:00:00 +0000

أنماط قواعد البيانات — Database Patterns

بعد تعلم الأساسيات، حان وقت الأنماط الاحترافية التي تُنظّم كودك وتجعله قابلاً للصيانة والاختبار.

نمط Repository

يفصل منطق الوصول للبيانات عن منطق الأعمال. بدلاً من كتابة SQL في كل مكان، تُغلّفه في طبقة واحدة:

main.go

package main

import (
 "errors"
 "fmt"
)

// النموذج — Model
type User struct {
 ID int
 Name string
 Email string
 Age int
}

// واجهة Repository — Repository interface
type UserRepository interface {
 Create(user *User) error
 GetByID(id int) (*User, error)
 GetAll() ([]User, error)
 Update(user *User) error
 Delete(id int) error
}

// تنفيذ في الذاكرة — In-memory implementation
type InMemoryUserRepo struct {
 users map[int]*User
 nextID int
}

func NewInMemoryUserRepo() *InMemoryUserRepo {
 return &InMemoryUserRepo{
 users: make(map[int]*User),
 nextID: 1,
 }
}

var ErrUserNotFound = errors.New("المستخدم غير موجود")

func (r *InMemoryUserRepo) Create(user *User) error {
 user.ID = r.nextID
 r.nextID++
 r.users[user.ID] = user
 return nil
}

func (r *InMemoryUserRepo) GetByID(id int) (*User, error) {
 user, ok := r.users[id]
 if !ok {
 return nil, ErrUserNotFound
 }
 return user, nil
}

func (r *InMemoryUserRepo) GetAll() ([]User, error) {
 result := make([]User, 0, len(r.users))
 for _, u := range r.users {
 result = append(result, *u)
 }
 return result, nil
}

func (r *InMemoryUserRepo) Update(user *User) error {
 if _, ok := r.users[user.ID]; !ok {
 return ErrUserNotFound
 }
 r.users[user.ID] = user
 return nil
}

func (r *InMemoryUserRepo) Delete(id int) error {
 if _, ok := r.users[id]; !ok {
 return ErrUserNotFound
 }
 delete(r.users, id)
 return nil
}

// خدمة الأعمال — Business service
type UserService struct {
 repo UserRepository
}

func (s *UserService) RegisterUser(name, email string, age int) (*User, error) {
 if name == "" || email == "" {
 return nil, fmt.Errorf("الاسم والبريد مطلوبان")
 }
 user := &User{Name: name, Email: email, Age: age}
 if err := s.repo.Create(user); err != nil {
 return nil, fmt.Errorf("فشل التسجيل: %w", err)
 }
 return user, nil
}

func main() {
 // إنشاء الطبقات — Create layers
 repo := NewInMemoryUserRepo()
 service := &UserService{repo: repo}

 // استخدام الخدمة — Use service
 u1, _ := service.RegisterUser("أحمد", "ahmed@example.com", 28)
 u2, _ := service.RegisterUser("فاطمة", "fatima@example.com", 24)
 fmt.Printf("تسجيل: %s (ID: %d)\n", u1.Name, u1.ID)
 fmt.Printf("تسجيل: %s (ID: %d)\n", u2.Name, u2.ID)

 // قراءة — Read
 user, err := repo.GetByID(1)
 if err != nil {
 fmt.Println("خطأ:", err)
 } else {
 fmt.Printf("البحث: %s — %s\n", user.Name, user.Email)
 }

 // قائمة — List
 all, _ := repo.GetAll()
 fmt.Printf("المجموع: %d مستخدمين\n", len(all))
}

Output:

لماذا Repository مهم:

أول برنامج — Hello World

Mon, 01 Jan 0001 00:00:00 +0000

أول برنامج — Hello World

كل مبرمج يبدأ رحلته بـ “Hello World” — وهذا التقليد بدأ مع لغة C عام 1978. لكن في AzLearn، سنكتب “مرحباً بالعالم” 🐹

البرنامج الكامل

main.go

package main

import "fmt"

// البرنامج الرئيسي — Main program
func main() {
 fmt.Println("مرحباً بالعالم! 🌍")
 fmt.Println("Hello, World!")
}

Output:

لنفهم كل سطر بالتفصيل:

اختبارات متقدمة

Mon, 01 Jan 0001 00:00:00 +0000

اختبارات متقدمة — Advanced Testing

بعد إتقان الأساسيات والاختبارات الجدولية، ننتقل لأدوات أقوى: قياس الأداء، محاكاة الاعتماديات، واختبار خوادم HTTP.

اختبارات الأداء — Benchmarks

main.go

package main

import "fmt"

func main() {
 fmt.Println(`// ملف: string_test.go
package main

import (
 "strings"
 "testing"
)

// اختبار أداء الربط — Benchmark concatenation
func BenchmarkConcat(b *testing.B) {
 for i := 0; i < b.N; i++ {
 s := ""
 for j := 0; j < 100; j++ {
 s += "x"
 }
 }
}

// اختبار أداء Builder — Benchmark Builder
func BenchmarkBuilder(b *testing.B) {
 for i := 0; i < b.N; i++ {
 var sb strings.Builder
 for j := 0; j < 100; j++ {
 sb.WriteString("x")
 }
 _ = sb.String()
 }
}`)

 fmt.Println("\n=== تشغيل Benchmarks ===")
 fmt.Println("go test -bench=. → كل الـ benchmarks")
 fmt.Println("go test -bench=BenchmarkConcat")
 fmt.Println("go test -bench=. -benchmem → مع إحصائيات الذاكرة")
 fmt.Println("go test -bench=. -count=5 → 5 مرات للدقة")

 fmt.Println("\n=== مثال الناتج ===")
 fmt.Println("BenchmarkConcat-8 10000 115000 ns/op 25208 B/op 99 allocs/op")
 fmt.Println("BenchmarkBuilder-8 200000 5200 ns/op 512 B/op 1 allocs/op")

 fmt.Println("\n💡 Builder أسرع 22 مرة وأقل ذاكرة 49 مرة!")
 fmt.Println("b.N يُحدد تلقائياً — Go يختار العدد المناسب")
}

Output:

الأنواع الوهمية — Mocks & Stubs

في Go، الواجهات تجعل المحاكاة سهلة جداً — لا تحتاج مكتبة خاصة:

الدوال

Mon, 01 Jan 0001 00:00:00 +0000

الدوال — Functions

الدوال هي اللبنة الأساسية لتنظيم الكود في Go. كل برنامج Go يبدأ بدالة main، لكنك ستكتب عشرات الدوال في أي مشروع حقيقي.

تعريف دالة بسيطة

func greet() {
 fmt.Println("مرحباً!")
}

دالة مع معاملات (Parameters)

func greet(name string) {
 fmt.Println("مرحباً يا", name)
}

إذا كانت المعاملات من نفس النوع، يمكنك اختصار الكتابة:

func add(a, b int) int { // a و b كلاهما int
 return a + b
}

دالة مع قيمة مُرجعة (Return Value)

main.go

package main

import "fmt"

// دالة الجمع — Add function
func add(a, b int) int {
 return a + b
}

// دالة التحية — Greet function
func greet(name string) string {
 return "مرحباً يا " + name + "! 👋"
}

// دالة المساحة — Area of rectangle
func area(width, height float64) float64 {
 return width * height
}

func main() {
 result := add(15, 27)
 fmt.Println("15 + 27 =", result)
 
 msg := greet("عزيز")
 fmt.Println(msg)
 
 a := area(5.5, 3.2)
 fmt.Printf("المساحة: %.2f\n", a)
}

Output:

الإرجاع المتعدد (Multiple Returns)

هذه من أقوى ميزات Go — الدالة يمكنها إرجاع عدة قيم. يُستخدم كثيراً لإرجاع نتيجة + خطأ:

النشر والإنتاج

Mon, 01 Jan 0001 00:00:00 +0000

النشر والإنتاج — Deployment

هذا الدرس الأخير يجمع كل شيء — كيف تأخذ تطبيق Go من جهازك إلى الإنتاج بشكل موثوق ومُراقب.

CI/CD مع GitHub Actions

main.go

package main

import "fmt"

func main() {
 fmt.Println(`# .github/workflows/deploy.yml
name: Build & Deploy

on:
 push:
 branches: [main]
 pull_request:
 branches: [main]

jobs:
 test:
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v4
 - uses: actions/setup-go@v5
 with:
 go-version: '1.22'

 - name: تنزيل الاعتماديات
 run: go mod download

 - name: الاختبارات مع كشف السباق
 run: go test -race -v ./...

 - name: التغطية
 run: go test -coverprofile=coverage.out ./...

 - name: الفحص الثابت
 uses: golangci/golangci-lint-action@v4

 build:
 needs: test
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v4
 - name: بناء صورة Docker
 run: docker build -t myapp:${{ github.sha }} .

 - name: نشر
 if: github.ref == 'refs/heads/main'
 run: |
 docker tag myapp:${{ github.sha }} registry.example.com/myapp:latest
 docker push registry.example.com/myapp:latest`)
}

Output:

Makefile للمشروع

main.go

package main

import "fmt"

func main() {
 fmt.Println(`# Makefile
.PHONY: build test run lint clean

# البناء — Build
build:
	CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/server ./cmd/server

# الاختبارات — Test
test:
	go test -race -cover ./...

# التشغيل — Run
run:
	go run ./cmd/server

# الفحص الثابت — Lint
lint:
	golangci-lint run

# التنظيف — Clean
clean:
	rm -rf bin/

# Docker
docker-build:
	docker build -t myapp .

docker-run:
	docker compose up -d`)

 fmt.Println("\n=== الاستخدام ===")
 fmt.Println("make build → بناء الملف التنفيذي")
 fmt.Println("make test → تشغيل الاختبارات")
 fmt.Println("make lint → فحص الكود")
 fmt.Println("make run → تشغيل محلي")
}

Output:

الإيقاف اللطيف — Graceful Shutdown

عند إيقاف الخادم، يجب إنهاء الطلبات الحالية قبل الإغلاق:

الهياكل

Mon, 01 Jan 0001 00:00:00 +0000

الهياكل — Structs

الهيكل (Struct) هو نوع بيانات مركّب يجمع عدة حقول (fields) في وحدة واحدة. فكّر فيه كـ “class” مبسّطة — Go لا تحتوي على classes بالمعنى التقليدي.

تعريف هيكل

main.go

package main

import "fmt"

// تعريف هيكل — Define a struct
type Person struct {
 Name string
 Age int
 City string
 IsAdmin bool
}

func main() {
 // إنشاء — Create
 p1 := Person{
 Name: "عزيز",
 Age: 25,
 City: "المدينة المنورة",
 IsAdmin: true,
 }
 fmt.Println("الشخص:", p1)
 
 // الوصول للحقول — Access fields
 fmt.Println("الاسم:", p1.Name)
 fmt.Println("العمر:", p1.Age)
 
 // تعديل — Modify
 p1.Age = 26
 fmt.Println("العمر الجديد:", p1.Age)
 
 // إنشاء بالترتيب — Positional (غير مُستحسن)
 p2 := Person{"سارة", 30, "الرياض", false}
 fmt.Println("شخص ٢:", p2)
 
 // إنشاء جزئي — Partial (باقي الحقول = قيم صفرية)
 p3 := Person{Name: "أحمد"}
 fmt.Printf("شخص ٣: %+v\n", p3) // %+v يعرض أسماء الحقول
}

Output:

الطرق (Methods)

الطرق هي دوال مرتبطة بنوع معين. تُعرّف بإضافة مستقبِل (receiver) قبل اسم الدالة:

الواجهات الشائعة

Mon, 01 Jan 0001 00:00:00 +0000

الواجهات الشائعة — Common Interfaces

Go مبنية على واجهات صغيرة ومحددة. المكتبة القياسية مليئة بواجهات تُستخدم في كل مكان. فهم هذه الواجهات يجعلك تكتب كوداً أكثر احترافية ومتوافقاً مع النظام البيئي لـ Go.

واجهة fmt.Stringer

أي نوع يُنفّذ String() string يتحكم في كيفية طباعته:

main.go

package main

import "fmt"

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

// تنفيذ Stringer — Implement Stringer
func (a Account) String() string {
 return fmt.Sprintf("💰 %s: %.2f %s", a.Owner, a.Balance, a.Currency)
}

// لون — Color
type Color struct {
 R, G, B uint8
}

func (c Color) String() string {
 return fmt.Sprintf("#%02X%02X%02X", c.R, c.G, c.B)
}

func main() {
 acc := Account{Owner: "أحمد", Balance: 5420.50, Currency: "ريال"}
 fmt.Println(acc) // يستدعي String() تلقائياً

 red := Color{R: 255, G: 0, B: 0}
 fmt.Println("الأحمر:", red)

 gold := Color{R: 212, G: 168, B: 83}
 fmt.Println("الذهبي:", gold)
}

Output:

واجهة error

واجهة error هي أبسط واجهة في Go — أسلوب واحد فقط:

الوسيط

Mon, 01 Jan 0001 00:00:00 +0000

الوسيط — Middleware

الوسيط (Middleware) هو نمط يسمح لك بتنفيذ كود قبل وبعد المعالج الفعلي — مثل التسجيل، المصادقة، ضغط البيانات، وغيرها. في Go، الوسيط هو ببساطة دالة تأخذ http.Handler وتُرجع http.Handler.

مفهوم الوسيط

الفكرة بسيطة: كل طلب يمر عبر سلسلة من الدوال قبل أن يصل للمعالج النهائي:

الطلب → [تسجيل] → [مصادقة] → [CORS] → المعالج → الاستجابة

كتابة وسيط بسيط

main.go

package main

import (
 "fmt"
 "net/http"
 "time"
)

// وسيط التسجيل — Logging middleware
func loggingMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 start := time.Now()

 // تنفيذ المعالج التالي — Execute next handler
 next.ServeHTTP(w, r)

 // تسجيل بعد الانتهاء — Log after completion
 duration := time.Since(start)
 fmt.Printf("[%s] %s %s — %v\n",
 time.Now().Format("15:04:05"),
 r.Method,
 r.URL.Path,
 duration,
 )
 })
}

// وسيط الترويسات — Headers middleware
func headersMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 w.Header().Set("X-Server", "AzLearn/1.0")
 w.Header().Set("Content-Type", "application/json; charset=utf-8")
 next.ServeHTTP(w, r)
 })
}

// المعالج الفعلي — Actual handler
func helloHandler(w http.ResponseWriter, r *http.Request) {
 fmt.Fprint(w, `{"message": "أهلاً!"}`)
}

func main() {
 // سلسلة الوسيط — Middleware chain
 handler := loggingMiddleware(
 headersMiddleware(
 http.HandlerFunc(helloHandler),
 ),
 )

 fmt.Println("سلسلة الوسيط:")
 fmt.Println("الطلب → loggingMiddleware → headersMiddleware → helloHandler")
 fmt.Println("\nهذا هو نمط الوسيط في Go!")

 _ = handler
}

Output:

وسيط المصادقة — Authentication Middleware

main.go

package main

import (
 "fmt"
 "net/http"
 "strings"
)

// وسيط المصادقة — Auth middleware
func authMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 token := r.Header.Get("Authorization")

 if token == "" {
 http.Error(w, `{"error": "مطلوب رمز مصادقة"}`, http.StatusUnauthorized)
 return // مهم! لا تكمل — Important! Don't continue
 }

 if !strings.HasPrefix(token, "Bearer ") {
 http.Error(w, `{"error": "تنسيق رمز غير صالح"}`, http.StatusUnauthorized)
 return
 }

 // تحقق من الرمز — Validate token
 actualToken := strings.TrimPrefix(token, "Bearer ")
 if actualToken != "valid-token-123" {
 http.Error(w, `{"error": "رمز منتهي أو غير صالح"}`, http.StatusForbidden)
 return
 }

 // المصادقة ناجحة — Auth successful
 next.ServeHTTP(w, r)
 })
}

func main() {
 // محاكاة فحص المصادقة — Simulate auth check
 tokens := []string{
 "",
 "InvalidFormat",
 "Bearer wrong-token",
 "Bearer valid-token-123",
 }

 for _, token := range tokens {
 if token == "" {
 fmt.Println("❌ بدون رمز → 401 غير مصرح")
 } else if !strings.HasPrefix(token, "Bearer ") {
 fmt.Println("❌ تنسيق خاطئ → 401 غير مصرح")
 } else if strings.TrimPrefix(token, "Bearer ") != "valid-token-123" {
 fmt.Println("❌ رمز خاطئ → 403 ممنوع")
 } else {
 fmt.Println("✅ مصادقة ناجحة → 200")
 }
 }
}

Output:

وسيط CORS

main.go

package main

import (
 "fmt"
 "net/http"
)

// وسيط CORS — CORS middleware
func corsMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 // ضبط ترويسات CORS — Set CORS headers
 w.Header().Set("Access-Control-Allow-Origin", "*")
 w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
 w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
 w.Header().Set("Access-Control-Max-Age", "86400")

 // طلبات OPTIONS (preflight) — Handle preflight
 if r.Method == "OPTIONS" {
 w.WriteHeader(http.StatusNoContent) // 204
 return
 }

 next.ServeHTTP(w, r)
 })
}

func main() {
 fmt.Println("ترويسات CORS:")
 fmt.Println("Access-Control-Allow-Origin: *")
 fmt.Println("Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS")
 fmt.Println("Access-Control-Allow-Headers: Content-Type, Authorization")
 fmt.Println("\nطلب OPTIONS → 204 No Content (بدون جسم)")
 fmt.Println("طلب GET/POST → يكمل للمعالج التالي مع ترويسات CORS")

 _ = corsMiddleware
}

Output:

سلسلة الوسيط — Middleware Chaining

بدلاً من التداخل العميق، يمكنك إنشاء دالة مساعدة:

عبارة Select

Mon, 01 Jan 0001 00:00:00 +0000

عبارة Select — Select Statement

select هي مثل switch لكن للقنوات. تنتظر عدة عمليات قنوات وتُنفّذ أول واحدة تكون جاهزة. هذا يجعلك تتعامل مع عدة مصادر بيانات متزامنة بأناقة.

select الأساسية

main.go

package main

import (
 "fmt"
 "time"
)

func main() {
 ch1 := make(chan string)
 ch2 := make(chan string)

 // goroutine بطيء — Slow goroutine
 go func() {
 time.Sleep(200 * time.Millisecond)
 ch1 <- "من القناة الأولى"
 }()

 // goroutine سريع — Fast goroutine
 go func() {
 time.Sleep(100 * time.Millisecond)
 ch2 <- "من القناة الثانية"
 }()

 // select تختار أول قناة جاهزة
 // select picks the first ready channel
 for i := 0; i < 2; i++ {
 select {
 case msg := <-ch1:
 fmt.Println("ch1:", msg)
 case msg := <-ch2:
 fmt.Println("ch2:", msg)
 }
 }
}

Output:

المهل الزمنية — Timeouts

من أهم استخدامات select — تحديد وقت أقصى للانتظار:

التحكم في التدفق

Mon, 01 Jan 0001 00:00:00 +0000

التحكم في التدفق — Control Flow

Go تمتلك أدوات تحكم بسيطة وقوية. لا يوجد while ولا do-while — حلقة for تغطي كل شيء!

if / else

لا تحتاج أقواساً حول الشرط (على عكس C وJava):

main.go

package main

import "fmt"

func main() {
 age := 20
 
 // شرط بسيط — Simple condition
 if age >= 18 {
 fmt.Println("بالغ ✅")
 } else {
 fmt.Println("قاصر ❌")
 }
 
 // if-else if-else
 score := 85
 if score >= 90 {
 fmt.Println("ممتاز 🌟")
 } else if score >= 80 {
 fmt.Println("جيد جداً 👍")
 } else if score >= 70 {
 fmt.Println("جيد")
 } else {
 fmt.Println("يحتاج تحسين")
 }
 
 // if مع تعريف متغير — if with init statement (ميزة مميزة!)
 if x := 10 * 2; x > 15 {
 fmt.Println("x =", x, "وهو أكبر من 15")
 }
 // x غير موجود هنا — x is not accessible here
}

Output:

ميزة Go الفريدة: يمكنك تعريف متغير داخل if — نطاقه محدود بالشرط فقط. هذا يُستخدم كثيراً مع معالجة الأخطاء.

حزمة sync

Mon, 01 Jan 0001 00:00:00 +0000

حزمة sync — Sync Package

القنوات هي الطريقة المفضلة للتزامن في Go، لكن أحياناً تحتاج أدوات منخفضة المستوى. حزمة sync توفر أقفال (mutexes) ومجموعات انتظار وغيرها.

سباق البيانات — Race Condition

قبل أن نتعلم الحلول، لنفهم المشكلة:

main.go

package main

import (
 "fmt"
 "sync"
)

func main() {
 // ❌ بدون حماية — سباق بيانات!
 // Without protection — data race!
 counter := 0
 var wg sync.WaitGroup

 for i := 0; i < 1000; i++ {
 wg.Add(1)
 go func() {
 defer wg.Done()
 counter++ // عدة goroutines تُعدّل نفس المتغير!
 }()
 }

 wg.Wait()
 fmt.Println("العدّاد (قد يكون خاطئاً):", counter)
 fmt.Println("المتوقع: 1000")
 fmt.Println("💡 في بيئة حقيقية، استخدم: go run -race main.go")
}

Output:

ملاحظة: في Go Playground قد تحصل على 1000 أحياناً لأن الجدولة تختلف. لكن على جهازك مع -race flag ستكتشف المشكلة.

AzLearn — منصة التعلّم من عزيز ويرز

Docker

Docker — حاويات Go

لماذا Go + Docker = ❤️

Dockerfile بسيط

شرح البناء المتعدد المراحل

Docker Compose

.dockerignore

أفضل ممارسات Docker + Go

إضافة مستخدم غير root

أساسيات HTTP

أساسيات HTTP — HTTP Basics

أبسط خادم HTTP

واجهة http.Handler

أساسيات SQL

أساسيات SQL — SQL Basics

بنية الحزمة

أساسيات الأخطاء

أساسيات الأخطاء — Error Basics

واجهة error

أساسيات الاختبار

أساسيات الاختبار — Testing Basics

القواعد الأساسية

ملف الاختبار الحقيقي

الأساليب

الأساليب — Methods

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

السياق

السياق — Context

لماذا Context؟

أنواع Context

الإلغاء — Cancellation

WithValue — تمرير بيانات

الغوروتينات

الغوروتينات — Goroutines

ما هي الـ goroutine؟

كلمة go

المتغيرات والثوابت

المتغيرات والثوابت — Variables & Constants

تعريف المتغيرات بـ var

المصفوفات والشرائح

المصفوفات والشرائح — Arrays & Slices

المصفوفات (Arrays)

الوحدات

الوحدات — Modules

ما هي الوحدة؟

إنشاء وحدة جديدة

مسار الوحدة — Module Path

بناء أداة CLI

بناء أداة CLI — Building a CLI Tool

os.Args — المعاملات البسيطة

حزمة flag — خيارات متقدمة

ما هي لغة Go؟

ما هي لغة Go؟ — What is Go?

القصة وراء Go

أنماط الأخطاء المتقدمة

أنماط الأخطاء المتقدمة — Advanced Error Patterns

الأخطاء الحارسة — Sentinel Errors

أنواع أخطاء مخصصة — Custom Error Types

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

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

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

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

الأنواع المعممة

الأنواع المعممة — Generics

المشكلة بدون Generics

الحل مع Generics

القيود — Constraints

الاختبارات الجدولية

الاختبارات الجدولية — Table-Driven Tests

لماذا الاختبارات الجدولية؟

مثال كامل

الاختبارات الفرعية — Subtests مع t.Run

التسجيل المهيكل

التسجيل المهيكل — Structured Logging

المشكلة مع التسجيل العادي

أساسيات slog

مستويات التسجيل — Log Levels

المجموعات والسمات — Groups & Attributes

معرّف الطلب — Request ID / Correlation ID

تعريف المتغيرات بـ `var`