Ace Your Interview with These Essential Git Interview Questions

Following is the list of Interview Questions and Answers

1. What is Git?

Git is a distributed version control system that allows multiple developers to work on a project concurrently. It efficiently handles large projects by tracking changes in files, enabling version tracking, facilitating code sharing and backup, and supporting branching and merging capabilities.

2. What are the differences between Git and SVN?

While both Git and SVN (Subversion) are version control systems, they differ significantly:

• Git is a distributed version control system, which means every developer's working copy of the code is also a repository with complete history and full version-tracking capabilities. On the other hand, SVN is a centralized version control system where version history is stored in one central place.

• Git branches are easier and quicker to create and merge, promoting branch-based workflows. SVN uses a more linear approach and branches are not as integral to its workflow.

• Git offers offline capabilities, allowing developers to commit changes locally before pushing them to the main repository. SVN requires connection to the central repository to commit changes.

3. What is a repository in Git?

A Git repository is a virtual storage of your project that tracks changes made to files. It contains all of the project files and the entire revision history. A repository holds commits, branches, tags, blobs, trees, and other components that are managed by Git.

4. What is a commit in Git?

A commit is a snapshot of changes made in the working directory. Each commit in Git has a unique ID (a SHA-1 hash), which allows Git to track history and changes over time. A commit includes the changes made, a commit message describing the changes, and references to the parent commits.

5. Can you explain the basic Git workflow?

The basic Git workflow involves the following steps:

• Clone the Git repository to get a copy of the project on your local machine.

• Create a new branch for the feature or bug fix you're working on.

• Make changes to the files in your local copy of the repository.

• Stage the changes, which adds them to a "staging area" in preparation for a commit.

• Commit the changes, creating a new snapshot of the project's state.

• Push your changes to the remote repository to share them with others.

• Open a pull request to merge your changes into the main branch.

• Review, discuss, and eventually merge the pull request into the main branch.

6. What is the difference between 'git pull' and 'git fetch'?

'Git pull' is a command that fetches changes from a remote repository and merges them into the current branch of your local repository. On the other hand, 'git fetch' only retrieves the changes from the remote repository without merging them. This allows you to review the updates before integrating them into your branch.

7. What is a branch in Git?

In Git, a branch is a pointer to a commit. It represents an independent line of development in a project. Branches are used to isolate new work from the main project. Changes made in a branch won't affect other branches, allowing you to work freely without disrupting the main codebase.

8. What is a 'conflict' in Git?

A 'conflict' occurs when two branches have made changes to the same line in a file, or if a file was deleted in one branch but edited in the other. Git cannot automatically determine what is correct. Conflicts generally arise during a merge or a rebase operation, and they must be resolved manually by the user.

9. How can you undo the most recent commit?

You can undo the most recent commit using the 'git reset' command. Specifically, 'git reset --hard HEAD1' will permanently remove the last commit, while 'git reset --soft HEAD1' will undo the last commit but keep the changes in the staging area.

10. What is a 'git stash'?

'Git stash' is a command that temporarily shelves (or stashes) changes you've made to your working copy but don't want to commit yet. This allows you to switch branches without committing your changes. You can apply the stashed changes later when you're ready.

11. What is a 'rebase' in Git?

Rebasing is a way to integrate changes from one branch into another. 'Git rebase' transfers the completed work from one branch to another. In the process, unwanted history can be eliminated and your feature branch can appear as if it was developed off the most recent commit on the master branch.

12. What does the 'git cherry-pick' command do?

The 'git cherry-pick' command is used to apply some commit from one branch into another branch. It takes the patch that was introduced in a commit and applies it to another branch.

13. What is a 'detached HEAD' in Git?

A 'detached HEAD' in Git means that you are no longer on a branch, but instead on a specific commit. In this state, any changes you make won’t be reflected on any branch, allowing you to experiment freely without the risk of disturbing your project's history. However, unless you create a new branch to store your changes, they will be discarded as soon as you check out a different commit or branch.

14. What is a 'remote' in Git?

