أساسيات Git و GitHub للمطورين: التحكم في الإصدارات والعمل الجماعي بكفاءة

مقدمة في Git و GitHub

في عالم تطوير البرمجيات الحديث، يعد نظام التحكم في الإصدارات Git أداة لا غنى عنها لكل مطور. سواء كنت تعمل بمفردك على مشروع شخصي أو ضمن فريق يضم عشرات المطورين، فإن Git يوفر لك القدرة على تتبع كل تغيير في الكود المصدري، والعودة إلى أي نقطة في تاريخ المشروع، والعمل على ميزات متعددة بشكل متوازٍ دون تعارض.

GitHub هو المنصة السحابية الأكثر شعبية لاستضافة مستودعات Git، حيث يستخدمه أكثر من 100 مليون مطور حول العالم. يوفر GitHub أدوات متقدمة للتعاون مثل Pull Requests و Issues و Actions للتكامل المستمر.

تثبيت وإعداد Git

التثبيت على أنظمة التشغيل المختلفة

قبل البدء باستخدام Git، تحتاج إلى تثبيته على جهازك. إليك طرق التثبيت على الأنظمة المختلفة:

# التثبيت على Ubuntu/Debian
sudo apt update
sudo apt install git

# التثبيت على CentOS/RHEL
sudo yum install git

# التثبيت على macOS باستخدام Homebrew
brew install git

# التحقق من التثبيت
git --version

الإعداد الأولي

بعد التثبيت، يجب إعداد معلوماتك الشخصية التي ستُستخدم في كل commit:

# إعداد اسم المستخدم
git config --global user.name "اسمك الكامل"

# إعداد البريد الإلكتروني
git config --global user.email "your.email@example.com"

# إعداد المحرر الافتراضي
git config --global core.editor "code --wait"

# تفعيل الألوان في الطرفية
git config --global color.ui auto

# عرض جميع الإعدادات
git config --list

المفاهيم الأساسية في Git

مناطق العمل الثلاث

يعمل Git بنظام ثلاث مناطق أساسية يجب فهمها جيداً:

• Working Directory (مجلد العمل): المكان الذي تعدّل فيه الملفات فعلياً على جهازك. هنا تكتب الكود وتجري التغييرات.
• Staging Area (منطقة التجهيز): المنطقة الوسيطة حيث تجمّع التغييرات التي تريد تضمينها في الـ commit القادم. تُعرف أيضاً بـ Index.
• Repository (المستودع): قاعدة البيانات التي تخزّن تاريخ جميع التغييرات. تنقسم إلى المستودع المحلي (Local) والبعيد (Remote).

إنشاء مستودع جديد

# إنشاء مجلد جديد وتهيئته كمستودع Git
mkdir my-project
cd my-project
git init

# أو استنساخ مستودع موجود
git clone https://github.com/username/repository.git

# استنساخ فرع محدد
git clone -b develop https://github.com/username/repository.git

العمليات الأساسية في Git

تتبع الملفات وإنشاء Commits

الـ commit هو لقطة من حالة المشروع في لحظة معينة. كل commit يحتوي على رسالة توضيحية تصف التغييرات:

# عرض حالة المستودع
git status

# إضافة ملف محدد إلى منطقة التجهيز
git add filename.js

# إضافة جميع الملفات المعدّلة
git add .

# إضافة ملفات بنمط محدد
git add "*.css"
git add src/

# إنشاء commit مع رسالة
git commit -m "إضافة ميزة تسجيل الدخول"

# إضافة وعمل commit في خطوة واحدة
git commit -am "تحديث ملفات CSS"

# تعديل آخر commit
git commit --amend -m "رسالة جديدة"

عرض سجل التغييرات

# عرض سجل الـ commits
git log

# عرض مختصر
git log --oneline

# عرض بياني للفروع
git log --oneline --graph --all

# عرض تغييرات commit محدد
git show abc1234

# عرض الفرق بين الملفات
git diff
git diff --staged
git diff branch1..branch2

إدارة الفروع (Branches)

