How Git stores objects - Visual Walkthrough

Process Flow - How Git stores objects

Create file or change

↓

Generate SHA-1 hash of content

↓

Compress content with zlib

↓

Store compressed object in .git/objects/xx/

↓

Index object by SHA-1 prefix

↓

Use object in commits, trees, blobs

↓

Retrieve by SHA-1 when needed

Git takes file content, creates a unique hash, compresses it, and stores it in a special folder indexed by that hash.

Execution Sample

Git

echo "Hello" > file.txt
sha1=$(git hash-object file.txt)
mkdir -p .git/objects/${sha1:0:2}
cp file.txt .git/objects/${sha1:0:2}/${sha1:2}

This simulates how Git hashes a file and stores it in the objects folder by splitting the SHA-1 hash.

Process Table

Step	Action	Input/State	Output/State Change
1	Create file	file.txt content: 'Hello'	File created with content 'Hello'
2	Generate SHA-1 hash	Content 'Hello'	SHA-1 hash: e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
3	Compress content	Content 'Hello'	Compressed data ready for storage
4	Create directory	.git/objects/e6	Directory created for first 2 chars of hash
5	Store object	Compressed data	Stored in .git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
6	Index object	Stored object	Object indexed by SHA-1 for retrieval
7	Use object	Object indexed	Used in commits, trees, blobs
8	Retrieve object	SHA-1 hash	Original content retrieved by hash

💡 Process ends after object is stored and indexed for retrieval by SHA-1 hash

Status Tracker

Variable	Start	After Step 2	After Step 5	Final
file.txt content	none	'Hello'	'Hello'	'Hello'
SHA-1 hash	none	e69de29bb2d1d6434b8b29ae775ad8c2e48c5391	e69de29bb2d1d6434b8b29ae775ad8c2e48c5391	e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
Compressed data	none	none	compressed 'Hello'	compressed 'Hello'
Storage path	none	none	.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391	.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391

Key Moments - 3 Insights

Why does Git split the SHA-1 hash into two parts for storage?

Git uses the first two characters of the SHA-1 hash as a folder name to avoid too many files in one directory, making storage efficient and fast (see Step 4 and 5 in execution_table).

Is the stored object the original file content?

No, Git compresses the content before storing it to save space, so the stored object is compressed data (see Step 3 and 5 in execution_table).

How does Git find the object later?

Git uses the full SHA-1 hash to locate the object by combining the folder (first 2 chars) and file name (remaining chars) to retrieve and decompress it (see Step 8 in execution_table).

Visual Quiz - 3 Questions

Look at the execution table, what is the SHA-1 hash generated at Step 2?

A 9de29bb2d1d6434b8b29ae775ad8c2e48c5391e6

B e69de29bb2d1d6434b8b29ae775ad8c2e48c5391

C Hello

D compressed 'Hello'

💡 Hint

Check the 'Output/State Change' column at Step 2 in the execution_table.

At which step is the object compressed before storage?

A Step 2

B Step 5

C Step 3

D Step 7

💡 Hint

Look at the 'Action' column describing compression in the execution_table.

If the SHA-1 hash started with 'ab', where would Git store the object?

A .git/objects/ab/...

B .git/objects/e6/...

C .git/objects/ba/...

D .git/objects/aa/...

💡 Hint

Refer to Step 4 and 5 in execution_table about directory naming from SHA-1 prefix.

Concept Snapshot

Git stores objects by:
- Creating a SHA-1 hash of file content
- Compressing the content
- Splitting hash: first 2 chars as folder, rest as filename
- Saving compressed object in .git/objects/
- Using hash to retrieve content later

Full Transcript

Git stores data by first creating a unique SHA-1 hash from the file content. This hash acts like a fingerprint. Then Git compresses the content to save space. It splits the hash into two parts: the first two characters become a folder name inside .git/objects, and the remaining characters become the file name inside that folder. The compressed content is saved there. Later, Git uses the full hash to find and decompress the object when needed. This process helps Git store data efficiently and retrieve it quickly.

Practice

1. What type of Git object stores the actual content of a file?

easy

