Git Checkout | Atlassian Git Tutorial

This page is an examination of the git checkout command. It will cover use examples and extreme cases. In Git terms, a checkout is the act of switching between different versions of a target entity. The git checkout command operates on three distinct entities: files, commits, and branches. In addition to the definition of “checkout”, the phrase “checkout” is commonly used to imply the act of executing the git checkout command. In the Undo Changes topic, we saw how git checkout can be used to view old commits. Most of this document will focus on payment transactions in branches.

Extracting branches is similar to extracting old commits and files in that the working directory is updated to match the selected branch or revision; however, new changes are saved in the project history, that is, it is not a read-only operation.

Check out


The git checkout command allows you to navigate between branches created by the git branch. Decommissioning a branch updates the files in the working directory to match the version stored in that branch and instructs Git to log all new commits to that branch. Think of it as a way to select which line of development you’re working on.

Having a dedicated branch for each new feature is a dramatic change from a traditional SVN workflow. It makes it ridiculously easy to test new experiments without the fear of destroying existing functionality, and makes it possible to work on many unrelated features at the same time. In addition, branch offices also facilitate various collaborative workflows.

The git

checkout command can occasionally be confused with git clone. The difference between the two commands is that the clone works to get code from a remote repository, alternatively, the checkout works to switch between versions of code that are already on the local system.

Usage: Existing


Assuming that the repository you are working in contains pre-existing branches, you can switch between these branches using git checkout. To find out which branches are available and what the name of the current branch is, run the git branch.

The previous example shows how to view a list of available branches by running the git branch command and switch to a specified branch, in this case, the feature_inprogress_branch.

New branches

The Git checkout works hand in hand with the git branch. The git branch command can be used to create a new branch. When you want to start a new feature, create a new branch outside main using git branch new_branch. Once created, you can use the git payment new_branch to switch to that branch. In addition, the git checkout command accepts a -b argument that acts as a convenience method that will create the new branch and immediately switch to it. You can work on multiple features in a single repository by switching between them with git checkout.

The preceding example simultaneously creates and unchecks out . The -b option is a convenience indicator that tells Git to run the git branch before running git checkout. By default, git checkout –

b will base the new branch on the current HEAD. An optional additional branch parameter can be passed to git checkout. In the example above, you pass which then bases the new branch on the existing branch instead of the current HEAD



branches Branch switching is a simple operation. Running the following will point HEAD to the tip of


Git tracks a history of payment transactions in the reflog. You can run git reflog to view the history.

Git Checkout a remote branch office

When collaborating with a team, it is common to use remote repositories. These repositories can be hosted and shared or they can be another colleague’s local copy. Each remote repository will contain its own set of branches. To retire a remote branch office, you must first obtain the contents of the branch office.

git fetch -all In modern versions of Git, you can retire the remote branch as a local branch.

Older versions of Git require the creation of

a new branch based on the remote control.

In addition, you can check out a new local branch and reset it to the last commit of the remote branches.


Now that we’ve looked at the top three uses

of git

checkout in branch offices, it’s important to discuss “HEAD separated” status. Remember that HEAD is how Git refers to the current snapshot. Internally, the git checkout command simply updates the HEAD to point to the specified branch or commit. When you point to a branch, Git doesn’t complain, but when you review a commit, it changes to a “separate HEAD” state.

This is a warning that tells you that everything you are doing is “separate” from the rest of your project’s development. If you started developing a feature while in a separate HEAD state, there would be no branch that would allow you to return to it. When you inevitably check another branch (for example, to merge your characteristic), there would be no way to refer to your characteristic:

Adjoint head vs separate head

The point is that its development should always take place on a branch, never on a separate HEAD. This ensures that you always have a reference to your new confirmations. However, if you’re just looking at an old engagement, it doesn’t really matter if you’re in a separate HEAD state or not.


This page focused on using the git checkout command when changing branches. In summary, git checkout, when used in branches, alters the target of the HEAD reference. It can be used to create branch offices, switch branches, and retire remote branch offices. The git checkout command is an essential tool for standard Git operation. It is a counterpart to git merge. The git checkout and git merge commands are critical tools for enabling git workflows.