تُعد الفروع من أقوى ميزات Git، حيث تسمح لك بالعمل على ميزات مختلفة بشكل مستقل دون التأثير على الكود الرئيسي:

إنشاء وإدارة الفروع

# عرض الفروع الموجودة
git branch
git branch -a  # عرض الفروع المحلية والبعيدة

# إنشاء فرع جديد
git branch feature-login

# الانتقال إلى فرع
git checkout feature-login

# إنشاء فرع والانتقال إليه مباشرة
git checkout -b feature-login
# أو بالأمر الأحدث
git switch -c feature-login

# حذف فرع
git branch -d feature-login
git branch -D feature-login  # حذف إجباري

دمج الفروع (Merge)

بعد الانتهاء من العمل على ميزة في فرع منفصل، تحتاج إلى دمجها مع الفرع الرئيسي:

# الانتقال إلى الفرع الرئيسي
git checkout main

# دمج فرع الميزة
git merge feature-login

# دمج مع رسالة مخصصة
git merge feature-login -m "دمج ميزة تسجيل الدخول"

# في حالة وجود تعارضات
# 1. افتح الملفات المتعارضة وعدّلها
# 2. أضف الملفات بعد حل التعارض
git add .
# 3. أكمل عملية الدمج
git commit -m "حل تعارضات الدمج"

استراتيجية Rebase

Rebase هو بديل للـ merge يعيد كتابة تاريخ الـ commits للحصول على تاريخ خطي ونظيف:

# إعادة بناء الفرع الحالي على آخر commit في main
git rebase main

# Rebase تفاعلي لتعديل عدة commits
git rebase -i HEAD~3

# في الـ rebase التفاعلي يمكنك:
# pick - الإبقاء على commit
# squash - دمج مع commit السابق
# reword - تغيير رسالة commit
# drop - حذف commit

العمل مع GitHub

ربط المستودع المحلي بـ GitHub

# إضافة مستودع بعيد
git remote add origin https://github.com/username/repo.git

# عرض المستودعات البعيدة
git remote -v

# رفع التغييرات
git push -u origin main

# تحديث المستودع المحلي
git pull origin main

# جلب التحديثات دون دمج
git fetch origin

العمل مع Pull Requests

تُعد Pull Requests الطريقة المثلى للتعاون في GitHub. إليك سير العمل الكامل:

• Fork المشروع: أنشئ نسخة من المستودع في حسابك على GitHub
• Clone النسخة: استنسخ النسخة محلياً باستخدام git clone
• إنشاء فرع: أنشئ فرعاً جديداً للميزة أو الإصلاح
• العمل والـ Commit: أجرِ التغييرات وأنشئ commits واضحة الرسائل
• Push: ارفع الفرع إلى نسختك على GitHub
• إنشاء PR: افتح Pull Request من واجهة GitHub مع وصف تفصيلي
• المراجعة: انتظر مراجعة الفريق وعالج أي ملاحظات
• الدمج: بعد الموافقة، يتم دمج التغييرات في الفرع الرئيسي

ملف .gitignore

ملف .gitignore يحدد الملفات والمجلدات التي يجب أن يتجاهلها Git:

# ملفات البيئة والأسرار
.env
.env.local
.env.production

# مجلدات التبعيات
node_modules/
vendor/

# ملفات البناء
dist/
build/
*.min.js
*.min.css

# ملفات النظام
.DS_Store
Thumbs.db
*.swp
*.swo

# ملفات المحرر
.vscode/
.idea/
*.sublime-project

# ملفات السجلات
*.log
logs/

Git Stash: حفظ التغييرات المؤقتة

عندما تحتاج للانتقال إلى فرع آخر دون عمل commit للتغييرات الحالية:

# حفظ التغييرات مؤقتاً
git stash

# حفظ مع رسالة وصفية
git stash save "تعديلات صفحة الدفع"

# عرض قائمة المحفوظات
git stash list

# استعادة آخر تغييرات محفوظة
git stash pop

# استعادة تغييرات محددة
git stash apply stash@{2}

