Git Interview Questions for DevOps and Testers

YatinJanuary 23rd, 2024Last Updated: January 23rd, 2024

0 84 13 minutes read

Git, a distributed version control system, revolutionizes how developers manage and collaborate on software projects. Its efficiency in tracking changes, maintaining project history, and enabling seamless collaboration has made it an integral part of modern software development. With a plethora of commands at developer’s disposal, Git empowers them to handle tasks ranging from staging changes and committing to branching, merging, and resolving conflicts. Let us delve to understanding Git.

1. What is Git?

Git is a version control system used in software development to manage and track changes to code over time.
It was created by Linus Torvalds, the creator of Linux, in 2005 and has become a popular tool in software development.
Git allows developers to create and manage multiple branches of code, making it easier to experiment and collaborate without affecting the main codebase.
It provides features for merging changes from different branches, resolving conflicts, and reviewing code changes before they are merged into the main codebase.
Git provides a safety net for development by allowing developers to easily revert to a previous version of their code if something goes wrong.
Git can be integrated with other tools and services, such as continuous integration and deployment systems, making it an important part of modern software development workflows.
Git is important because it provides an efficient and reliable way for developers to manage and collaborate on code, helping to streamline the software development process and improve code quality.

1.1 What is Origin in Git?

In Git, origin is the default name given to the remote repository from which a local repository was cloned. It serves as a reference to the original repository and is often used as a default when pushing or pulling changes. For example, you might run git push origin master to push changes from your local master branch to the master branch on the remote repository named origin.

1.2 What is a Git repository? How to Initialize a Git Repository?

A Git repository is a storage space where your project’s version-controlled files and their history are stored. It includes the entire project’s history, branches, configurations, and more. To initialize a Git repository, navigate to your project’s root directory in the terminal and use the following command:

git init

This command initializes a new Git repository in the current directory, creating the necessary hidden .git folder to store Git’s internal data. It’s the first step in tracking and managing changes in your project. For example, to initialize a repository for a new project:

-- Make a new folder
mkdir my-project

-- Enter the new folder
cd my-project

-- Initialize it as a git repository
git init

1.3 Difference between Forking, Branching, and Cloning in Git?

Forking: Forking involves creating a copy of a repository on your GitHub account. This allows you to freely experiment with changes without affecting the original project. You can later submit pull requests to contribute changes back to the original repository.
Branching: Branching is the process of creating a separate line of development within the same repository. It enables developers to work on features or bug fixes in isolation, keeping the main branch (usually master) stable.
Cloning: Cloning creates a local copy of a repository on your machine. This local copy contains all the project’s files and commit history, allowing you to work on the code locally and contribute to the project.

1.4 What is the meaning of Staging Area in Git?

The Staging Area in Git is a temporary storage area where changes are prepared before committing them to the repository. It allows you to selectively include or exclude specific changes from the commit. By using git add to stage changes, you can craft well-organized and logical commits that represent a specific feature or bug fix.

1.5 Benefits of using Git

Git allows for efficient management and tracking of changes to code over time.
Developers can create and manage multiple branches of code, making it easier to experiment and collaborate without affecting the main codebase.
Git provides features for merging changes from different branches, resolving conflicts, and reviewing code changes before they are merged into the main codebase.
Developers can easily revert to a previous version of their code if something goes wrong, providing a safety net for development.
Git can be integrated with other tools and services, such as continuous integration and deployment systems, making it an important part of modern software development workflows.
Using Git can improve code quality by providing an efficient and reliable way for developers to manage and collaborate on code.
Git allows for easier collaboration among developers, making it easier to work on large projects with distributed teams.

1.6 How to install git on Windows?

If someone needs to go through the Git installation, please watch this video.

1.7 How to install git on Mac?

If someone needs to go through the Git installation, please watch this video.

2. Understanding Git terminology

2.1 What is Git Stash?

Git Stash is a command that allows you to save changes in your working directory that are not ready to be committed. It is useful when you need to switch to another branch or address an urgent issue without committing incomplete changes. The stash acts as a temporary storage for changes, and you can later apply or drop the stash as needed.

2.1.1 What is the purpose of the .gitignore file?

The .gitignore file is used to specify files and directories that should be ignored by Git. It helps prevent irrelevant or sensitive files from being included in the version control system. Common entries in this file include build artifacts, log files, and dependencies.

2.1.2 How to Add a File to the Staging Area?

Before committing changes in Git, you need to stage the modified files. Staging allows you to select which changes to include in the next commit. Here’s how to add a file to the staging area:

git add [file_name]

For example, to stage a file named example.txt, use:

git add example.txt

You can also use the following command to stage all changes in the working directory:

git add .

2.1.3 How to Commit Changes in the Staging Area with a Descriptive Message?

After staging the changes, the next step is to commit them with a meaningful message. A commit captures a snapshot of the changes at that moment. Here’s how to commit changes:

git commit -m "Your descriptive message here"

For example, to commit changes with the message “Add new feature”, use:

git commit -m "Add new feature"

2.1.4 How to Push Committed Changes to a Remote Repository?

