Git و GitHub

فهم بنية Git

13 دقيقة الدرس 3 من 35

فهم بنية Git

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

الحالات الثلاث لـ Git

لدى Git ثلاث حالات رئيسية يمكن أن تكون ملفاتك فيها:

1. معدل (مجلد العمل)
لقد غيرت الملفات ولكن لم تلتزم بها بعد.
الملفات في مجلد عملك ولكن غير متتبعة.

2. مرحلي (منطقة التدريج / الفهرس)
لقد وسمت الملفات المعدلة للذهاب إلى التزامك التالي.
الملفات جاهزة للالتزام.

3. ملتزم (المستودع / مجلد .git)
البيانات محفوظة بأمان في قاعدة بياناتك المحلية.
الملفات محفوظة بشكل دائم في تاريخ Git.

سير عمل Git:

[مجلد العمل] → git add → [منطقة التدريج] → git commit → [المستودع]
     (معدل)                     (مرحلي)                   (ملتزم)

مثال:
1. تحرير file.txt (معدل)
2. git add file.txt (مرحلي)
3. git commit -m "Update file" (ملتزم)

مفهوم رئيسي: منطقة التدريج (تسمى أيضاً "الفهرس") هي ما يجعل Git فريدة. تسمح لك بإعداد التزامك بعناية عن طريق اختيار التغييرات التي تريد تضمينها بالضبط.

الأقسام الرئيسية الثلاثة

1. مجلد العمل

ما هو:
• نسخة واحدة من إصدار واحد من المشروع
• ملفات مستخرجة من قاعدة البيانات المضغوطة في .git
• الملفات الفعلية التي تراها وتحررها على جهازك

الموقع:
مجلد مشروعك (مثل: /Users/john/my-project/)

الغرض:
حيث تجري تغييرات على ملفاتك

2. منطقة التدريج (الفهرس)

ما هي:
• ملف (محفوظ في .git/index)
• تخزن معلومات حول ما سيدخل في التزامك التالي
• تسمى أيضاً "الفهرس"

الغرض:
• تتيح لك إعداد الالتزامات بعناية
• يمكنك تدريج بعض التغييرات مع ترك الأخرى غير مدرجة
• تسمح بالتزامات ذرية ومنطقية

مثال:
قمت بتعديل 5 ملفات ولكن تريد فقط الالتزام بـ 3:
git add file1.txt file2.txt file3.txt
(file4.txt و file5.txt تبقى غير مدرجة)

3. المستودع (مجلد .git)

ما هو:
• حيث تخزن Git البيانات الوصفية وقاعدة بيانات الكائنات
• موجود في مجلد .git في جذر مشروعك
• يحتوي على تاريخ مشروعك الكامل

الموقع:
مجلد .git/ (مجلد مخفي)

الغرض:
• تخزين دائم لجميع الالتزامات
• تاريخ المشروع الكامل
• الفروع، الوسوم، التكوين

مهم: لا تحرر أبداً الملفات يدوياً في مجلد .git ما لم تكن تعرف بالضبط ما تفعله. Git تدير هذا المجلد تلقائياً.

داخل مجلد .git

لنستكشف بنية مجلد .git:

.git/
├── HEAD                  # يشير إلى الفرع الحالي
├── config               # تكوين خاص بالمستودع
├── description          # وصف المستودع (لـ GitWeb)
├── index                # منطقة التدريج
├── hooks/               # خطافات جانب العميل والخادم
├── info/                # ملف الاستبعاد العام
├── objects/             # قاعدة بيانات الكائنات (الالتزامات، الأشجار، النقط)
│   ├── pack/           # كائنات معبأة للكفاءة
│   └── info/           # معلومات قاعدة بيانات الكائنات
├── refs/                # المراجع (الفروع والوسوم)
│   ├── heads/          # الفروع المحلية
│   ├── remotes/        # الفروع البعيدة
│   └── tags/           # الوسوم
└── logs/                # تاريخ تحديثات المرجع

الملفات والمجلدات الرئيسية:

HEAD:
يشير إلى الفرع الحالي الذي أنت عليه.
محتوى المثال: ref: refs/heads/main

config:
إعدادات تكوين خاصة بالمستودع.
تجاوز تكوين Git العام لهذا المستودع.

objects/:
قاعدة بيانات الكائنات - حيث تخزن Git كل المحتوى.
يحتوي على نقط، أشجار، التزامات، ووسوم.

refs/:
مراجع للالتزامات (الفروع والوسوم).
refs/heads/ يحتوي على فروع محلية.
refs/remotes/ يحتوي على فروع تتبع بعيدة.

index:
منطقة التدريج (ملف ثنائي).

كائنات Git: كيف تخزن Git البيانات