# حذف جميع المحفوظات
git stash clear

التراجع عن التغييرات

من أهم مزايا Git هي القدرة على التراجع عن أي تغيير بسهولة:

# التراجع عن تغييرات ملف في مجلد العمل
git checkout -- filename.js
git restore filename.js  # الأمر الأحدث

# إزالة ملف من منطقة التجهيز
git reset HEAD filename.js
git restore --staged filename.js

# التراجع عن commit مع الحفاظ على التغييرات
git reset --soft HEAD~1

# التراجع عن commit وإزالة التغييرات
git reset --hard HEAD~1

# إنشاء commit عكسي
git revert abc1234

GitHub Actions: التكامل المستمر

GitHub Actions يسمح لك بأتمتة عمليات البناء والاختبار والنشر. إليك مثال لملف workflow:

# .github/workflows/ci.yml
name: CI Pipeline

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

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20
      - name: Install dependencies
        run: npm ci
      - name: Run tests
        run: npm test
      - name: Run linter
        run: npm run lint

أفضل الممارسات لرسائل Commit

كتابة رسائل commit واضحة ومنظمة أمر بالغ الأهمية للتعاون الفعّال:

• feat: لإضافة ميزة جديدة – مثال: feat: إضافة نظام المصادقة بالرموز JWT
• fix: لإصلاح خطأ – مثال: fix: إصلاح مشكلة تحويل العملات
• docs: لتحديث التوثيق – مثال: docs: تحديث دليل التثبيت
• style: لتغييرات التنسيق – مثال: style: تنسيق ملفات CSS
• refactor: لإعادة هيكلة الكود – مثال: refactor: تبسيط منطق المصادقة
• test: لإضافة اختبارات – مثال: test: إضافة اختبارات وحدة للـ API
• chore: لمهام الصيانة – مثال: chore: تحديث تبعيات المشروع

سيناريوهات عملية شائعة

السيناريو 1: حل تعارضات الدمج

عندما يعدّل مطوران نفس الملف في فروع مختلفة، ينشأ تعارض عند الدمج. إليك كيفية التعامل:

# عند ظهور تعارض أثناء الدمج
# افتح الملف المتعارض وستجد:
<<<<<<< HEAD
// الكود في الفرع الحالي
const greeting = "مرحباً";
=======
// الكود في الفرع المدمج
const greeting = "أهلاً وسهلاً";
>>>>>>> feature-branch

# اختر الكود المناسب أو ادمجهما
const greeting = "مرحباً وأهلاً";

# بعد حل التعارض
git add .
git commit -m "حل تعارض في ملف greeting"

السيناريو 2: العمل مع مشاريع مفتوحة المصدر

# 1. Fork المشروع من GitHub
# 2. استنساخ نسختك
git clone https://github.com/your-username/project.git

# 3. إضافة المستودع الأصلي كـ upstream
git remote add upstream https://github.com/original/project.git

# 4. مزامنة نسختك مع الأصلي
git fetch upstream
git checkout main
git merge upstream/main

# 5. إنشاء فرع للمساهمة
git checkout -b fix/typo-in-readme

# 6. بعد التعديل، الرفع وإنشاء PR
git push origin fix/typo-in-readme

أدوات وإضافات مفيدة

• VS Code GitLens: إضافة قوية تعرض تاريخ التغييرات داخل المحرر مع معلومات عن كل سطر
• GitHub Desktop: واجهة رسومية سهلة الاستخدام لإدارة مستودعات Git بدون سطر الأوامر
• Git Kraken: أداة رسومية متقدمة لتصور الفروع والتاريخ بشكل بصري جذاب
• Conventional Commits: معيار لكتابة رسائل commit منظمة يسهل قراءتها وأتمتتها
• Husky: أداة لتشغيل scripts تلقائياً قبل كل commit لضمان جودة الكود

Git Tags: إدارة الإصدارات

