Switching Between Branches (git checkout or git switch)

Switching between branches is a fundamental operation in Git, allowing developers to move their work environment to a specific line of development. Creating a new branch, for instance, using git branch <branch-name>, establishes a new pointer but does not automatically change your current development context. Your working directory always reflects the state of the branch you are actively on, which is often the main branch by default before switching.

To change your active working context to a different branch, you need to "check out" that branch. This action tells Git, "I want to work on this branch now." When you switch branches, Git performs two main tasks:

1. It updates the special pointer called HEAD to point to the tip of the branch you're switching to. HEAD usually points to the name of the branch you are currently on.
2. It modifies the files in your working directory to match the snapshot stored in the last commit of the target branch.

Think of it like having multiple project drafts laid out on different desks. Creating a branch is like setting up a new desk (git branch new-feature). Switching branches is like physically moving over to work at that new desk (git checkout new-feature or git switch new-feature), and the papers (files) on the desk change to reflect the state of that draft.

Using git checkout

Historically, the primary command for switching branches has been git checkout. Its usage is straightforward:

git checkout <branch-name>

For example, if you previously created a branch named fix-login-bug using git branch fix-login-bug, you would switch to it like this:

# Assuming you are currently on the 'main' branch
git checkout fix-login-bug

After running this command, Git will report:

Switched to branch 'fix-login-bug'

Now, any new commits you make will be added to the fix-login-bug branch, advancing its history independently from the main branch or any other branches. Your working directory files will reflect the state they were in at the last commit on fix-login-bug (which, if you just created it, will be the same as the commit you branched off from).

Introducing git switch (Modern Approach)

The git checkout command is quite versatile. Besides switching branches, it can also be used to restore files in the working directory from different commits or the index (staging area). This overlap in functionality sometimes caused confusion for newcomers.

To address this, newer versions of Git (starting from 2.23) introduced two more specific commands: git switch for changing branches and git restore for changing files. The git switch command is dedicated solely to branch operations, making its purpose clearer.

To switch to our fix-login-bug branch using git switch, you would run:

# Assuming you are currently on the 'main' branch
git switch fix-login-bug

The result is identical to using git checkout fix-login-bug:

Switched to branch 'fix-login-bug'

Your HEAD now points to fix-login-bug, and your working directory is updated accordingly.

Visualizing the Switch

Imagine your repository history looks like this initially, with HEAD pointing to the main branch:

HEAD pointing to main, which points to commit C3.

Now, you create a new branch feature-x from main using git branch feature-x. The HEAD pointer doesn't move yet.

feature-x created, both branches point to C3, HEAD still on main.

When you run git switch feature-x (or git checkout feature-x), Git updates HEAD:

HEAD now points to feature-x. Your working directory reflects commit C3 (initially). Subsequent commits will advance feature-x.

Important Notes

• Uncommitted Changes: Git tries to protect your work. If you have modifications in your working directory or staging area that conflict with the branch you are trying to switch to (meaning the switch would overwrite your changes), Git will usually prevent the switch and warn you. You'll typically need to commit your changes, stash them (a concept covered later), or discard them before you can switch branches.
• Creating and Switching: Both git checkout and git switch have options to create a new branch and immediately switch to it in one step.
  • git checkout -b <new-branch-name>
  • git switch -c <new-branch-name> This is a common shortcut, combining git branch <name> and git switch <name>.

Recommendation

While git checkout works perfectly fine for switching branches and is widely used in older tutorials and projects, using git switch is generally recommended for clarity if your Git version supports it. It makes the intent of your command unambiguous: you are switching your working context to a different branch.

Being able to swiftly move between different lines of development is fundamental to leveraging Git's branching power. You can now start a new feature on one branch, switch to another to fix an urgent bug, and then switch back to your feature, keeping the work isolated until you are ready to combine it.