A Beginner's Guide to Version Control Git

Git is a powerful user-friendly version control system for tracking changes in your code. It allows you to collaborate effectively revert to previous versions and maintain a clear history of your project's evolution.

Understanding the Git Workflow

Imagine Git as a digital filing cabinet for your project's code. It stores various snapshots (called commits) of your code at different points in time. Each commit has a unique identifier and a message describing the changes made. This enables you to easily navigate back to any previous version of your code if needed.

Essential Git Commands:

Creating a New Branch:

Before making changes to your project's main codebase, it's good practice to create a new branch. This allows you to experiment and isolate your changes without affecting the main code. Use the following command to create a new branch named "my-new-feature":

git checkout -b my-new-feature

Switching Branches:

To switch between existing branches, use the following command:

git checkout branch-name

Adding and Committing Changes:

Once you've made changes to your code, you need to stage them (add them to the next commit) using:

git add <file_name>

You can then commit your staged changes with a descriptive message:

git commit -m "Added new feature X"

Cloning a Repository:

To obtain a copy of a remote repository (e.g., hosted on GitHub), use the following command, replacing <url> with the repository's URL:

git clone <url>

Deleting a Branch:

To delete a branch that is no longer needed, use:

git branch -d my-deleted-branch

Important Note: This command permanently deletes the branch. Ensure you don't need the branch before deleting it.

Reverting a Commit:

Sometimes, you might need to undo a specific commit. Git doesn't directly remove commits, but it allows you to create a new "revert commit" that effectively reverses the changes introduced in the previous commit. Use the following command:

git revert <commit_hash>

7. Understanding Git Rebase:

Rebase rewrites your commit history by applying your commits from a branch on top of another branch (usually the main branch). This can be useful for cleaning up your commit history, but use it cautiously, as it can potentially rewrite shared history, causing issues for collaborators.

8. Installing Git on Windows:

Download the official Git installer from https://git-scm.com/downloads and follow the installation instructions.

9. Removing Untracked Files:

Git tracks only files that have been added using git add. To remove untracked files (e.g., temporary files) from your working directory, use:

git clean -f

Important Note: This command permanently deletes untracked files. Use it with caution and ensure you don't need the files before running the command.

Step-by-Step Guide

Deleting a Branch in Git: A Step-by-Step Guide

Here's how to delete a branch in Git, ensuring you do it safely and effectively:

Switch Branches (Optional):

It's essential to not be on the branch you want to delete. Use the following command to switch to a different branch:

git checkout <branch_name>

Replace <branch_name> with the name of the branch you want to be on (e.g., main, master).

Delete the Branch:

Once you're on a different branch, use the following command to delete the unwanted branch:

git branch -d <branch_name>

Replace <branch_name> with the actual name of the branch you want to delete.

Verify the Deletion:

Use the following command to list all branches and confirm the deleted branch is no longer present:

git branch

Important Note:

• The -d flag in the deletion command indicates that the branch will only be deleted if it has been merged into another branch. If the branch hasn't been merged, you'll encounter an error message.
• To force the deletion of a branch that hasn't been merged, use the following command (use with caution):

git branch -D <branch_name>

This command permanently deletes the branch, even if it hasn't been merged. Be absolutely certain you want to delete the branch before using this option.

Additional Tips:

• Always double-check the branch name before deleting to avoid accidentally removing the wrong branch.
• Consider using a graphical Git client like GitKraken or GitHub Desktop for a more visual representation of your branches and deletion process.

By following these steps, you can effectively delete unwanted branches in your Git workflow. Remember to use caution when force-deleting branches, especially in collaborative projects.

Switching Branches in Git: A Step-by-Step Guide

Here's a simple guide on how to switch branches in Git:

List Branches:

Start by listing all available branches in your local repository using the following command:

git branch

This command will display a list of branches, indicating the currently active branch with an asterisk (*).

Identify the Target Branch:

Decide which branch you want to switch to. This could be an existing branch or a newly created one.

Switch Branches:

Use the following command to switch to your desired branch, replacing <branch_name> with the actual name:

git checkout <branch_name>

Verify the Switch (Optional):

Run the git branch command again to confirm that the asterisk (*) has moved next to the newly selected branch, indicating it's now the active branch.

