Skip to content

Latest commit

 

History

History
200 lines (122 loc) · 7.45 KB

15_Git Interview Q&A and Commands.md

File metadata and controls

200 lines (122 loc) · 7.45 KB
Raw

DevOps Diary - Day 11 | Git Interview Q&A and Commands

Introduction

Welcome to Day 11 of our DevOps Diary! Today, we'll focus on Git, a fundamental tool in the DevOps toolbox. We'll cover some common Git interview questions and essential Git commands that every DevOps practitioner should be familiar with.

Git Interview Questions

Let's start with some common Git interview questions and brief explanations: Certainly! Here's a combined list of Git interview questions and answers, including both the previous set and the new set:

Q1: What is Git?

Answer: Git is a distributed version control system that allows developers to track changes in their codebase, collaborate with others, and manage different versions of a project efficiently.

Q2: What is the difference between Git and GitHub?

Answer: Git is the version control system itself, while GitHub is a web-based platform that provides Git repository hosting, collaboration features, and additional tools for software development.

Q3: What are Git branches, and why are they important?

Answer: Git branches are separate lines of development within a Git repository. They allow developers to work on different features or fixes simultaneously, keeping changes isolated and enabling efficient collaboration.

Q4: Explain the difference between a merge and a rebase.

Answer:

  • Merge: Merging combines changes from one branch into another, creating a new commit that incorporates the changes. Merge commits retain the history of both branches.
  • Rebase: Rebasing moves or combines a sequence of commits to a new base commit, usually the latest commit on another branch. It results in a linear commit history but can rewrite commit hashes.

Q5: How do you resolve a merge conflict in Git?

Answer: To resolve a merge conflict, follow these steps:

  1. Identify the conflicting files and open them in a text editor.
  2. Manually edit the files to resolve conflicts, removing conflict markers (e.g., <<<<<<<, =======, >>>>>>>).
  3. Save the changes.
  4. Add the resolved files to the staging area using git add.
  5. Commit the changes to complete the merge.

Q6: What is a Git repository?

Answer: A Git repository is a storage location where Git tracks the changes to files and directories over time. It contains the entire history of a project, including all the commits, branches, and tags.

Q7: What is the Git staging area?

Answer: The staging area, also known as the index, is an intermediate area in Git where you prepare changes to be committed. You use git add to stage changes before creating a commit.

Q8: How do you undo the last commit in Git?

Answer: To undo the last commit while keeping the changes in your working directory, you can use the following command:

git reset HEAD~1

This command moves the branch pointer back one commit, effectively "uncommitting" the last commit.

Q9: Explain the purpose of .gitignore in a Git repository.

Answer: The .gitignore file is used to specify files and directories that should be ignored by Git. It prevents Git from tracking files that don't need to be versioned, such as build artifacts, log files, and sensitive data.

Q10: What is a Git remote?

Answer: A Git remote is a reference to a remote repository where your Git project is stored, typically on a server. It allows you to interact with and synchronize changes between your local repository and the remote repository. Common remote commands include git remote add, git remote remove, and git remote -v to list remotes.

Q11: How do you create and apply Git patches?

Answer: To create a Git patch for a specific commit, you can use the git format-patch command. For example:

git format-patch -1 <commit_sha>

To apply a patch, you can use the git apply command:

git apply <patch_file>

Q12: What is Git rebase, and when would you use it?

Answer: Git rebase is a command used to move or combine a series of commits onto a new base commit. It's often used to maintain a linear and clean commit history. You might use rebase to integrate changes from one branch into another, update your feature branch with the latest changes from develop, or squash multiple commits into one before merging.

Q13: Explain the difference between git pull and git fetch.

Answer:

  • git pull: This command fetches changes from a remote repository and automatically merges them into the current branch. It's a combination of git fetch followed by git merge.
  • git fetch: This command fetches changes from a remote repository and updates the remote-tracking branches in your local repository but does not automatically merge them. It allows you to review changes before merging.

Q14: How do you create and apply Git patches?

Answer: To create a Git patch for a specific commit, you can use the git format-patch command. For example:

git format-patch -1 <commit_sha>

To apply a patch, you can use the git apply command:

git apply <patch_file>

Q15: Explain the difference between Git and SVN (Subversion).

Answer:

  • Distributed vs. Centralized: Git is a distributed version control system, meaning each user has a complete copy of the repository. SVN is centralized, with a single central repository that users check out from.
  • Commit Model: Git commits are more granular and represent changesets, while SVN commits are more like snapshots of the entire project.
  • Branching: Git excels at branching and merging, making it easier to work on multiple features simultaneously. SVN's branching can be more challenging.
  • Offline Work: Git allows users to work offline and commit changes locally, while SVN requires a connection to the central repository.

Essential Git Commands for DevOps

Here are some essential Git commands that every DevOps practitioner should know:

1. Initialize a New Git Repository

To start tracking changes in a project, use the following commands:

git init

2. Clone a Repository

To make a copy of a remote Git repository on your local machine, use:

git clone <repository_url>

3. Create a New Branch

To create a new branch for feature development or bug fixes:

git checkout -b <branch_name>

4. Commit Changes

To save changes in the working directory to the local repository:

git commit -m "Your commit message here"

5. Push Changes

To upload local commits to a remote repository (e.g., GitHub):

git push <remote_name> <branch_name>

6. Pull Changes

To fetch and merge changes from a remote repository into your local branch:

git pull <remote_name> <branch_name>

7. Merge Branches

To merge changes from one branch into another:

git merge <branch_name>

8. Rebase Commits

To rebase your branch on top of another branch:

git rebase <base_branch>

9. Check Repository Status

To see the status of your Git repository (e.g., modified files, untracked files):

git status

10. View Commit History

To view the commit history of your repository:

git log

Conclusion

Being proficient in Git is crucial for DevOps professionals. Understanding these interview questions and mastering these essential Git commands will help you navigate version control effectively in your DevOps journey.

That concludes Day 11 of our DevOps Diary. Stay tuned for more DevOps insights and best practices!