تُستخدم العلامات (Tags) في Git لتحديد نقاط مهمة في تاريخ المشروع، وخاصة لتحديد إصدارات البرنامج. هناك نوعان من العلامات: العلامات الخفيفة (Lightweight) والعلامات الموضحة (Annotated) التي تحتوي على معلومات إضافية مثل اسم المنشئ وتاريخ الإنشاء ورسالة توضيحية.

# إنشاء علامة موضحة (Annotated Tag)
git tag -a v1.0.0 -m "الإصدار الأول المستقر"

# إنشاء علامة خفيفة (Lightweight Tag)
git tag v1.0.1

# عرض جميع العلامات
git tag
git tag -l "v1.*"  # تصفية بنمط محدد

# عرض تفاصيل علامة
git show v1.0.0

# رفع علامة إلى GitHub
git push origin v1.0.0

# رفع جميع العلامات
git push origin --tags

# حذف علامة محلياً وبعيداً
git tag -d v1.0.1
git push origin --delete v1.0.1

نظام الإصدارات الدلالي (Semantic Versioning)

يتبع معظم المشاريع نظام SemVer بصيغة MAJOR.MINOR.PATCH حيث يشير MAJOR إلى تغييرات غير متوافقة مع الإصدارات السابقة، و MINOR لإضافة ميزات جديدة متوافقة، و PATCH لإصلاحات الأخطاء. على سبيل المثال، الانتقال من v1.2.3 إلى v2.0.0 يعني وجود تغييرات جذرية في واجهة البرنامج.

Git Submodules: إدارة المشاريع المعقدة

عندما يعتمد مشروعك على مكتبات أو مشاريع فرعية أخرى، يمكنك استخدام Submodules لتضمينها كمستودعات مستقلة داخل مشروعك الرئيسي. هذا يسمح لك بتتبع إصدارات محددة من المكتبات الخارجية دون نسخ كودها مباشرة:

# إضافة submodule
git submodule add https://github.com/lib/useful-lib.git libs/useful-lib

# استنساخ مشروع يحتوي على submodules
git clone --recurse-submodules https://github.com/user/project.git

# تحديث submodules بعد الاستنساخ
git submodule update --init --recursive

# تحديث submodule لآخر إصدار
cd libs/useful-lib
git pull origin main
cd ../..
git add libs/useful-lib
git commit -m "تحديث المكتبة الفرعية"

Git Hooks: أتمتة سير العمل

توفر Git Hooks طريقة لتشغيل scripts تلقائياً عند حدوث أحداث معينة في Git. هذا مفيد لفرض معايير جودة الكود وأتمتة المهام المتكررة:

# تثبيت Husky لإدارة Git Hooks بسهولة
npm install --save-dev husky
npx husky install

# إضافة hook لما قبل الـ commit
npx husky add .husky/pre-commit "npm run lint"

# إضافة hook لما قبل الـ push
npx husky add .husky/pre-push "npm test"

# مثال لملف pre-commit يدوي
# .git/hooks/pre-commit
#!/bin/sh
echo "فحص الكود قبل الحفظ..."
npm run lint
if [ $? -ne 0 ]; then
  echo "فشل فحص الكود! أصلح الأخطاء قبل الحفظ."
  exit 1
fi

استراتيجيات Git Flow للفرق

تحدد Git Flow نموذجاً واضحاً لإدارة الفروع في المشاريع الاحترافية. يعتمد هذا النموذج على فروع رئيسية ثابتة وفروع مؤقتة للعمل:

• main/master: يحتوي دائماً على الكود الجاهز للإنتاج. لا يتم العمل المباشر عليه أبداً، بل يُدمج فيه فقط من فروع release أو hotfix
• develop: فرع التطوير الرئيسي الذي يجمع جميع الميزات الجديدة. يُنشأ منه فروع الميزات ويُدمج فيها عند اكتمالها
• feature/*: فروع مؤقتة لتطوير ميزات جديدة. كل ميزة لها فرع مستقل يُنشأ من develop ويُدمج فيه عند الاكتمال
• release/*: فروع التحضير للإصدار حيث يتم إجراء الاختبارات النهائية وإصلاح الأخطاء الطفيفة قبل النشر
• hotfix/*: فروع الإصلاحات العاجلة للأخطاء الحرجة في الإنتاج. تُنشأ من main وتُدمج في كل من main و develop

# تهيئة Git Flow
git flow init

# بدء ميزة جديدة
git flow feature start user-authentication

# إنهاء الميزة ودمجها في develop
git flow feature finish user-authentication

# بدء إصدار جديد
git flow release start 1.0.0

# إنهاء الإصدار
git flow release finish 1.0.0

# إصلاح عاجل
git flow hotfix start fix-login-bug
git flow hotfix finish fix-login-bug

أمان المستودعات على GitHub

حماية مستودعك على GitHub أمر بالغ الأهمية، خاصة للمشاريع التجارية والفرق الكبيرة:

• حماية الفروع (Branch Protection Rules): فرض مراجعة الكود قبل الدمج، ومنع الـ force push على الفروع الرئيسية، واشتراط نجاح اختبارات CI قبل السماح بالدمج
• المصادقة الثنائية (2FA): تفعيل المصادقة بخطوتين لجميع أعضاء الفريق لمنع الوصول غير المصرح به
• SSH Keys: استخدام مفاتيح SSH بدلاً من كلمات المرور للمصادقة الآمنة مع GitHub
• Dependabot: تفعيل التحديثات التلقائية للتبعيات لسد الثغرات الأمنية
• Secret Scanning: الكشف التلقائي عن المفاتيح والأسرار المسربة في الكود

# إنشاء مفتاح SSH
ssh-keygen -t ed25519 -C "your.email@example.com"

# إضافة المفتاح إلى SSH Agent
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# نسخ المفتاح العام لإضافته إلى GitHub
cat ~/.ssh/id_ed25519.pub

# اختبار الاتصال
ssh -T git@github.com

مشروع تطبيقي: بناء سير عمل كامل

لنطبق كل ما تعلمناه في مشروع حقيقي لبناء تطبيق ويب مع سير عمل احترافي:

# 1. إنشاء المشروع
mkdir my-web-app && cd my-web-app
git init
npm init -y

# 2. إنشاء الهيكل الأساسي
mkdir -p src/{css,js,components} tests
touch src/index.html src/css/style.css src/js/app.js
touch .gitignore README.md

# 3. إعداد .gitignore
echo "node_modules/
dist/
.env
*.log" > .gitignore

# 4. الـ commit الأول
git add .
git commit -m "chore: تهيئة المشروع"

# 5. إنشاء مستودع على GitHub وربطه
git remote add origin git@github.com:user/my-web-app.git
git push -u origin main

# 6. إنشاء فرع develop
git checkout -b develop
git push -u origin develop

# 7. بدء العمل على ميزة
git checkout -b feature/responsive-nav
# ... العمل على الكود ...
git add .
git commit -m "feat: إضافة شريط تنقل متجاوب"
git push origin feature/responsive-nav

# 8. إنشاء Pull Request على GitHub ومراجعة الكود

ملخص المهارات المكتسبة

• تثبيت وإعداد Git على جميع أنظمة التشغيل
• فهم مناطق العمل الثلاث في Git والتنقل بينها
• إتقان العمليات الأساسية: add, commit, push, pull
• إنشاء وإدارة الفروع واستراتيجيات الدمج
• العمل مع GitHub والتعاون عبر Pull Requests
• استخدام Git Stash والتراجع عن التغييرات
• إعداد GitHub Actions للتكامل المستمر
• اتباع أفضل ممارسات رسائل Commit
• حل تعارضات الدمج والمساهمة في المشاريع المفتوحة

الخطوة التالية

بعد إتقان أساسيات Git و GitHub، انتقل إلى تعلم Git Flow كاستراتيجية متقدمة لإدارة الفروع في المشاريع الكبيرة، واستكشف GitHub Actions بعمق لأتمتة عمليات CI/CD الكاملة من الاختبار إلى النشر التلقائي. ابدأ بالمساهمة في مشاريع مفتوحة المصدر لتطبيق ما تعلمته في بيئة حقيقية.