Git dahili olarak nasıl çalışır?

Question

Accepted Answer

Dahili olarak, Git bir **içerik adreslenebilir nesne deposu**dur — her şeyi **nesneler** olarak (blob'lar, ağaçlar, commit'ler, etiketler) **SHA-1 hash** tarafından tanımlanan şekilde depolar. Bu modeli anlamak Git'i demystify eder ve neden işlemleri bu şekilde davrandığını açıklar.

## Git bir içerik adreslenebilir nesne deposudur

```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).
```

## Bir commit bir fark değil, bir anlık görüntüdür

```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.
```

## Hepsi nasıl bir araya gelir

```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.
```

## Bu Git'in davranışını nasıl açıklar

```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)
```

## Neden önemli

Git'in dahili olarak nasıl çalıştığını anlamak, **Git'i demystify ettiği** ve işlemlerinin *neden* bu şekilde davrandığını açıkladığı için değerli bir kıdemli seviye bilgisidir ve Git'i güvenle kullanma ve akıl yürütme yeteneğinizi derinleştirir.

Temel model — Git bir **içerik adreslenebilir nesne deposu** olarak dört nesne türü (dosya içerikleri için blob'lar, dizinler için ağaçlar, anlık görüntüler için commit'ler, etiketler) her biri **içeriğinin hash** tarafından tanımlanır — her şey bunun üzerine inşa edilir.

**Bir commit bir fark değil, bir anlık görüntüdür** olduğunu anlamak (her commit proje durumunun tamamını temsil eden tam bir ağaca işaret eder, değiştirilmemiş dosyalar aynı blob'ları verimli şekilde yeniden kullanır ve farklar depolanmak yerine hesaplanır) yaygın bir yanlış anlaşılmayı düzeltir ve Git'in anlık görüntü tabanlı modelini açıklar.

**Hepsi nasıl bir araya gelir** görülmesi (branch'ler ve etiketler commit'lere ucuz işaretçiler/ref'ler olarak, HEAD geçerli branch'i gösterir, commit'ler ebeveynler aracılığıyla zincirlenmiş) altındaki zarif basitliği ortaya koymaktadır.

En değerli olarak, bu anlayış **Git'in gözlemlenebilir davranışını açıklar**: **branch'ler neden hafifdir** (sadece küçük bir dosyada bir hash, dosya kopyası değil — branching'in neden bu kadar hızlı olduğunu açıklar), Git neden **bütünlüğe** sahiptir (içerik adreslemesi hash uyuşmazlıkları aracılığıyla bozulmayı algılar), **commit'ler neden değişmezdir** ve rebase gibi geçmiş yeniden yazma işlemleri **yeni hash'leri olan yeni commit'ler** oluşturur (herhangi bir içeriği değiştirmek hash'i değiştirir), ve Git neden **çoğaltır** (aynı içerik bir kez depolanır).

Bu daha derin model Git'i ezberlenmiş komutlar dizisinden anlaşılabilir bir sisteme dönüştürür ve karmaşık işlemler hakkında güvenli bir şekilde akıl yürütmeyi sağlar.

Dahili nesne modelini anlamak Git'in neden bu şekilde davrandığını açıkladığı için (hafif branch'ler, değişmez commit'ler, yeniden yazma üzerine hash değişiklikleri, bütünlük) ve Git'i kullanmaktan gerçekten anlamaya yükselttiği için, Git internals'ı anlamak değerli bir kıdemli seviye bilgisidir — kıdemli roller için beklenen derinliği yansıtan bir konu ve Git hakkında güvenle akıl yürütmek, davranışını demystify etmek ve ileri işlemleri gizemli olmaktan çok anlaşılabilir hale getirmek için zihinsel modeli sağlayan bir konudur.