25 Git Interview Questions and Answers

Git is a powerful version control system that has become an essential tool for developers. It allows for efficient collaboration, tracking of changes, and management of project history. Git’s distributed nature and robust branching and merging capabilities make it a preferred choice for both small and large development teams. Its integration with platforms like GitHub and GitLab further enhances its utility in modern software development workflows.

This article provides a curated selection of Git interview questions designed to test your understanding and proficiency with the tool. By familiarizing yourself with these questions and their answers, you will be better prepared to demonstrate your expertise in version control and collaborative development during your interview.

Git Interview Questions and Answers

1. Describe the process to create a new branch and switch to it.

To create a new branch and switch to it, use the git branch and git checkout commands, or the git switch command. This allows you to work on new features without affecting the main codebase.

Example:

# Create and switch to a new branch named 'feature-branch'
git switch -c feature-branch

2. How do you merge two branches? What are potential conflicts that might arise, and how would you resolve them?

To merge two branches, use the git merge command. This integrates changes from one branch into another. Conflicts may arise if changes affect the same lines of code or if one branch deletes a file that the other modifies. These conflicts need to be resolved manually.

Example:

# Switch to the main branch and merge the feature branch
git checkout main
git merge feature-branch

# Resolve conflicts, if any, and complete the merge
git add <file-with-conflict>
git commit

3. What is the difference between git pull and git fetch?

The difference between git pull and git fetch is in their functionality:

– git fetch: Downloads commits, files, and references from a remote repository but does not merge them into your working directory.
– git pull: Combines git fetch and git merge, fetching changes and merging them into your current branch, which can lead to merge conflicts.

4. How do you revert a commit that has already been pushed to a remote repository?

To revert a commit that has been pushed to a remote repository, use the git revert command. This creates a new commit that undoes the changes made by the specified commit without altering the commit history.

Example:

# Revert a commit and push the changes
git revert <commit-hash>
git push origin main

5. How do you stash your changes and apply them later?

Stashing in Git allows you to save your current changes without committing them. Use git stash to save changes and git stash apply to reapply them later.

Example:

git stash
git stash apply

To apply a specific stash, use its identifier:

git stash list
git stash apply stash@{0}

6. How do you view the commit history for a repository?

To view the commit history, use the git log command. For a concise view, use --oneline, and for a graphical representation, add --graph.

Example:

git log --oneline --graph

7. What is the purpose of git rebase and how does it differ from git merge?

git rebase integrates changes by moving commits to a new base, creating a linear history. In contrast, git merge combines changes by creating a new commit that preserves the branching history.

Key differences:
– git rebase creates a linear history.
– git merge preserves the complete history.

8. How do you cherry-pick a commit from another branch?

Cherry-picking applies changes from a specific commit to another branch. Identify the commit hash and use git cherry-pick.

Example:

git checkout target-branch
git cherry-pick <commit-hash>

9. How do you set up a remote repository and push your local repository to it?

To set up a remote repository and push your local repository to it:

1. Create a remote repository.
2. Link your local repository using git remote add.
3. Push your local repository using git push.

Example:

git init
git remote add origin https://github.com/username/repository.git
git add .
git commit -m "Initial commit"
git push -u origin master

10. What is the purpose of git bisect and how would you use it to find a bug?

git bisect helps find the commit that introduced a bug by performing a binary search through your commit history.

Steps:
1. Start the bisect process.
2. Mark known good and bad commits.
3. Test commits and mark them as good or bad.
4. Continue until the bad commit is found.
5. End the bisect session.

Example:

git bisect start
git bisect bad <commit-hash>
git bisect good <commit-hash>
git bisect reset

11. How do you rename a branch both locally and remotely?

To rename a branch locally and remotely:

1. Rename the branch locally.
2. Push the renamed branch.
3. Delete the old branch from the remote.
4. Reset the upstream branch.

Example:

git branch -m old-branch-name new-branch-name
git push origin new-branch-name
git push origin --delete old-branch-name
git push --set-upstream origin new-branch-name

12. Describe the process to squash multiple commits into one.

Squashing multiple commits into one is done using interactive rebase. This combines several commits into a single one.

Example:

git rebase -i HEAD~n

