Git Branch | How To Create, Merge, & Delete Branches (With Syntax)

Git is a powerful version control system that helps developers to manage their codebase efficiently. Git Branches are one of the fundamental features that make Git so useful. Git Branches allow developers to create parallel versions of their codebase, where they can experiment with new features, make changes, and fix bugs without affecting the main codebase. This article will cover Git Branches in detail, explaining what they are, how to create and manage them, and how they can be used to streamline the development process.

What Is Branch In Git?

A Git Branch is a parallel version of the main codebase. In other words, it is a separate timeline of the codebase where developers can make changes without affecting the main codebase. A branch in Git basically represents an isolated line of development. Every Git Branch has its own set of pointers to commits, which means that developers can make changes to one branch without affecting other branches making the master branch free from questionable code. Git Branches are used to create new features, fix bugs, and test new ideas without disturbing the stability of the main codebase. It is a feature present in most modern version control systems.

Why Are Git Branches Essential?

Git branches are essential for several reasons, which are:

They allow developers to work on different parts of the codebase simultaneously without interfering with each other's everyday development process. For example, if one developer is working on a new feature, they can create a branch for that feature and work on it independently without worrying about other changes being made to the main codebase. They can also check the previous versions, everyday workflow, project history, repository history, code base, and current commit in the feature branch.
Branches allow developers to experiment with new ideas and approaches without affecting the disk space and stability of the main codebase. If a new feature is not working as expected, it can be abandoned or refined in the branch without affecting the main codebase.
Git Branches enable developers to collaborate on code changes effectively. By creating a separate branch for a specific feature or bug fix, developers can work together to make changes in the lines of development and review each other's unstable code before merging it back into the main codebase.

How To Create A New Git Branch?

Creating a new Git Branch is a straightforward process. Instead of copying files from directory to directory, Git stores a branch as a reference to a previous commit. First, the developer must decide on a name for the new branch head. This name should be descriptive and should reflect the purpose of the new branch head. For example, if a new branch is being created to add a new feature to the codebase, the name of the branch could be "feature/add-new-feature." Once the name of the new branch has been decided, the developer can create the new branch using the Git command:

git branch <branch-name>

For example, to create a new branch named "feature/add-new-feature," the developer would use the following command:

git branch feature/add-new-feature

After the new branch has been created, the developer can switch to the new branch using the Git command:

git checkout <branch-name>

For example, to switch to the new branch named "feature/add-new-feature," the developer would use the following command:

git checkout feature/add-new-feature

Managing Git Branches

Once a new Git Branch has been created, the developer can start making changes to the codebase in that branch. As the development process progresses, the developer may need to merge changes from one branch into another. For example, if a bug is discovered in the main codebase, the developer may need to create a new branch to fix the bug. Once the bug has been fixed, the developer can merge the changes from the bug-fix branch back into the main codebase.

Merging Git Branches

Merging Git Branches is the process of combining the changes from one branch into another to a local or remote repository. When merging Git Branches, Git uses a "three-way merge" algorithm to determine which changes should be kept and which should be discarded. The three-way merge algorithm compares the changes in three different versions of the codebase: the two branches being merged and the common ancestor of the two branches present in the remote repository.

To merge one branch into another in a remote repository, the developer must first switch to the branch that will receive the changes. For example, if the changes in the "feature/add-new-feature" branch need to be merged into the main codebase, the developer would switch to the default branch using the Git command:

git checkout <main-branch>

Once the developer has switched to the main branch, they can use the Git Merge command:

git merge <branch-to-merge>

For example, to merge the changes from the "feature/add-new-feature" branch into the main codebase, the developer would use the following command:

git merge feature/add-new-feature

How To Delete A Git Branch?

In Git, you can delete a branch using the git branch -d command. This command deletes the specified branch, but it will fail if the branch has unmerged changes. If you want the branch deletion regardless of whether it has unmerged changes, you can use the git branch -D command instead.

Here are the steps to delete a Git branch:

First, make sure that you are not currently on the branch that you want to delete. You can use the git branch command to list all branches in your repository, and the currently active base branch will be marked with an asterisk (*).

$ git branch
master
* feature-branch
new-branch

Switch to a different branch by using the git checkout command. Replace [branch-name] with the name of the branch you want to switch to.

$ git checkout master

Delete the branch using the git branch -d command. Replace [branch-name] with the name of the branch you want to delete.

$ git branch -d feature-branch

If the branch has unmerged changes and you still want to delete it, use the git branch -D command instead:

$ git branch -D feature-branch

After you delete a branch, it will no longer appear in the output of the git branch command. However, the branch's commit history will still be preserved in the repository's commit history.

Git Branch: Commands

Git branch commands are used to manage branches in a Git repository. Here are some commonly used Git branch operations and commands :

git branch: This command lists all the branches in the current Git repository.
git branch <branch-name>: This command creates a new branch with the specified name.
git checkout <branch-name>: This Git checkout command switches to the specified master branch.
git checkout -b <branch-name>: This Git checkout command creates a new branch with the specified name and switches to it.
git merge <branch-name>: This command merges the specified branch into the current branch. It is used to check the merged status of the master branch.
git branch -d <branch-name>: This command lists the current branch for deletion i.e. it deletes the unneeded branch.
git branch -m <old-branch-name> <new-branch-name>: The -M <Branch> command renames the specified upstream branch from the old name to the new name.
git branch -a: This command lists all local and remote branches from the master in the current Git repository.
git branch -r: This command lists all remote branches after creation in the current Git repository.
git branch -v: This command lists all branches with the last commit message in the current directory.
git branch --merged: This command lists all branches that have been merged into the master branch.
git branch --no-merged: This command lists all branches that have not been merged into the default branches.
git branch -t: This command allows you to create a new local branch that is set up to track a start-point branch. This means that when you push or pull changes to the previous commit object and from the remote-tracking branches, Git will automatically know which branch to use.

By now, you must know all about Git Branch. Read the following to learn about other interesting topics:

Shivani Goyal

Manager, Content

I am an economics graduate using my qualifications and life skills to observe & absorb what life has to offer. A strong believer in 'Don't die before you are dead' philosophy, at Unstop I am producing content that resonates and enables you to be #Unstoppable. When I don't have to be presentable for the job, I'd be elbow deep in paint/ pencil residue, immersed in a good read or socializing in the flesh.

Updated On: 14 Aug'23, 09:27 AM IST