تخزن Git كل المحتوى ككائنات. هناك أربعة أنواع من الكائنات:

1. النقطة (كائن ثنائي كبير)

ما تخزنه:
• محتوى الملف (البيانات الفعلية في ملفاتك)
• لا يوجد اسم ملف، لا يوجد بنية مجلد
• فقط محتوى نقي

مثال:
إذا كان لديك ملف "hello.txt" بمحتوى "Hello, World!"
Git تنشئ كائن نقطة يحتوي على "Hello, World!"
يتم تحديد النقطة بواسطة تجزئة SHA-1 الخاصة بها.

نقطة رئيسية:
إذا كان لملفين محتوى متطابق، Git تخزن نقطة واحدة فقط.

2. الشجرة

ما تخزنه:
• بنية المجلد
• مراجع للنقط (الملفات) وأشجار أخرى (مجلدات فرعية)
• أسماء الملفات والأذونات

مثال:
project/
├── README.md (blob: abc123)
└── src/
    └── main.js (blob: def456)

كائن الشجرة يحتوي على:
- README.md → blob abc123
- src → tree xyz789

3. الالتزام

ما يخزنه:
• مرجع لكائن شجرة (لقطة المشروع)
• اسم وبريد المؤلف
• اسم وبريد الملتزم
• رسالة الالتزام
• مرجع الالتزام الأصل
• الطابع الزمني

مثال على كائن الالتزام:
tree abc123def456...         (لقطة المشروع)
parent 789xyz123...          (الالتزام السابق)
author John Doe <john@example.com> 1234567890 -0500
committer John Doe <john@example.com> 1234567890 -0500

رسالة الالتزام الأولية

4. الوسم (مشروح)

ما يخزنه:
• مرجع للالتزام
• اسم وبريد واضع الوسم
• رسالة الوسم
• اسم الوسم

يستخدم لوضع علامة على نقاط محددة في التاريخ (الإصدارات).

مهم: جميع كائنات Git غير قابلة للتغيير. بمجرد إنشائها، لا تتغير أبداً. هذا أساسي لنموذج سلامة البيانات في Git.

فهم تجزئات SHA-1

يتم تحديد كل كائن في Git بواسطة تجزئة SHA-1:

ما هي SHA-1؟
• خوارزمية التجزئة الآمنة 1
• تنتج سلسلة سداسية عشرية من 40 حرفاً
• تعمل كبصمة فريدة للمحتوى

مثال SHA-1:
a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0

الخصائص:
• نفس المحتوى ينتج دائماً نفس التجزئة
• محتوى مختلف ينتج تجزئة مختلفة (من المستحيل عملياً التصادم)
• حتى التغيير الصغير ينتج تجزئة مختلفة تماماً

مثال:
المحتوى: "Hello, World!"  → التجزئة: 8ab686ea...
المحتوى: "Hello, World."  → التجزئة: 9bc797fb...
(فرق حرف واحد، تجزئة مختلفة تماماً)

لماذا SHA-1 مهم:

1. سلامة البيانات:
   لا يمكنك تغيير المحتوى الملتزم به دون علم Git.

2. التحديد الفريد:
   كل التزام وملف وشجرة لها معرف فريد.

3. التخزين الفعال:
   يمكن لـ Git العثور بسرعة على الكائنات ومقارنتها.

4. معالجة المحتوى:
   Git تخزن المحتوى بناءً على تجزئته، وليس اسم الملف.

حقيقة ممتعة: Git تنتقل من SHA-1 إلى SHA-256 لأمان أفضل، لكن SHA-1 عملت بشكل رائع لأغراض Git.

كيف تخزن Git البيانات: اللقطات، وليس الدلتا

هنا تختلف Git بشكل أساسي عن أنظمة التحكم في الإصدارات الأخرى:

أنظمة التحكم التقليدية (على أساس الدلتا):
تخزن الاختلافات بين الإصدارات.

الملف V1: "Hello"
الملف V2: +", World"  (تخزن الفرق)
الملف V3: +"!"        (تخزن الفرق)

للحصول على V3، تحتاج: V1 + التغييرات إلى V2 + التغييرات إلى V3

Git (على أساس اللقطات):
تخزن لقطات كاملة لمشروعك.

الالتزام 1: لقطة كاملة (شجرة + نقط)
الالتزام 2: لقطة كاملة (شجرة + نقط)
الالتزام 3: لقطة كاملة (شجرة + نقط)

للحصول على أي إصدار: فقط اقرأ شجرة ذلك الالتزام.

لكن انتظر، أليس هذا مهدر؟

لا! Git ذكية:

1. الملفات غير المتغيرة:
   إذا لم يتغير ملف، Git لا تنشئ نقطة جديدة.
   فقط تشير إلى النقطة الموجودة.

