Como o Git funciona internamente?

Question

Accepted Answer

Internamente, Git é um **armazenamento de objetos endereçáveis por conteúdo** — ele armazena tudo como **objetos** (blobs, trees, commits, tags) identificados pelo seu **hash SHA-1**. Compreender esse modelo desmistifica o Git e explica por que suas operações se comportam como se comportam.

## Git é um armazenamento de objetos endereçáveis por conteúdo

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

## Um commit é um snapshot, não um diff

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

## Como isso se encaixa

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

## Por que isso explica o comportamento do 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)
```

## Por que isso importa

Compreender como o Git funciona internamente é conhecimento valioso de nível sênior porque **desmistifica o Git** e explica *por que* suas operações se comportam como se comportam, aprofundando sua capacidade de raciocinar sobre e usar o Git com confiança.

O modelo central — Git como um **armazenamento de objetos endereçáveis por conteúdo** com quatro tipos de objeto (blobs para conteúdos de arquivos, trees para diretórios, commits para snapshots, tags) cada um identificado pelo **hash de seu conteúdo** — é a base sobre a qual tudo o mais repousa.

Compreender que **um commit é um snapshot, não um diff** (cada commit aponta para uma árvore completa representando o estado completo do projeto, com arquivos inalterados reutilizando eficientemente os mesmos blobs, e diffs computados em vez de armazenados) corrige uma concepção errônea comum e explica o modelo baseado em snapshots do Git.

Ver **como isso se encaixa** (branches e tags como ponteiros/refs baratos para commits, HEAD apontando para o branch atual, commits encadeados via pais) revela a elegante simplicidade por trás.

Mais valosamene, essa compreensão **explica o comportamento observável do Git**: por que **branches são leves** (apenas um hash em um arquivo pequeno, não cópias de arquivos — explicando por que branching é tão rápido), por que Git tem **integridade** (endereçamento por conteúdo detecta corrupção via desajustes de hash), por que **commits são imutáveis** e operações de reescrita de histórico como rebase criam **novos commits com novos hashes** (mudar qualquer conteúdo muda o hash), e por que Git **deduplicata** (conteúdo idêntico armazenado uma vez).

Esse modelo mais profundo transforma Git de um conjunto de comandos memorizados em um sistema compreensível, permitindo raciocínio confiante sobre operações complexas.

Como compreender o modelo de objeto interno explica por que o Git se comporta como se comporta (branches leves, commits imutáveis, mudanças de hash ao reescrever, integridade) e eleva alguém de usar Git para realmente compreendê-lo, compreender as internals do Git é conhecimento valioso de nível sênior — um tópico que reflete a profundidade esperada para funções sênior e fornece o modelo mental para raciocinar sobre Git com confiança, desmistificando seu comportamento e tornando operações avançadas compreensíveis em vez de misteriosas.