როგორ მუშაობს Git შიგნით?

Question

Accepted Answer

შიგნით, Git არის **კონტენტის მიხედვით მისამართებული ობიექტის მაგაზინი** — ის ყველაფერს ინახავს როგორც **ობიექტებს** (ბლობები, ხეები, კომიტები, ტეგები), რომლებიც იდენტიფიცირებული არიან მათი **SHA-1 ჰეშით**. ამ მოდელის გაგება Git-ს დემისტიფიცირებს და ხსნის, რატომ იქცევა მისი ოპერაციები ისე, როგორც ისინი იქცევიან.

## Git არის კონტენტის მიხედვით მისამართებული ობიექტის მაგაზინი

```text
Git stores 4 types of OBJECTS, each identified by the SHA-1 HASH of its content:
  BLOB   → file CONTENTS (just the data, no filename)
  TREE   → a directory: maps names → blobs (files) and trees (subdirs) + permissions
  COMMIT → a snapshot: points to a TREE (the root) + parent commit(s) + author/message
  TAG    → an annotated tag object (points to a commit, with metadata)
→ Content-addressable: an object's ID IS the hash of its content (same content = same hash).
```

## კომიტი არის სნაპშოტი, არა დიფი

```text
→ Each COMMIT points to a complete TREE (the full state of the project at that point)
→ Git stores SNAPSHOTS, not diffs (though it compresses/deduplicates internally):
  unchanged files → the commit's tree just REUSES the same blob (same hash) → efficient
→ Diffs you see are COMPUTED between snapshots, not stored.
```

## როგორ უკავშირდება ერთმანეთს

```text
Branch (e.g. main) → a pointer (a ref) to a COMMIT
HEAD → points to the current branch (or commit)
Commit → tree → blobs (the snapshot)
Commit → parent → parent → ... (the history chain)
→ Branches/tags are just small files containing a commit hash (cheap pointers).
  That's WHY branching is so lightweight.
```

## რატომ ხსნის ეს Git-ის ქცევას

```text
✓ Branches are cheap → they're just a 40-char hash in a file (not file copies)
✓ Integrity → content-addressing means corruption/changes are detectable (hash mismatch)
✓ Commits are immutable → changing anything = a new hash = a new commit (why rebase
  creates NEW commits, why history rewriting changes hashes)
✓ Deduplication → identical content stored once (shared blobs)
```

## რატომ აქვს ეს მნიშვნელობა

Git-ის შიგნითი მუშაობის გაგება ღირებული უფროსი დონის ცოდნაა, რადგან ის **დემისტიფიცირებს Git-ს** და ხსნის, რატომ *იქცევა* მისი ოპერაციები ისე, რითიც ისინი იქცევიან, რაც მეტად აღრმავებს თქვენი უნარს დაფიქრდეთ და თავდაჯერებულად გამოიყენოთ Git.

ბირთვის მოდელი — Git როგორც **კონტენტის მიხედვით მისამართებული ობიექტის მაგაზინი** ოთხი ობიექტის ტიპით (ბლობები ფაილის შინაარსისთვის, ხეები დირექტორიებისთვის, კომიტები სნაპშოტებისთვის, ტეგები) თითოეული იდენტიფიცირებული მის **კონტენტის ჰეშით** — არის ფუძე, რომელზეც ყველაფერი დაფუძნებულია.

ის, რომ **კომიტი არის სნაპშოტი, არა დიფი** (თითოეული კომიტი ზე ნიშნავს სრულ ხეს, რომელიც წარმოადგენს პროექტის სრულ მდგომარეობას, შეუცვლელი ფაილები ეფექტურად ხელახლა იყენებენ იგივე ბლობებს, ხოლო დიფები გამოითვლება და არ ინახება) იღებს საერთო მცდარი წარმოდგენა და ხსნის Git-ის სნაპშოტზე დაფუძნებულ მოდელს.

**როგორ უკავშირდება ერთმანეთს** (ბრენჩები და ტეგები იაფი მაჩვენებლებია/რეფერენცია კომიტებზე, HEAD ზე მიუთითებს მიმდინარე ბრენჩზე, კომიტები დაკავშირებული მშობლების საშუალებით) კრიტიკულად აჩვენებს ელეგანტურ სიმარტივეს ქვეშ.

ყველაზე ღირებული, ეს გაგება **ხსნის Git-ის დაკვირვებული ქცევა**: რატომ არის **ბრენჩები სუსტი** (მხოლოდ ჰეში მცირე ფაილში, არ ფაილის ასლები — რაც ხსნის, რატომ არის ბრენჩი ასე სწრაფი), რატომ აქვს Git **მთლიანობა** (კონტენტის მისამართი ამოიცნობს კორუფციას ჰეშის შეუსაბამობებით), რატომ არიან **კომიტები უცვლელი** და ისტორიის გადაწერის ოპერაციები, როგორიცაა rebase, ქმნიან **ახალ კომიტებს ახალი ჰეშებით** (ნებისმიერი კონტენტის შეცვლა ჰეშს იცვლის), და რატომ **დედუპლიცირებს** Git (იდენტური კონტენტი ერთხელ ინახება).

ეს ღრმა მოდელი Git-ს გარდაქმნის დამახსოვრებული ბრძანებებიდან გაგებული სისტემაში, რაც შესაძლებელს ხდის კომპლექსური ოპერაციების თავდაჯერებული გონივრული დასაბუთება.

ვინაიდან შიგნითი ობიექტის მოდელის გაგება ხსნის, რატომ იქცევა Git ისე, როგორც ის იქცევა (სუსტი ბრენჩები, უცვლელი კომიტები, ჰეშის ცვლილება გადაწერისას, მთლიანობა) და აზუსტებს ერთს Git-ის გამოყენებიდან მის ჭეშმარიტად გაგებამდე, Git-ის შიგნითი მუშაობის გაგება ღირებული უფროსი დონის ცოდნაა — თემა, რომელიც ასახავს სიღრმეს, რომელიც მოსალოდნელია უფროსი როლებისთვის და გაწვდის მენტალურ მოდელს Git-ის გონივრული დასაბუთებისთვის, დემისტიფიცირებს მის ქცევას და ხდის განვითარებული ოპერაციები გაგებული და არა საიდუმლო.