A Comprehensive Guide to Git: Git Merge vs. Git Rebase and Essential Commands

Introduction

Git is a powerful version control system used by millions of developers worldwide to manage and track their source code changes. Whether you’re working solo or as part of a large team, understanding Git’s essential commands and techniques can make your development workflow smoother and more efficient. In this blog post, we’ll cover Git’s core functionalities, focusing on the differences between git merge and git rebase and how to set up and work with Git effectively. Let’s dive into some Git basics and later, we’ll explore more advanced techniques.

1. Setting Up Git

Before we begin with branching and merging strategies, it’s essential to set up Git with your personal preferences.

Configuring Git

After installing Git, you need to configure it with your name and email, which will be used in every commit.

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

You can also specify your default text editor for commits, merge messages, and other Git operations. For example, if you prefer Vim:

git config --global core.editor "vim"

Other options include nano, Visual Studio Code, and more. The choice is entirely up to you.

Creating Git Aliases

To save time typing out long Git commands, you can set up aliases. For instance, these are common shortcuts you might want to use:

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status

This way, instead of typing git checkout, you can simply use git co, speeding up your workflow.

2. Working with Branches in Git

Git allows developers to create multiple branches to work on features independently, providing a clean separation from the main codebase.

Creating and Switching Branches

To create a new branch and switch to it immediately, use:

git checkout -b new-branch

If you want to view a list of all branches, including remote ones, you can run:

git branch -a

Deleting Branches

Once a feature branch has been merged, it can be deleted to keep the repository clean:

git branch -d branch-name  # For merged branches
git branch -D branch-name  # For unmerged branches

Visualizing Branches

A typical branching strategy often includes a main branch (sometimes called master or main) and several feature branches. Here’s where things can get a bit tricky when it comes to combining branches: do you use git merge or git rebase?

Let’s now focus on the differences between the two commands.

3. Git Merge vs. Git Rebase: What’s the Difference?

When working on a feature branch, at some point, you’ll need to integrate your changes back into the main branch. The two most common strategies are git merge and git rebase. Understanding the distinction is crucial to maintaining a clean and readable project history.

The Basics of git merge

A git merge takes the contents of your feature branch and integrates it with the target branch (e.g., main). This results in a merge commit that combines both branches’ histories.

Example:

Suppose you have a feature branch feature that diverges from the main branch. When you execute git merge:

git checkout main
git merge feature

The commit history would look something like this:

A---B---C---D   (main branch)
     \       \
      E---F---G (feature branch)

After merging:

A---B---C---D---G'  (merged commit)
     \       /
      E---F---G

As you can see from the diagram, git merge creates a merge commit (labeled as G'), which records the integration of the two branches. This is a non-linear history but keeps a clear record of when the merge occurred.

The Basics of git rebase

Rebasing, on the other hand, rewrites the commit history. Instead of creating a new merge commit, git rebase integrates the changes by moving (or “replaying”) the commits from your feature branch on top of the main branch.

Example:

When you execute git rebase, Git replays the commits in your feature branch starting from the latest commit in the main branch. Here’s how you would use it:

git checkout feature
git rebase main

This results in a history that looks like this:

A---B---C---D  (main branch)
              \
               E'---F'---G' (feature branch, rebased)

Here, the feature branch’s commits are rewritten as if they had been based on the latest state of the main branch. There are no merge commits, and the history appears linear, which can make things cleaner but at the cost of losing a visual record of the branch divergence.

When to Use git merge vs. git rebase

Both merge and rebase have their pros and cons. Here’s a quick guide on when to use each:

• Use git merge when:
  • You want to preserve the historical context of a feature branch.
  • You are working in a team and want a clear visual record of branch integration.
• Use git rebase when:
  • You prefer a cleaner, linear history.
  • You are working on a personal branch that hasn’t been shared yet.

In general, teams often use merge when combining branches on shared repositories but opt for rebase during personal development to maintain clean commit histories.

4. Other Essential Git Commands

Beyond merging and rebasing, here are more essential Git commands for everyday use:

Viewing and Editing Commits

If you need to edit your last commit (e.g., to fix a message or add a forgotten file), you can use:

git commit --amend

Additionally, if you want to rebase interactively to squash multiple commits into one, you can run:

git rebase -i HEAD~3

This command allows you to edit the last three commits.

Working with Remote Repositories

To collaborate with others, you’ll frequently push and pull changes from a remote repository:

• Add a new remote: git remote add origin https://github.com/user/repo.git
• Pull the latest changes: git pull origin main
• Push your changes: git push origin main

Undoing Changes

Git offers several ways to undo changes:

• Reset the last commit but keep the changes in the working directory:
  • git reset --soft HEAD~1
• Reset the last commit and discard the changes:
  • git reset --hard HEAD~1

Stashing Changes

When you need to save your work temporarily without committing, use Git’s stash feature:

git stash
git stash pop  # Apply the changes again

5. Final Thoughts

Git is a powerful tool, but it can be overwhelming if you’re new to it. However, with practice, you’ll see how efficient it is at managing code. Whether you’re choosing between git merge and git rebase or mastering other Git essentials like branching, stashing, and remote collaboration, understanding these concepts will give you confidence and control over your development process.

Happy coding!

Explore more fascinating blog posts on our site!