How branches are just files with hashes in Git - Quick Revision & Summary

Recall & Review

beginner

What is a Git branch in simple terms?

A Git branch is just a file that stores the hash (a unique ID) of the latest commit on that branch.

beginner

How does Git know which commit a branch points to?

Git reads the branch file which contains the hash of the commit it points to. This hash tells Git the exact snapshot of the project.

intermediate

What happens to the branch file when you make a new commit?

The branch file updates to store the new commit's hash, so the branch always points to the latest commit.

intermediate

Where are branch files stored in a Git repository?

Branch files are stored inside the .git/refs/heads directory as simple text files containing commit hashes.

beginner

Why is it useful to think of branches as files with hashes?

Because it shows branches are lightweight pointers to commits, making Git fast and efficient at switching and managing code versions.

What does a Git branch file contain?

A The list of all commits in the branch

B The full source code of the project

C The commit message of the last commit

D The hash of the latest commit on that branch

A Git branch file stores the hash of the latest commit it points to, not the full code or commit messages.

Where can you find branch files inside a Git repository?

A .git/objects/

B .git/config

C .git/refs/heads/

D .git/hooks/

Branch files are stored as simple files inside the .git/refs/heads directory.

What happens to a branch file when you commit new changes?

A It updates to the new commit's hash

B It deletes the old commit

C It creates a new branch file

D It stores the commit message

The branch file updates to point to the new commit hash after a commit.

Why are branches considered lightweight in Git?

A Because they are stored in the cloud

B Because they are just files with commit hashes

C Because they contain all commit messages

D Because they store full copies of the project

Branches are lightweight because they only store a pointer (hash) to a commit, not full project copies.

What does the commit hash in a branch file represent?

A A unique ID for a specific project snapshot

B The name of the branch

C The date of the last commit

D The author of the commit

The commit hash uniquely identifies a specific snapshot of the project at that commit.

Explain how Git branches work as files with hashes.

Think about how a branch points to a commit using a simple file.

Describe where branch files are stored and what they contain in a Git repository.

Look inside the .git folder to find branch files.

Practice

1. What does a Git branch file store internally?

easy

A. A commit hash pointing to a specific commit

B. The entire project files

C. The list of all branches

D. The commit message text

Solution

1. Step 1: Understand what a branch represents

   A branch in Git is a pointer to a commit, not the files themselves.

2. Step 2: Identify what is stored in the branch file

   The branch file stores the commit hash it points to, which identifies the commit.

3. Final Answer:

   A commit hash pointing to a specific commit -> Option A

4. Quick Check:

   Branch file = commit hash [OK]

Hint: Branches store commit hashes, not files or messages [OK]

Common Mistakes:

• Thinking branches store full project files
• Confusing branch files with commit messages
• Assuming branches list all other branches

2. Which command shows the content of the branch file for main in Git?

easy

A. git show main

B. cat .git/refs/heads/main

C. git branch main

D. git log main

Solution

1. Step 1: Locate branch files in Git directory

   Branch files are stored in .git/refs/heads/ folder.

2. Step 2: Use a command to read the branch file content

   The cat command reads the file content, showing the commit hash.

3. Final Answer:

   cat .git/refs/heads/main -> Option B

4. Quick Check:

   Read branch file with cat [OK]

Hint: Branch files are plain files under .git/refs/heads/ [OK]

Common Mistakes:

• Using git show which shows commit details, not raw hash
• Using git branch which lists branches, not file content
• Using git log which shows commit history, not branch file

3. Given the branch file .git/refs/heads/feature contains abc1234, what does git checkout feature do?

medium

A. Creates a new commit with hash abc1234

B. Deletes the feature branch

C. Moves HEAD to commit abc1234 and updates working files

D. Shows the commit message of abc1234

Solution

1. Step 1: Understand what git checkout does with a branch

   It moves the HEAD pointer to the commit the branch points to.

2. Step 2: Connect branch file content to checkout effect

   The branch file has commit hash abc1234, so checkout moves HEAD there and updates files.

3. Final Answer:

   Moves HEAD to commit abc1234 and updates working files -> Option C

4. Quick Check:

   Checkout moves HEAD to branch commit [OK]

Hint: Checkout moves HEAD to branch's commit hash [OK]

Common Mistakes:

• Thinking checkout deletes branches
• Confusing checkout with commit creation
• Assuming checkout only shows commit messages

4. You see that .git/refs/heads/dev file is empty. What problem will this cause?

medium

A. Git will ignore the dev branch and use main instead

B. Git will create a new commit automatically

C. Git will treat dev as a remote branch

D. Git cannot find the commit for branch dev, causing errors on checkout

Solution

1. Step 1: Understand branch file role in Git

   The branch file must contain a commit hash to point to a commit.

2. Step 2: Analyze effect of empty branch file

   If empty, Git cannot find the commit, so checkout or other commands fail with errors.

3. Final Answer:

   Git cannot find the commit for branch dev, causing errors on checkout -> Option D

4. Quick Check:

   Empty branch file breaks commit reference [OK]

Hint: Branch files must have commit hashes, never be empty [OK]

Common Mistakes:

• Assuming Git auto-fixes empty branch files
• Confusing empty branch file with remote branch
• Thinking Git defaults to main silently

5. You want to create a new branch release pointing to the same commit as main. Which command correctly updates the branch file?

hard

A. git checkout -b release main

B. git branch release main

C. A and B

D. echo $(cat .git/refs/heads/main) > .git/refs/heads/release

Solution

1. Step 1: Understand how branches point to commits

   Branches are files storing commit hashes. Copying main's hash creates release at same commit.

2. Step 2: Analyze each option's effect

   echo $(cat .git/refs/heads/main) > .git/refs/heads/release manually copies the hash file content. git branch release main creates branch release at main's commit. git checkout -b release main creates and switches to release at main's commit.

3. Step 3: Confirm which options update branch file correctly

   Options A, B, and D all create the release branch pointing to main's commit, but only D is a single command that creates and switches to the branch.

4. Final Answer:

   git checkout -b release main -> Option A

5. Quick Check:

   git checkout -b creates and switches branch [OK]

Hint: Multiple ways to set branch file to same commit hash, but checkout -b is most common [OK]

Common Mistakes:

• Thinking only git commands can create branches
• Ignoring manual file editing possibility
• Confusing checkout with branch creation only