Replace n with the number of commits to squash. Change “pick” to “squash” for the commits to combine. After editing, force-push the changes if necessary.

git push --force

13. How do you configure Git to use a specific text editor for commit messages?

To configure Git to use a specific text editor for commit messages, set the core.editor configuration.

Example:

git config --global core.editor "nano"

Replace “nano” with your preferred editor.

14. Explain the concept of submodules and how you would add one to a repository.

Submodules allow you to include external repositories within a main repository. To add a submodule:

git submodule add <repository_url> <path>
git submodule init
git submodule update

Example:

git submodule add https://github.com/example/repo.git libs/repo

15. How do you amend the most recent commit?

To amend the most recent commit, use git commit --amend. This allows you to modify the commit message or include additional changes.

Example:

git add <file>
git commit --amend

To amend without changing the message:

git commit --amend --no-edit

16. Describe the process to clone a repository with a specific branch.

To clone a repository with a specific branch, use the -b option with git clone.

Example:

git clone -b <branch_name> <repository_url>

17. How do you list all branches, both local and remote?

To list all branches, use:

– Local branches: git branch
– Remote branches: git branch -r
– Both: git branch -a

18. How do you reset a branch to a previous commit?

Resetting a branch to a previous commit can be done with git reset. Choose between soft, mixed, or hard reset based on your needs.

Example:

# Soft reset
git reset --soft <commit_hash>

# Mixed reset
git reset <commit_hash>

# Hard reset
git reset --hard <commit_hash>

19. Explain the difference between git reset --soft, --mixed, and --hard.

The git reset command has three options:

– --soft: Moves the HEAD to the specified commit, keeping changes staged.
– --mixed: Moves the HEAD and updates the index, unstaging changes.
– --hard: Moves the HEAD and updates both the index and working directory, discarding changes.

20. How do you handle merge conflicts in a rebase operation?

To handle merge conflicts during a rebase:

1. Start the rebase.
2. Resolve conflicts manually.
3. Add resolved files.
4. Continue the rebase.
5. Abort if necessary.

Example:

git rebase branch_name
git status
git add resolved_file
git rebase --continue
git rebase --abort

21. Describe the process to perform an interactive rebase.

Interactive rebase allows you to rewrite commit history. Use it to edit, reorder, squash, or drop commits.

Example:

git rebase -i HEAD~n

Change “pick” to “squash” for commits to combine. Edit the commit message as needed.

22. How do you sign a commit and why is it important?

Signing a commit adds a cryptographic signature, verifying the identity of the committer. Use GPG keys for this purpose.

Steps:

1. Generate a GPG key.
2. Configure Git to use your GPG key.
3. Sign a commit.

Example:

gpg --full-generate-key
gpg --list-secret-keys --keyid-format LONG
git config --global user.signingkey YOUR_KEY_ID
git commit -S -m "Your commit message"

23. What are Git hooks and how can they be used to automate tasks?

Git hooks are scripts that run automatically at specific points in the Git workflow. They can automate tasks like running tests or checking code quality.

Example:

Create a pre-commit hook to check for Python syntax errors:

#!/bin/sh
files=$(git diff --cached --name-only --diff-filter=ACM | grep '\.py$')
if [ "$files" != "" ]; then
    for file in $files; do
        python -m py_compile $file
        if [ $? -ne 0 ]; then
            echo "Syntax error in $file"
            exit 1
        fi
    done
fi

Make it executable:

chmod +x .git/hooks/pre-commit

24. How do you create and use Git aliases to improve productivity?

Git aliases are shortcuts for common commands, improving efficiency. Define them in the Git configuration file.

Example:

git config --global alias.st status

For complex sequences:

git config --global alias.ac '!git add -A && git commit -m'

Use it like this:

git ac "Your commit message"

25. How would you migrate a repository from one hosting service to another while preserving commit history?

To migrate a repository while preserving commit history:

1. Clone the existing repository.
2. Add the new hosting service as a remote.
3. Push the local repository to the new remote.
4. Verify the commit history.

Example:

git clone https://old-hosting-service.com/username/repository.git
cd repository
git remote add new-origin https://new-hosting-service.com/username/repository.git
git push new-origin --all
git push new-origin --tags