Detached HEAD state in Git - Mini Project: Build & Apply

Understanding Detached HEAD State in Git

📖 Scenario: You are working on a project using Git for version control. Sometimes, you might want to look at or test an older version of your project without changing the main branch. This is called a detached HEAD state. In this project, you will practice how to enter and recognize this state.

🎯 Goal: Learn how to checkout a specific commit to enter detached HEAD state and verify that you are in this state using Git commands.

📋 What You'll Learn

Use git checkout to switch to a specific commit hash

Use git log --oneline to find commit hashes

Use git status to check the HEAD state

💡 Why This Matters

🌍 Real World

Developers often need to inspect or test older versions of code without affecting the main branch. Detached HEAD state allows this safely.

💼 Career

Understanding detached HEAD is important for safe version control and avoiding accidental changes in shared branches.

1

Find a commit hash

Run the command git log --oneline and copy the first 7 characters of the second commit hash shown (not the latest). Assign this value as a string to a variable called commit_hash.

Git

# Run 'git log --oneline' in your terminal and copy the second commit hash
commit_hash = ""  # Paste the 7-character commit hash here

Hint

Use git log --oneline to see commit hashes. Copy the second commit's first 7 characters exactly.

2

Checkout the commit to enter detached HEAD

Use the command git checkout {commit_hash} to switch to the commit stored in the variable commit_hash. Write the exact command as a string assigned to a variable called checkout_command.

Git

commit_hash = "a1b2c3d"
# Write the git checkout command using commit_hash
checkout_command = ""

Hint

Use an f-string to include commit_hash in the checkout command.

3

Check the HEAD state

Write the command git status as a string assigned to a variable called status_command. This command will help you verify that you are in detached HEAD state.

Git

commit_hash = "a1b2c3d"
checkout_command = f"git checkout {commit_hash}"
# Write the git status command
status_command = ""

Hint

Simply assign the string git status to status_command.

4

Display the detached HEAD confirmation

Print the exact phrase "You are in detached HEAD state" to confirm understanding of the state after running git status.

Git

commit_hash = "a1b2c3d"
checkout_command = f"git checkout {commit_hash}"
status_command = "git status"
# Print the confirmation message

Hint

Use print() to display the message exactly as shown.

Practice

1. What does it mean when Git is in a detached HEAD state?

easy

A. You are merging two branches together.

B. You are on the latest commit of the main branch.

C. You are viewing a specific commit, not a branch.

D. You have uncommitted changes in your working directory.

Solution

1. Step 1: Understand HEAD in Git

   HEAD usually points to the latest commit on a branch, representing your current working state.

2. Step 2: Meaning of detached HEAD

   When HEAD points directly to a commit instead of a branch, you are in detached HEAD state, meaning you are not on any branch.

3. Final Answer:

   You are viewing a specific commit, not a branch. -> Option C

4. Quick Check:

   Detached HEAD = viewing commit, no branch [OK]

Hint: Detached HEAD means no branch, just a commit [OK]

Common Mistakes:

• Confusing detached HEAD with uncommitted changes
• Thinking detached HEAD means merging branches
• Assuming detached HEAD is always on main branch

2. Which Git command puts you into a detached HEAD state?

easy

A. git checkout main

B. git branch new-feature

C. git merge feature-branch

D. git checkout

Solution

1. Step 1: Understand git checkout usage

   Checking out a branch moves HEAD to that branch's latest commit, staying attached.

2. Step 2: Checkout a commit hash

   Checking out a specific commit hash moves HEAD directly to that commit, causing detached HEAD state.

3. Final Answer:

   git checkout <commit-hash> -> Option D

4. Quick Check:

   Checkout commit hash = detached HEAD [OK]

Hint: Checkout commit hash, not branch, to detach HEAD [OK]

Common Mistakes:

• Using branch name instead of commit hash
• Confusing branch creation with checkout
• Thinking merge causes detached HEAD

3. What will be the output of the following commands?

git checkout 1a2b3c4
git status

Assuming 1a2b3c4 is a valid commit hash.

medium

A. HEAD detached at 1a2b3c4
nothing to commit, working tree clean

B. On branch main
Your branch is up to date.

C. error: pathspec '1a2b3c4' did not match any file(s) known to git

D. You are currently rebasing branch 'main'

Solution

1. Step 1: Checkout commit hash

   Running git checkout 1a2b3c4 moves HEAD to that commit, entering detached HEAD state.

2. Step 2: Check git status output

   In detached HEAD, git status shows 'HEAD detached at <commit>' and clean working tree if no changes.

3. Final Answer:

   HEAD detached at 1a2b3c4 nothing to commit, working tree clean -> Option A

4. Quick Check:

   Detached HEAD status shows commit and clean tree [OK]

Hint: Detached HEAD status shows commit hash and clean tree [OK]

Common Mistakes:

• Expecting branch name in status
• Thinking checkout commit hash causes error
• Confusing rebase message with detached HEAD

4. You are in detached HEAD state and made some changes. Which command will save your changes safely on a new branch?

medium

A. git commit -m 'save changes'

B. git checkout -b new-branch

C. git merge main

D. git reset --hard

Solution

1. Step 1: Understand detached HEAD changes

   Changes made in detached HEAD are not on any branch and can be lost if you switch commits.

2. Step 2: Create a new branch to save changes

   Using git checkout -b new-branch creates a branch at current commit and switches to it, preserving changes.

3. Final Answer:

   git checkout -b new-branch -> Option B

4. Quick Check:

   Create branch from detached HEAD to save changes [OK]

Hint: Create new branch from detached HEAD to keep changes [OK]

Common Mistakes:

• Committing without a branch loses changes on checkout
• Merging without branch context does not save changes
• Resetting discards changes

5. You checked out a commit hash and made changes in detached HEAD. Later, you want to keep those changes and continue working on a branch named feature. What is the correct sequence of commands?

hard

A. git checkout -b feature
git add .
git commit -m 'work'

B. git commit -m 'work'
git branch feature
git checkout feature

C. git add .
git commit -m 'work'
git checkout feature

D. git checkout feature
git merge HEAD

Solution

1. Step 1: Create and switch to new branch

   Use git checkout -b feature to create a branch at current detached HEAD and switch to it.

2. Step 2: Stage and commit changes

   Run git add . and git commit -m 'work' to save your changes on the new branch.

3. Final Answer:

   git checkout -b feature git add . git commit -m 'work' -> Option A

4. Quick Check:

   Create branch first, then commit changes [OK]

Hint: Create branch first, then add and commit changes [OK]

Common Mistakes:

• Committing before creating branch loses changes
• Switching to branch before committing loses detached changes
• Merging detached HEAD into branch is incorrect