Squashing commits in Git - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output of this git command sequence?

You have 3 commits on your branch. You run git rebase -i HEAD~3 and squash the last two commits into one. What will git log --oneline show after completing the rebase?

Git

commit1: Initial commit
commit2: Added feature A
commit3: Fixed bug in feature A

A One commit with message of commit3 only

B Two commits: first commit unchanged, second commit combines commit2 and commit3

C One commit with combined message of all three commits

D Three separate commits unchanged

💡 Hint

Squashing merges commits into the previous one, combining their changes and messages.

Squashing the last two commits into one means the first commit stays, and the second and third commits merge into one. So the log shows two commits: the original first commit and a combined commit of the last two.

❓ Troubleshoot

intermediate

Why does git rebase -i HEAD~3 fail with 'cannot rebase: You have unstaged changes'?

You try to squash commits using git rebase -i HEAD~3 but get an error about unstaged changes. What is the cause?

A Your repository is corrupted and needs repair

B You are on the wrong branch and must switch to master first

C You have uncommitted changes in your working directory that must be committed or stashed before rebasing

D You need to update git to the latest version

💡 Hint

Git requires a clean working directory to safely rebase.

Git prevents rebasing when there are unstaged or uncommitted changes to avoid conflicts or data loss. You must commit or stash changes before rebasing.

❓ Configuration

advanced

How to configure git to always use squash when merging a feature branch?

You want to set up your git repository so that when you merge a feature branch into main, it always squashes commits automatically. Which configuration achieves this?

A git config --global merge.squash true

B git config --global pull.rebase squash

C git config --global merge.ff false

D git config --global merge.squash false

💡 Hint

Look for a setting related to merge and squash.

Setting merge.squash to true makes git merge commands squash commits by default.

🔀 Workflow

advanced

What is the correct sequence to squash the last 4 commits into one with a new message?

You want to combine the last 4 commits into a single commit with a new commit message. Which sequence of commands is correct?

A git rebase -i HEAD~4; mark first commit as 'pick' and others as 'squash'; save and exit

B git rebase -i HEAD~4; mark all commits as 'pick'; save and exit

C git merge --squash HEAD~4; git commit -m "New combined message"

D git reset --soft HEAD~4; git commit -m "New combined message"

💡 Hint

Interactive rebase lets you choose which commits to squash.

In interactive rebase, you keep the first commit as 'pick' and mark the rest as 'squash' to combine them into one commit with a new message.

✅ Best Practice

expert

What is the best practice when squashing commits before pushing to a shared remote branch?

You have squashed multiple commits locally and want to push to a shared remote branch. What should you do to avoid disrupting others?

A Force push with <code>git push --force</code> after squashing

B Push normally with <code>git push</code> without force

C Delete the remote branch and push again

D Create a new branch and push the squashed commits there

💡 Hint

Force pushing can overwrite others' work.

Force pushing to a shared branch can overwrite others' commits and cause problems. Creating a new branch preserves history and avoids conflicts.

Practice

1. What is the main purpose of squashing commits in Git?

easy

A. To revert the last commit without changing history

B. To combine multiple commits into one for a cleaner history

C. To create a new branch from the current commit

D. To delete all commits from the repository

Solution

1. Step 1: Understand commit history management

   Squashing is used to combine several commits into a single commit to simplify the commit history.

2. Step 2: Identify the purpose of squashing

   This helps keep the project history clean and easier to read by reducing clutter from many small commits.

3. Final Answer:

   To combine multiple commits into one for a cleaner history -> Option B

4. Quick Check:

   Squashing = combine commits [OK]

Hint: Squash = combine commits to clean history [OK]

Common Mistakes:

• Thinking squashing deletes commits permanently
• Confusing squashing with branching
• Believing squashing reverts commits

2. Which Git command starts an interactive rebase to squash commits?

easy

A. git commit --squash HEAD~3

B. git merge -i HEAD~3

C. git rebase -i HEAD~3

D. git reset --soft HEAD~3

Solution

1. Step 1: Identify the command for interactive rebase

   The command to start an interactive rebase is git rebase -i followed by the commit range.

2. Step 2: Confirm the correct syntax

   git rebase -i HEAD~3 opens the last 3 commits for editing, allowing squashing.

3. Final Answer:

   git rebase -i HEAD~3 -> Option C

4. Quick Check:

   Interactive rebase = git rebase -i [OK]

Hint: Use git rebase -i to start squashing commits [OK]

Common Mistakes:

• Using git merge -i which does not exist
• Trying git commit --squash which is invalid
• Confusing reset with rebase for squashing

3. Given these commits:

commit1: Add README
commit2: Fix typo
commit3: Update README formatting

If you run git rebase -i HEAD~3 and squash commit2 and commit3 into commit1, what will the commit history show?

medium

A. One commit combining messages from commit1, commit2, and commit3

B. Three separate commits unchanged

C. One commit with message from commit1 only

D. Two commits: commit1 and combined commit2+commit3

Solution

1. Step 1: Understand squash behavior in interactive rebase

   Squashing merges commits into one, combining their changes and commit messages.

2. Step 2: Result of squashing commit2 and commit3 into commit1

   The final commit will include all changes and combined commit messages from all three commits.

3. Final Answer:

   One commit combining messages from commit1, commit2, and commit3 -> Option A

4. Quick Check:

   Squash merges commits and messages [OK]

Hint: Squash merges commits and their messages together [OK]

Common Mistakes:

• Assuming only the first commit message remains
• Expecting commits to stay separate after squash
• Thinking squash deletes commit messages

4. You ran git rebase -i HEAD~4 to squash commits but got a conflict error. What should you do next?

medium

A. Manually fix the conflicts, then run git rebase --continue

B. Abort the rebase with git rebase --abort and try again

C. Run git reset --hard to discard all changes

D. Push your changes immediately to remote to fix conflicts

Solution

1. Step 1: Understand conflict during rebase

   A conflict means Git needs you to fix code differences manually before continuing.

2. Step 2: Resolve conflicts and continue rebase

   Fix the conflicts in files, then run git rebase --continue to proceed with squashing.

3. Final Answer:

   Manually fix the conflicts, then run git rebase --continue -> Option A

4. Quick Check:

   Fix conflicts + git rebase --continue [OK]

Hint: Fix conflicts manually then git rebase --continue [OK]

Common Mistakes:

• Aborting rebase without trying to fix conflicts
• Using git reset --hard which discards work
• Pushing incomplete changes to remote

5. You squashed commits locally and want to update the remote branch. What is the correct command to push your changes safely?

hard

A. git push --all origin

B. git push origin main

C. git push --no-verify origin main

D. git push --force-with-lease origin main

Solution

1. Step 1: Understand effect of squashing on commit history

   Squashing rewrites commit history, so the remote branch history differs from local.

2. Step 2: Use force push safely

   To update remote with rewritten history, use git push --force-with-lease to avoid overwriting others' work accidentally.

3. Final Answer:

   git push --force-with-lease origin main -> Option D

4. Quick Check:

   Force push safely after squash [OK]

Hint: Use git push --force-with-lease after squash [OK]

Common Mistakes:

• Using normal git push causing rejection
• Using --no-verify which skips hooks but not force push
• Pushing all branches unnecessarily