Creating and Switching Branches

Creating branches is a normal part of everyday Git work. For example, if you are about to build a login feature, you might create a branch called:

feature/login

and do all login-related work there.

Viewing Existing Branches

Use:

git branch

to list local branches in the repository.

You may see:

* main
  feature/login

The * shows which branch you are currently on. In this example, the current branch is main.

You can also run:

git status

and Git will usually show:

On branch main

Creating a New Branch

To create a branch, use:

git branch <branch-name>

For example:

git branch feature/login

This creates the branch, but it does not switch to it.

If you run:

git branch

again, you may see:

  feature/login
* main

The new branch exists, but you are still on main.

Switching Branches with git switch

To move to an existing branch, use:

git switch <branch-name>

For example:

git switch feature/login

Now:

git branch

may show:

* feature/login
  main

Any new commits you create will now belong to feature/login.

Create feature/login, switch to it, and confirm the HEAD position.

Creating and Switching in One Step

In real work, you often want to create a branch and immediately start using it. You can do that with:

git switch -c <branch-name>

For example:

git switch -c feature/payment

The -c means create.

This is essentially the same as running:

git branch feature/payment

followed by:

git switch feature/payment

Because it combines both operations, git switch -c is very convenient.

Naming Branches

Git does not force you to follow one branch naming style, but clear names make a repository much easier to understand.

For feature work, you might use:

feature/login
feature/payment
feature/user-profile

For bug fixes:

fix/login-error
fix/payment-timeout

Simpler names are also fine:

login-feature
payment-fix

The exact style is less important than making the purpose of the branch obvious.

Be Careful with Uncommitted Changes

Suppose you are working on feature/login and have modified several files but have not committed them yet. If you try to switch branches, Git may carry those changes with you, or it may stop you if the switch would overwrite something.

A good beginner habit is to check:

git status

before switching branches.

If your current work is ready, you can commit it first:

git add .
git commit -m "Add login form"

Then switch branches.

This keeps your work easier to understand and avoids unnecessary confusion.

A Simple Example

Suppose you are currently on main:

git branch

Output:

* main

Create and switch to a branch for the login feature:

git switch -c feature/login

Make your changes, then commit them:

git add .
git commit -m "Add login page"

That commit now belongs to feature/login.

If you switch back:

git switch main

the login changes may no longer appear in your working files. The changes are not lost; they belong to the other branch.

Switch back again:

git switch feature/login

and the code returns.

This is one of the key ideas behind branches: different branches can represent different versions of the project at the same time.