Once changes are committed locally, you want to share them with a remote repository. Here’s how to push committed changes:

git push [remote_name] [branch_name]

For example, to push changes to the master branch on the origin remote repository, use:

git push origin master

Ensure you have the necessary permissions to push changes to the remote repository.

2.1.5 How Do You Undo the Last Commit in Git?

If you need to undo the last commit in Git, you can use the following command:

git reset --soft HEAD^

This command resets the current branch’s HEAD to the previous commit, keeping the changes staged. If you want to completely discard the last commit and unstage changes, use:

git reset --hard HEAD^

Be cautious with the hard option, as it irreversibly discards changes.

2.1.6 How to Unstage a File?

If you’ve added a file to the staging area but want to unstage it, use:

git reset [file_name]

This command removes the specified file from the staging area while keeping the changes in your working directory.

2.2 What is the difference between git fetch and git pull?

While both commands fetch changes from a remote repository, git fetch only retrieves changes without merging them into your working branch. It updates your local repository with changes made in the remote repository, but it leaves your working directory unchanged. On the other hand, git pull fetches and automatically merges the changes into your current branch, updating both your local repository and working directory.

2.3 What is Git checkout, rebase, and merge?

Git Checkout: The git checkout command is used to switch between branches or restore files in the working directory. For example, git checkout -b new-feature creates and switches to a new branch named new-feature.
Git Rebase: Git rebase combines the changes from one branch into another, creating a linear history. It is often used to integrate feature branches with the main branch while maintaining a clean and readable commit history.
Git Merge: Git merge integrates changes from different branches, creating a new commit that combines the branch histories. Merging is a common way to bring changes from a feature branch into the main branch.

2.4 What is the git cherry-pick command used for?

The git cherry-pick command is used to apply a specific commit from one branch to another. It allows you to select and incorporate individual commits without merging the entire branch. This is helpful when you want to pick specific changes without bringing in the entire set of modifications from another branch.

2.5 What is Git Resetting and Reverting?

Git Reset: Git reset is used to unstage changes in the staging area or reset the current branch to a specified commit. It can be used with different options like --soft, --mixed, or --hard to control the extent of the reset.
Git Revert: Git revert creates a new commit that undoes the changes made in a previous commit. This is a safer option than resetting when working with shared branches, as it maintains a linear commit history.

2.6 What is the difference between Git reflog and log?

Git Log: The git log command displays the commit history, showing information such as commit hashes, authors, dates, and commit messages. It provides a chronological view of the project’s development history.
Git Reflog: Git reflog shows a reference log, including the history of branch updates, merges, and other changes. Reflog is useful for recovering lost commits or branches, as it keeps a record of recent actions even if the branch pointer has moved.

2.7 What is the purpose of the git bisect command?

The git bisect command is used for binary searching through the commit history to find the commit where a bug was introduced. It helps identify the commit that introduced or fixed a particular issue by interactively narrowing down the search space.

2.8 How do we squash multiple commits into a single commit in Git?

To squash multiple commits into a single commit, you can use the interactive rebase with the git rebase -i command. This opens an interactive editor where you can mark commits for squashing. Squashing is useful for cleaning up the commit history and presenting changes more coherently and logically.

2.9 How to identify if a certain branch has been merged into Master?

To check if a branch has been merged into the master, you can use the git branch --merged command. It lists the branches that have been merged into the current branch (e.g., master). This helps ensure that changes from a feature branch are successfully integrated into the main branch before cleaning up the feature branch.

2.10 How to show the current status of the repository, including modified files and branch information?

To show the current status of the repository, use the following command:

git status

This command provides information about modified files, untracked files, and the current branch. It helps you understand the state of your working directory and what changes are ready to be committed. Git status is a powerful tool for keeping track of your changes and ensuring you commit the right files.

3. Experimenting Git

3.1 How do we configure a global username and email in Git?

To configure a global username and email in Git, you can use the following commands:

-- Set the username for all repositories
git config --global user.name "Your Name"

-- Set email address for all repositories
git config --global user.email "your.email@example.com"

These settings are used for all your Git repositories and help identify the author of the commits.

3.2 How to connect a local repository to a remote repository?

To connect a local repository to a remote repository, you can use the following steps:

Create a new repository on a hosting service like GitHub, GitLab, or Bitbucket. This is where your remote repository will be hosted.
Copy the remote repository URL provided by the hosting service.
In your local repository, use the following command to add the remote repository:

git remote add origin [remote_repository_URL]

For example:

git remote add origin https://github.com/your-username/your-repository.git

This command establishes a connection between your local repository and the remote repository. The term origin is a conventional name, but you can choose another name if you prefer. It allows you to push and pull changes between your local and remote repositories. After adding the remote, you can use commands like git push to upload changes to the remote repository and git pull to fetch changes from the remote repository to your local repository.

3.3 What is a Merge Conflict, and How Do You Resolve It?

A merge conflict occurs in Git when there are conflicting changes in different branches that Git cannot automatically merge. This typically happens when two branches modify the same part of a file, and Git is unable to determine which changes should take precedence. When a conflict arises, Git marks the conflicted areas, and it’s up to the user to resolve these conflicts manually.