Additional Notes:

• If the branch you want to switch to doesn't exist locally, you will need to create it before switching. You can create a new branch and switch to it simultaneously using the following command:

git checkout -b <branch_name>

• This command combines the functionalities of git branch (to create the branch) and git checkout (to switch to it).

Reverting a Commit in Git: A Step-by-Step Guide

There are two main ways to "undo" changes in Git:

Using git revert (Recommended):

This method creates a new commit that effectively reverses the changes introduced in the commit you want to undo. It's generally the safer and preferred approach.

Steps:

1. Identify the commit hash: Use the git log command to view your commit history. Locate the commit you want to revert and note down its unique hash identifier (a long alphanumeric string).
2. Execute the revert command: Run the following command, replacing <commit_hash> with the actual hash of the commit you want to revert:

git revert <commit_hash>

3. Write a commit message: Git will prompt you to enter a new commit message explaining why you're reverting the changes. Provide a clear and concise description.
4. Review and stage changes (optional): Git might automatically stage some files affected by the revert. You can review the changes using git status and stage/unstage specific files using git add or git reset commands if needed.
5. Commit the revert: Once satisfied, commit the revert with your chosen message using git commit.

Using git reset (Caution Needed):

Warning: This method directly rewrites your Git history and should be used with caution, especially in collaborative projects. It's generally recommended to use git revert as explained above for safer undo operations.

Steps:

1. Identify the commit hash: Follow step 1 from the git revert method.
2. Execute the reset command: Use the following command, replacing <commit_hash> with the actual hash:

git reset --hard <commit_hash>

Important Note: This command permanently discards all changes introduced after the specified commit, including any commits, staged changes, and uncommitted changes. Make sure you understand the implications before using this method.

How to clone a branch in git : A Step-by-Step Guide

There's a subtle difference between cloning a branch and simply cloning a repository. While cloning a repository fetches all branches and the remote HEAD (usually "master" or "main"), cloning a specific branch downloads only that particular branch. Here's how to achieve both scenarios:

Clone a Specific Branch:

Step 1: Identify the branch name. This information should be available in the repository you want to clone.

Step 2: Use the git clone command with the -b flag:

git clone -b <branch_name> <url>

• Replace <branch_name> with the actual name of the branch you want to clone.
• Replace <url> with the URL of the remote repository you want to clone from.

Example:

git clone -b feature/new-login-system https://github.com/username/my-project.git

This command will clone only the "feature/new-login-system" branch from the "username/my-project" repository on GitHub.

Clone the Entire Repository and Checkout a Specific Branch:

Step 1: Perform a regular clone:

git clone <url>

Replace <url> with the URL of the remote repository.

Step 2: Navigate to the cloned directory:

cd <cloned_directory_name>

Step 3: Checkout the desired branch:

git checkout <branch_name>

Replace <branch_name> with the name of the branch you want to switch to.

Example:

git clone https://github.com/username/my-project.git
cd my-project
git checkout feature/new-login-system

This approach first clones the entire repository and then switches to the specific "feature/new-login-system" branch within the local copy.

Creating a New Branch in Git: A Step-by-Step Guide

Here's how to create a new branch in Git:

Ensure you're in the desired starting point:

Before creating your new branch, use git status to check the current branch and any uncommitted changes. If you have uncommitted changes and want to keep them for the new branch, you should commit them before proceeding.

Use the git checkout command with the -b flag:

git checkout -b <branch_name>

• Replace <branch_name> with the desired name for your new branch. Choose a descriptive name that reflects the purpose of the branch.

Example:

git checkout -b fix-login-bug

This command will create a new branch named "fix-login-bug" and simultaneously switch you to that branch.

Verify the creation (optional):

Use the git branch command to list all branches and confirm that your newly created branch is present.

git branch

The asterisk (*) next to the branch name indicates the currently active branch.

Additional Notes:

• You can also create a new branch without switching to it by omitting the -b flag:

git branch <branch_name>

This will only create the branch, leaving you on your current branch. You can then use git checkout <branch_name> to switch to the newly created branch later.

• When creating a new branch, it's generally recommended to base it on the latest commit of the "main" or "master" branch. This ensures your new branch starts with a clean and stable history.

Frequently Asked Questions about Git