A 'remote' in Git is a common repository that all team members use to exchange their updates. It lives on a web-based hosting service like GitHub or Bitbucket. 'Origin' is a common shorthand name for the repository where the developers cloned the code.

15. W2hat is a 'pull request' in Git?

A 'pull request' is a feature of collaborative git platforms like GitHub, Bitbucket, or GitLab. It's a proposal to merge a branch into another, usually followed by peer review and discussion before integration. It allows you to notify others about the changes you have pushed to a repository.

16. What is a 'bare' repository in Git?

A 'bare' repository in Git is a repository that only contains the contents of the .git subdirectory. Unlike a regular repository, it doesn't have working or checked out copy of source files. They are primarily for sharing and collaborating purposes, and typically reside on a remote server.

17. What does the '.gitignore' file do?

A '.gitignore' file is a text file that tells Git which files or folders to ignore in a project. It is used to avoid committing transient files from your working directory that aren't useful to other collaborators, such as compilation products, temporary files IDEs create, etc.

18. What is 'git bisect'? How can you use it to find the source of a bug?

'Git bisect' is a powerful tool used for searching the commit that introduced a bug in your project. The process involves a binary search algorithm. Git bisect checks out a commit between the "bad" commit, known to contain the bug, and the "good" commit, known to be bug-free. The developer then tests that commit for the bug. If the bug is present, the 'bad' commit is now the midpoint commit; if not, the 'good' commit becomes the midpoint commit. The process continues until the exact commit that introduced the bug is found.

19. What are 'git hooks'?

Git hooks are scripts that run automatically every time a particular event occurs in a Git repository. They let you customize Git's internal behavior and trigger customizable actions at key points in the development life cycle. For example, a pre-commit hook can check your code style, perform linting, or run your tests before you make a commit.

20. Explain the difference between a 'fast-forward' merge and a '3-way' merge.

A 'fast-forward' merge occurs when there is a linear path from the current branch tip to the target branch. Instead of creating a new commit, Git just moves the branch pointer forward to point to the target branch's latest commit.

In contrast, a '3-way' merge is needed when there is no clear path between the branches. In this case, Git creates a new commit that brings together the changes from both branches, preserving the ancestry of each commit.

21. What is 'git stash pop' and 'git stash apply'?

The 'git stash pop' command applies the changes from the latest stash and then removes the stash from the stack. On the other hand, 'git stash apply' applies the stashed changes but keeps the stash in your stack for future use.

22. What is a 'fork' in Git?

A 'fork' is a copy of a repository that allows you to freely experiment with changes without affecting the original project. Forking a repository creates a separate copy under your own Git account. It's commonly used in open-source projects, where various developers 'fork' the project, make changes, and then propose these changes back to the original repository using a pull request.

23. What is the difference between 'HEAD', 'working tree', and 'index' in Git?

In Git:

• 'HEAD' is a reference to the last commit in the currently checked-out branch.
• The 'working tree' (or working directory) consists of files that you are currently working on. It's the place where you add or edit files before staging and committing them.
• The 'index' (or staging area) is an intermediate area where commits can be formatted and reviewed before completing the commit.

24. How do you initialize a Git repository?

To initialize a Git repository, you navigate to the project's root directory in the command line and run the command git init . This command creates a new Git repository in the current directory.

25. What is the difference between git add and git commit ?

git add is used to add changes or new files to the staging area. It prepares them to be included in the next commit.

git commit creates a new commit with the changes that are currently staged. It records a snapshot of the project at that point in time.

26. How do you check the status of a Git repository?

To check the status of a Git repository, you can use the command git status . It provides information about which files are modified, staged, or untracked, and if there are any differences between the local repository and the remote repository.

27. What is the purpose of the .gitignore file?

The .gitignore file specifies files and directories that Git should ignore. It is commonly used to exclude generated files, build artifacts, temporary files, and any other files that should not be version controlled. Each line in the .gitignore file represents a pattern to match against file or directory names.

28. How do you create a new branch in Git?