A. Blob

B. Tree

C. Commit

D. Tag

Solution

1. Step 1: Understand Git object types

   Git stores data in objects: blobs for file content, trees for directories, commits for snapshots, and tags for references.

2. Step 2: Identify the object for file content

   The blob object specifically holds the content of files, not metadata or history.

3. Final Answer:

   Blob -> Option A

4. Quick Check:

   File content = Blob [OK]

Hint: Remember: Blob = file content, Tree = folder [OK]

Common Mistakes:

• Confusing tree with blob
• Thinking commit stores file content
• Assuming tag stores file data

2. Which command correctly shows the type of a Git object given its hash abc123?

easy

A. git object-type abc123

B. git show-type abc123

C. git cat-file -t abc123

D. git object -show abc123

Solution

1. Step 1: Recall Git commands for object info

   The command git cat-file is used to inspect Git objects. The -t option shows the object type.

2. Step 2: Match the correct syntax

   git cat-file -t abc123 correctly shows the type of the object with hash abc123. Other options are invalid commands.

3. Final Answer:

   git cat-file -t abc123 -> Option C

4. Quick Check:

   Show object type = git cat-file -t [OK]

Hint: Use git cat-file -t to check object type fast [OK]

Common Mistakes:

• Using git show-type which doesn't exist
• Confusing git object commands
• Forgetting the -t option

3. Given a Git commit object hash def456, what will the command git cat-file -p def456 display?

medium

A. The raw content of a file stored in the commit

B. The list of branches containing the commit

C. The tags pointing to this commit

D. The commit message, author info, and tree hash

Solution

1. Step 1: Understand what a commit object contains

   A commit object stores metadata: author, date, commit message, and a tree hash representing the snapshot of files.

2. Step 2: Interpret git cat-file -p output for commit

   The command git cat-file -p pretty-prints the commit object, showing its message, author info, and tree hash, not raw file content or branch/tag info.

3. Final Answer:

   The commit message, author info, and tree hash -> Option D

4. Quick Check:

   Commit object details = message + author + tree [OK]

Hint: Commit object shows metadata, not file content [OK]

Common Mistakes:

• Expecting file content from commit object
• Confusing branches or tags with commit data
• Thinking commit object lists branches

4. You run git cat-file -p 123abc but get an error: fatal: Not a valid object name 123abc. What is the most likely cause?

medium

A. The command syntax is incorrect

B. The hash 123abc does not exist in the repository

C. You need to add files before using git cat-file

D. The repository is corrupted

Solution

1. Step 1: Analyze the error message

   The error says the object name is invalid, meaning Git cannot find an object with hash 123abc.

2. Step 2: Check common causes

   This usually happens if the hash is wrong or does not exist. The command syntax is correct, and adding files is unrelated. Repository corruption is less common and would cause other errors.

3. Final Answer:

   The hash 123abc does not exist in the repository -> Option B

4. Quick Check:

   Invalid object name = missing hash [OK]

Hint: Check if object hash exists before using git cat-file [OK]

Common Mistakes:

• Assuming syntax error instead of missing object
• Thinking files must be added before cat-file
• Jumping to repository corruption conclusion

5. You want to find the SHA-1 hash of a file's content before committing. Which Git command sequence correctly creates the object and shows its hash without committing?

hard

A. git hash-object -w <file> && git cat-file -p <hash>

B. git commit -m 'temp' && git show <file>

C. git add <file> && git log --hash

D. git init && git status

Solution

1. Step 1: Understand git hash-object usage

   The command git hash-object -w <file> creates a blob object from the file content and writes it to the object database, returning its hash.

2. Step 2: Verify object content with git cat-file

   Using git cat-file -p <hash> shows the content of the created blob object, confirming the hash matches the file content.

3. Final Answer:

   git hash-object -w <file> && git cat-file -p <hash> -> Option A

4. Quick Check:

   hash-object -w creates blob and shows hash [OK]

Hint: Use git hash-object -w to create and get file hash [OK]

Common Mistakes:

• Using git commit before hashing
• Confusing git add with hashing
• Thinking git init shows file hash