3.3.1 Causes of Merge Conflicts

Parallel changes: When changes are made in the same part of a file in different branches.
Deleted modification: When one branch deletes a file or a line that another branch modified.
Renaming issues: Renaming a file in one branch while modifying the same file in another branch.

3.3.2 How to Identify a Merge Conflict?

When you attempt to merge branches and Git encounters conflicting changes, it will display a message indicating a conflict. Additionally, you can use the following command to check for unmerged files:

git status

3.3.3 Resolving a Merge Conflict

Follow these steps to resolve a merge conflict:

Open the conflicted file(s) in your code editor. Git marks the conflicted sections with special markers like <<<<<<<, =======, and >>>>>>>.
Manually edit the file to choose which changes to keep. Remove the conflict markers and unwanted changes, leaving only the desired modifications.
After resolving conflicts, save the file(s).
Mark the file(s) as resolved using the following command:
```
git add [conflicted_file]
```

Repeat this for all conflicted files. Once conflicts are resolved, complete the merge using:

git merge –continue

Or, if you were in the middle of a rebase:

git rebase --continue

After completing the merge, run:

git status

Ensure there are no unmerged files or conflicts. Additionally, review the changes with the git log command. If conflicts are too complex or you wish to start over, you can abort the merge using:

git merge –abort

Or, for a rebase:

git rebase --abort

By following these steps, you can successfully resolve merge conflicts in Git, ensuring a smooth integration of changes between branches.

3.4 How to List Existing Branches? How to Create a New Branch?

Git allows you to manage branches effectively. Here’s how to list existing branches and create a new one:

3.4.1 List Existing Branches

To list existing branches, use the following command:

git branch

This command displays a list of local branches, with the current branch highlighted. If you want to see remote branches as well, use:

git branch -a

3.4.2 Create a New Branch

To create a new branch, you can use:

git branch [new_branch_name]

3.5 How to Switch to a Specific Branch?

Switching between branches is a common Git operation. Here’s how to switch to a specific branch:

git checkout [existing_branch_name]

-- Create and Switch to a New Branch in One Command
git checkout -b [new_branch_name]

3.6 How to Merge Changes from a Different Branch into the Current Branch?

Merging allows you to integrate changes from one branch into another. Here’s how to merge changes:

-- Switch to the target branch
git checkout [target_branch]

-- Merge changes
git merge [source_branch]

This command merges changes from the specified source branch into the current target branch. Git will automatically perform the merge if it’s a straightforward process. In case of conflicts, you’ll need to resolve them manually.

3.7 How Do You Delete a Branch in Git?

Deleting branches that are no longer needed is good practice. Here’s how to delete a branch:

git branch -d [branch_name]

This command deletes the specified local branch. If the branch contains changes that are not merged, Git will prevent deletion unless you force it with:

git branch -D [branch_name]

3.7.1 Delete a Remote Branch

This command deletes the specified branch on the remote repository. Ensure you have the necessary permissions to delete branches on the remote repository.

git push origin --delete [remote_branch_name]

3.8 How Do You Pull Changes from a Remote Repository?

To incorporate changes from a remote repository into your local branch, you can use:

git pull [remote_name] [branch_name]

For example, to pull changes from the origin remote’s master branch, use:

git pull origin master

This command fetches changes and automatically merges them into your current local branch.

3.9 How Do You Show the Differences Between Two Commits?

To view the differences between two commits, use:

git diff [commit_hash1] [commit_hash2]

Replace [commit_hash1] and [commit_hash2] with the actual commit hashes you want to compare. This command displays the changes made between the specified commits.

3.10 How Do You Revert a Commit in Git?

If you need to revert a commit, you can use:

git revert [commit_hash]

This command creates a new commit that undoes the changes made in the specified commit. It’s a safe way to undo commits, especially if changes have been shared with others.

3.11 How Do You View the Commit History in Git?

To view the commit history of a repository, use:

git log

This command displays a chronological list of commits, including commit hashes, authors, dates, and commit messages. You can navigate through the history using arrow keys or press q to exit.

3.12 How to Remove a File from the Remote Repository?

To remove a file from both the working directory and the remote repository, use:

git rm [file_name]

This command stages the file deletion, and you need to commit and push the changes to the remote repository afterward.

4. Conclusion

In conclusion, mastering Git commands is essential for effective version control and collaboration in software development. The diverse range of operations, from staging changes and committing them with descriptive messages to branching, merging, and handling conflicts, empowers developers to manage their projects efficiently. Understanding how to navigate commit history, compare changes between commits, and revert changes provides valuable insights and control over the development process. Additionally, Git facilitates collaboration through operations like pulling changes from remote repositories and pushing local commits. Whether tracking changes in code, managing branches, or resolving conflicts, a solid understanding of Git commands empowers developers to work seamlessly and contribute effectively to collaborative projects. The versatility of Git makes it a cornerstone tool for version control, enabling developers to maintain a clear and organized development history while facilitating collaboration among team members.