2. ملفات الحزم:
   Git تضغط بشكل دوري الكائنات في ملفات الحزم.
   يتم تخزين المحتوى المشابه بكفاءة.

النتيجة:
• عمليات سريعة (لا حاجة لحساب الدلتا)
• تخزين فعال (لا يوجد محتوى مكرر)
• نموذج بسيط (اللقطات أسهل في الفهم)

رؤية رئيسية: نموذج اللقطة في Git يجعل العمليات مثل التفريع والدمج والتبديل سريعة للغاية لأنك فقط تحرك المؤشرات، وليس إعادة حساب الدلتا.

المراجع: HEAD، الفروع، والوسوم

HEAD

ما هو HEAD؟
• مؤشر إلى موقعك الحالي في المستودع
• عادة يشير إلى مرجع فرع
• يحدد ما تراه في مجلد عملك

محتوى .git/HEAD المثال:
ref: refs/heads/main

هذا يعني HEAD → فرع main → أحدث التزام على main

عندما تلتزم:
HEAD → الفرع الحالي → التزام جديد

الفروع

ما هي الفروع في Git؟
• فقط مؤشرات للالتزامات
• محفوظة في .git/refs/heads/
• خفيفة الوزن (فقط 41 بايت!)

مثال .git/refs/heads/main:
a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0

هذا فقط تجزئة SHA-1 للالتزام الذي يشير إليه الفرع.

إنشاء فرع:
فقط أنشئ ملفاً جديداً في refs/heads/ مع تجزئة التزام.
هذا كل شيء! لا نسخ للملفات أو التاريخ.

الوسوم

ما هي الوسوم؟
• مراجع لالتزامات محددة
• محفوظة في .git/refs/tags/
• على عكس الفروع، الوسوم لا تتحرك

الأنواع:
1. وسم خفيف: فقط مؤشر (مثل فرع لا يتحرك)
2. وسم مشروح: كائن كامل مع رسالة، واضع الوسم، تاريخ

يستخدم لـ:
وضع علامات على الإصدارات (v1.0.0، v2.1.3، إلخ)

نموذج سلامة البيانات في Git

ضمانات سلامة Git:

1. تجزئة كل شيء:
   كل ملف والتزام يتم تجزئته قبل التخزين.
   لا يمكنك تغيير المحتوى دون علم Git.

2. التخزين الموجه للمحتوى:
   يتم تخزين الملفات حسب تجزئة محتواها.
   نفس المحتوى = نفس التجزئة = يخزن مرة واحدة.

3. الإلحاق فقط:
   Git بشكل عام تضيف البيانات فقط، لا تزيلها أبداً.
   حتى الالتزامات "المحذوفة" يمكن غالباً استعادتها.

4. سلسلة الالتزامات:
   كل التزام يشير إلى أصله.
   لا يمكنك تغيير التاريخ دون كسر السلسلة.

النتيجة:
من المستحيل تقريباً فقدان البيانات أو عدم اكتشاف الفساد.

تمرين استكشافي:

لنستكشف مجلد .git:

أنشئ مجلداً جديداً وابدأ مستودع Git:
```
mkdir git-test && cd git-test
git init
```
انظر إلى بنية مجلد .git:
```
ls -la .git/
```
تحقق مما يشير إليه HEAD:
```
cat .git/HEAD
```

أنشئ ملفاً، درجه، والتزم به:

echo "Hello Git" > test.txt
git add test.txt
git commit -m "First commit"

انظر إلى مجلد الكائنات:
```
find .git/objects -type f
```
تحقق من تجزئة الالتزام:
```
git log --oneline
```

ما تعلمته: رأيت كيف تنشئ Git الكائنات والمراجع أثناء عملك!

الملخص

في هذا الدرس، تعلمت:

لدى Git ثلاث حالات رئيسية: معدل، مرحلي، وملتزم
مجلد العمل ومنطقة التدريج والمستودع تشكل بنية Git
مجلد .git يحتوي على جميع بيانات ومعلومات Git الوصفية
Git تخزن البيانات كأربعة أنواع من الكائنات: نقط، أشجار، التزامات، ووسوم
تجزئات SHA-1 تحدد بشكل فريد جميع الكائنات وتضمن سلامة البيانات
Git تستخدم اللقطات، وليس الدلتا، للعمليات السريعة والموثوقة
HEAD والفروع والوسوم هي فقط مؤشرات للالتزامات
بنية Git تضمن سلامة البيانات وتجعل التفريع خفيف الوزن

التالي: في الدرس التالي، سنطبق هذه المعرفة من خلال تعلم سير عمل Git الأساسي - إنشاء المستودعات، تدريج التغييرات، وإجراء الالتزامات!