-
- Joined
- Mar 22, 2026
-
- Messages
- 292
-
- Reaction score
- 0
-
- Points
- 0
Git branches are a fundamental concept in version control, allowing developers to work on different features, bug fixes, or experiments in isolation without affecting the main codebase. Understanding and effectively utilizing branches is key to collaborative development and maintaining a stable project.
What are Git Branches?
At its core, a Git branch is simply a lightweight movable pointer to one of your commits. When you make a commit, Git creates a new commit object and the branch pointer for the current branch moves to that new commit. The
Why use branches?
Core Branching Commands
Let's dive into the essential commands for managing branches.
1. Listing Branches:
To see all local branches in your repository, use:
The currently active branch will be marked with an asterisk (
To see both local and remote branches:
2. Creating a New Branch:
To create a new branch named
This command creates the branch but keeps you on your current branch.
3. Switching Branches:
To move to an existing branch (e.g.,
Or, with newer Git versions (2.23+), the more semantic
When you switch branches, your working directory and staging area will update to reflect the state of that branch.
4. Creating and Switching (Combined):
This is a common workflow. To create a new branch and immediately switch to it:
Or using
Merging Branches
Once you've completed work on a feature branch, you'll typically want to integrate those changes back into a more stable branch, like
1. Switch to the Target Branch:
First, switch to the branch you want to merge *into* (e.g.,
2. Perform the Merge:
Now, merge your feature branch (
Merge Types:
* Fast-Forward Merge: If the target branch (
* Three-Way Merge: If the target branch has new commits that your feature branch doesn't have, Git performs a three-way merge, combining the changes from both branches and creating a new "merge commit". This commit has two parent commits (the head of
3. Resolving Merge Conflicts:
Sometimes, Git cannot automatically combine changes. This happens when the same lines of code (or nearby lines) have been modified differently in both branches. Git will pause the merge and mark the conflicting files.
You'll see messages like:
To resolve:
* Open the conflicting file(s). Git inserts markers (
* Manually edit the file to choose which changes to keep, or combine them.
* After resolving, add the file(s) to the staging area:
* Complete the merge by committing:
Rebasing Branches (Advanced)
Rebasing is an alternative way to integrate changes from one branch onto another, but it rewrites commit history. Instead of creating a merge commit, rebasing moves or combines a sequence of commits to a new base commit.
When to use rebase:
How to rebase:
Assume you are on
1. Ensure
2. Switch back to your feature branch:
3. Perform the rebase:
Git will take all commits from
If conflicts occur during rebase, resolve them, then use
Deleting Branches
After merging a feature branch, you'll often want to delete it to keep your repository clean.
1. Delete a Local Branch (Safe):
This command will only delete the branch if it has been fully merged into its upstream branch (or
2. Delete a Local Branch (Force):
Use
3. Delete a Remote Branch:
After deleting a local branch, you might also want to delete the corresponding branch on your remote repository (e.g., GitHub, GitLab).
Or, a shorter syntax:
Best Practices for Branching
Mastering Git branches is a journey, not a destination. Practice these commands regularly, understand the implications of merging vs. rebasing, and you'll become a much more effective and collaborative developer.
What are Git Branches?
At its core, a Git branch is simply a lightweight movable pointer to one of your commits. When you make a commit, Git creates a new commit object and the branch pointer for the current branch moves to that new commit. The
main (or master) branch is the default branch in most Git repositories, representing the official project history.Why use branches?
- Isolation: Work on new features or bug fixes without breaking the stable
mainbranch. - Parallel Development: Multiple developers can work on different aspects of a project simultaneously.
- Experimentation: Try out new ideas without committing them to the main line of development.
- Code Review: Branches facilitate code review workflows (e.g., pull requests).
Core Branching Commands
Let's dive into the essential commands for managing branches.
1. Listing Branches:
To see all local branches in your repository, use:
Code:
bash
git branch*).To see both local and remote branches:
Code:
bash
git branch -a2. Creating a New Branch:
To create a new branch named
feature/login, use:
Code:
bash
git branch feature/login3. Switching Branches:
To move to an existing branch (e.g.,
feature/login), use:
Code:
bash
git checkout feature/loginswitch command:
Code:
bash
git switch feature/login4. Creating and Switching (Combined):
This is a common workflow. To create a new branch and immediately switch to it:
Code:
bash
git checkout -b feature/user-profileswitch:
Code:
bash
git switch -c feature/user-profileMerging Branches
Once you've completed work on a feature branch, you'll typically want to integrate those changes back into a more stable branch, like
main. This is done using git merge.1. Switch to the Target Branch:
First, switch to the branch you want to merge *into* (e.g.,
main).
Code:
bash
git switch main2. Perform the Merge:
Now, merge your feature branch (
feature/user-profile) into main:
Code:
bash
git merge feature/user-profileMerge Types:
* Fast-Forward Merge: If the target branch (
main) hasn't diverged from your feature branch since you created it, Git will simply move the main pointer forward to the latest commit of your feature branch. No new merge commit is created.* Three-Way Merge: If the target branch has new commits that your feature branch doesn't have, Git performs a three-way merge, combining the changes from both branches and creating a new "merge commit". This commit has two parent commits (the head of
main and the head of feature/user-profile).3. Resolving Merge Conflicts:
Sometimes, Git cannot automatically combine changes. This happens when the same lines of code (or nearby lines) have been modified differently in both branches. Git will pause the merge and mark the conflicting files.
You'll see messages like:
Code:
Auto-merging <file-name>
CONFLICT (content): Merge conflict in <file-name>
Automatic merge failed; fix conflicts and then commit the result.* Open the conflicting file(s). Git inserts markers (
<<<<<<<, =======, >>>>>>>) to show the conflicting sections.* Manually edit the file to choose which changes to keep, or combine them.
* After resolving, add the file(s) to the staging area:
Code:
bash
git add <conflicting-file>
Code:
bash
git commit -m "Merge branch 'feature/user-profile' into main"Rebasing Branches (Advanced)
Rebasing is an alternative way to integrate changes from one branch onto another, but it rewrites commit history. Instead of creating a merge commit, rebasing moves or combines a sequence of commits to a new base commit.
When to use rebase:
- To maintain a linear project history, avoiding extra merge commits.
- To clean up a feature branch before merging into
main(e.g., squashing multiple small commits into one larger, meaningful commit). - Crucial Rule: Never rebase branches that have been pushed to a shared remote repository and other developers might have based their work on. Rewriting shared history can cause significant problems for collaborators. Only rebase your *private* branches.
How to rebase:
Assume you are on
feature/login and want to rebase it onto the latest main:1. Ensure
main is up-to-date:
Code:
bash
git switch main
git pull origin main
Code:
bash
git switch feature/login
Code:
bash
git rebase mainfeature/login that are not on main, replay them one by one on top of the latest main commit.If conflicts occur during rebase, resolve them, then use
git add <file> and git rebase --continue. To abort, use git rebase --abort.Deleting Branches
After merging a feature branch, you'll often want to delete it to keep your repository clean.
1. Delete a Local Branch (Safe):
This command will only delete the branch if it has been fully merged into its upstream branch (or
HEAD).
Code:
bash
git branch -d feature/login2. Delete a Local Branch (Force):
Use
-D (capital D) to force delete a branch, even if it hasn't been merged. Be careful with this, as you could lose unmerged work.
Code:
bash
git branch -D buggy-experiment3. Delete a Remote Branch:
After deleting a local branch, you might also want to delete the corresponding branch on your remote repository (e.g., GitHub, GitLab).
Code:
bash
git push origin --delete feature/login
Code:
bash
git push origin :feature/loginBest Practices for Branching
- Keep
mainClean: Themainbranch should always be stable and deployable. - Feature Branches: Create a new branch for every new feature or significant bug fix. Name them descriptively (e.g.,
feature/add-user-auth,bugfix/fix-login-error). - Small, Frequent Commits: Make small, focused commits on your feature branch.
- Push Regularly: Push your feature branches to the remote often to back up your work and facilitate collaboration.
- Pull Requests/Merge Requests: Use these mechanisms for code review before merging into
main. - Branching Models: Consider adopting a branching model like GitFlow or GitHub Flow for larger projects to standardize your workflow.
Mastering Git branches is a journey, not a destination. Practice these commands regularly, understand the implications of merging vs. rebasing, and you'll become a much more effective and collaborative developer.