To create a new branch in Git, you use the command git branch <branch-name> . This creates a new branch at the current commit. You can then switch to the newly created branch using git checkout <branch-name> or combine the creation and checkout with git checkout -b <branch-name> .

29. How do you merge branches in Git?

To merge branches in Git, you switch to the branch you want to merge into (usually the main branch), and then run the command git merge <branch-name> . This merges the specified branch into the current branch, combining the changes from both branches. Git will attempt to automatically merge the changes, but conflicts may occur and need to be resolved manually.

30. How do you push changes to a remote repository?

To push changes to a remote repository, you use the command git push . This command sends the committed changes from your local repository to the remote repository. It typically requires specifying the name of the remote repository and the branch you want to push.

31. How do you update your local repository with the latest changes from the remote repository?

To update your local repository with the latest changes from the remote repository, you can use the command git pull . This command fetches the latest commits from the remote repository and merges them into your current branch.

Having a solid understanding of these basic Git concepts will help you navigate through version control effectively and demonstrate your familiarity with Git during interviews.

32. What is the purpose of the git clone command?

The git clone command is used to create a local copy of a remote Git repository. It downloads the entire repository, including all files, commit history, and branches, onto your local machine.

33. How do you revert a commit in Git?

To revert a commit in Git, you can use the command git revert <commit-id> . This creates a new commit that undoes the changes made in the specified commit. It allows you to safely undo a commit without rewriting history.

34. What is the purpose of the git branch command?

The git branch command is used to list, create, or delete branches in a Git repository. Without any arguments, it lists all existing branches. When used with a branch name as an argument, it creates a new branch. With the -d option followed by a branch name, it deletes a branch.

35. How do you view the commit history in Git?

To view the commit history in Git, you can use the command git log . It displays a list of commits in reverse chronological order, showing the commit hash, author, date, and commit message.

36. What is the purpose of the git remote command?

The git remote command is used to manage connections to remote repositories. It allows you to view, add, or remove remote repositories. It is often used in conjunction with commands like git fetch , git push , and git pull to interact with remote repositories.

37. What is the purpose of the git reset command?

The git reset command is used to move the current branch to a specific commit, effectively resetting the branch to a different state. It can be used to undo commits, unstage files, or move the branch pointer to a specific commit in various modes, such as --soft , --mixed , or --hard .

38. How do you rename a file in Git?

To rename a file in Git, you can use the command git mv <old-filename> <new-filename> . This renames the file and stages the change, ready to be committed.

39. How do you remove untracked files in Git?

To remove untracked files in Git, you can use the command git clean . By running git clean -f , you can remove untracked files from your working directory. Be cautious, as this action cannot be undone.

40. What is the purpose of the git diff command?

The git diff command is used to show the differences between two states of a Git repository. It compares changes between commits, branches, or the working directory. It helps you visualize the modifications made to files, such as additions, deletions, or modifications.

41. How do you create and apply a Git patch?

To create a Git patch, you can use the command git format-patch <commit-id> . This generates a patch file containing the changes made in the specified commit or range of commits.

To apply a Git patch, you can use the command git apply <patch-file> . This applies the changes from the patch file to your current branch.

42. What is the purpose of the git rebase command?

The git rebase command is used to integrate changes from one branch onto another. It moves or combines a sequence of commits to a new base commit. It is commonly used to keep your feature branch up to date with the latest changes from the main branch before merging.

43. What is the purpose of the git tag command?

The git tag command is used to create and manage tags in Git. Tags are references to specific points in Git history, often used to mark important commits, versions, or milestones. They provide a convenient way to refer to specific points in the commit history.

44. How do you discard local changes in Git?

To discard local changes in Git and revert your files to the state of the last commit, you can use the command git checkout -- <file> . This discards the changes made to the specified file and restores it to the last committed version. Be cautious when using this command, as it permanently discards the local changes.

45. What is the purpose of the .gitattributes file?

The .gitattributes file is used to specify attribute patterns for paths in your Git repository. It allows you to control how Git treats certain files, such as specifying line-ending conventions, merging strategies, and handling binary files. It helps maintain consistency and avoid conflicts in cross-platform or collaborative development environments.

46. How do you resolve merge conflicts in Git?

To resolve merge conflicts in Git, you need to manually edit the conflicted files to remove the conflict markers ( <<<<<<< , ======= , >>>>>>> ) and make the necessary modifications. After resolving the conflicts, you can stage the changes and create a new commit to complete the merge.

47. What is the purpose of the git log command with different options?

The git log command is used to display the commit history in a Git repository. It has various options that allow you to customize the output. Some commonly used options include:

• --oneline : Displays each commit on a single line, showing only the commit hash and the commit message.
• --graph : Shows a text-based graph of the commit history, indicating branches and merges.
• --author : Filters the commit history to show only commits by a specific author.
• --since and --until : Filters the commit history based on a specific time range.
• --grep : Searches for commits that match a specific pattern or keyword in the commit message.

48. What is the purpose of the git remote show command?

The git remote show command displays information about a specific remote repository. It provides details such as the remote URL, branches, tracked branches, and information about the last fetch from the remote repository. It is useful for inspecting and managing remote repositories.

49. What is the purpose of the git revert command?

The git revert command is used to create a new commit that undoes the changes made in a specific commit. It is different from the git reset command, which removes commits from the commit history. git revert is a safe way to undo changes while preserving the commit history.

50. What is the purpose of the git reflog command?

The git reflog command displays the reference logs, which track changes to the branch pointers in a Git repository. It shows the history of all branch checkouts, commits, merges, and other reference-related actions. git reflog is useful for recovering lost commits or branches.

51. How do you cherry-pick a commit in Git?

To cherry-pick a commit in Git, you use the command git cherry-pick <commit-id> . This command applies the changes from the specified commit onto the current branch. It allows you to selectively include specific commits from one branch to another.

52. What is the purpose of the git rebase -i command?

The git rebase -i command allows you to perform an interactive rebase. It presents a list of commits and provides options to modify, squash, reorder, or delete commits before applying them to a new base commit. Interactive rebasing helps in organizing and cleaning up commit history.

53. How do you remove a file from a Git repository?

To remove a file from a Git repository, you can use the command git rm <file> . This removes the file from the working directory, stages the deletion, and prepares it to be committed. After committing the deletion, the file will be removed from the repository.

54. How do you undo the last Git commit, keeping the changes in the working directory?

To undo the last Git commit while keeping the changes in the working directory, you can use the command git reset HEAD~1 . This command moves the branch pointer to the previous commit, effectively removing the last commit from the commit history but keeping the changes in the working directory.

55. What is the purpose of the git revert command?

The git revert command is used to create a new commit that undoes the changes made in a specific commit. It allows you to revert commits without rewriting history and provides a safe way to undo changes while preserving the commit history.

56. How do you update your local repository with the latest changes from the remote repository?

To update your local repository with the latest changes from the remote repository, you can use the command git pull . This command fetches the latest commits from the remote repository and automatically merges them into your current branch.

57. What is the purpose of the .gitignore file?

The .gitignore file specifies files and directories that Git should ignore. It is used to prevent certain files from being tracked or committed to the repository, such as temporary files, build artifacts, and sensitive information. It helps keep the repository clean and avoids unnecessary commits.

58. How do you create a new branch in Git and switch to it?

To create a new branch in Git and switch to it, you can use the command git checkout -b <branch-name> . This command creates a new branch with the specified name and switches to it. Alternatively, you can use the following two commands separately: git branch <branch-name> to create the branch, and git checkout <branch-name> to switch to it.

59. How do you delete a branch in Git?

To delete a branch in Git, you can use the command git branch -d <branch-name> . This command deletes the specified branch. If the branch has unmerged changes, Git will prevent deletion unless you use the -D option, which forces the deletion of the branch.

60. What is the purpose of the git stash command?

The git stash command is used to save changes that are not ready to be committed yet. It allows you to temporarily save your modifications and switch to a different branch without committing them. Later, you can apply the stashed changes to the current branch or another branch.