What is HEAD in Git?

G

Greg Hewgill

You can think of the HEAD as the "current branch". When you switch branches with git checkout, the HEAD revision changes to point to the tip of the new branch.

You can see what HEAD points to by doing:

cat .git/HEAD

In my case, the output is:

$ cat .git/HEAD
ref: refs/heads/master

It is possible for HEAD to refer to a specific revision that is not associated with a branch name. This situation is called a detached HEAD.

So git HEAD is context dependent on which BRANCH you are on, correct? Even further, you as a developer? I guess I'm asking, Is Git HEAD going to be a repository-wide global thing, or individual for each dev?

@bobobobo: That's right, HEAD is like a pointer that points to the current branch. When you checkout a different branch, HEAD changes to point to the new one. The current HEAD is local to each repository, and is therefore individual for each developer.

@動靜能量: HEAD can point to any commit, it does not need to be the last commit in any branch. (When HEAD points to a commit that is not the last commit in a branch, that is a "detached HEAD").

HEAD is not "the current branch". Is is the name given to the commit from which the working tree's current state was initialized. In more practical terms, it can be thought of as a symbolic reference to the checked-out commit.

Voted down. I agree with @BenCollins. In my opinion the first sentence is quite confusing, and could be rephrased to: "You can think of the HEAD as the current commit on the current branch"

n

nCardot

To quote other people:

A head is simply a reference to a commit object. Each head has a name (branch name or tag name, etc). By default, there is a head in every repository called master. A repository can contain any number of heads. At any given time, one head is selected as the “current head.” This head is aliased to HEAD, always in capitals". Note this difference: a “head” (lowercase) refers to any one of the named heads in the repository; “HEAD” (uppercase) refers exclusively to the currently active head. This distinction is used frequently in Git documentation.

Another good source that quickly covers the inner workings of git (and therefore a better understanding of heads/HEAD) can be found here. References (ref:) or heads or branches can be considered like post-it notes stuck onto commits in the commit history. Usually they point to the tip of series of commits, but they can be moved around with git checkout or git reset etc.

From this: "Each head has a name". And "one head is selected as the “current head.” This head is aliased to HEAD". So i conclude from this that "HEAD" does not refer to situation of "detached HEAD" state.

@gxyd if it is the case that HEAD doesn't point to a 'head', it is a detached HEAD. It is pointing at the commit id of the commit you have specified (using, for example, git checkout HEAD~2), which is not the commit id of a known head. See the article at eagain.net/articles/git-for-computer-scientists for a more thorough explanation.

@Silfheed: Generally I think this answer is conceptually more sound than the accepted one (even though using lowercase "head" to refer to a branch confuses many people). However git revert isn't a good example of moving a branch to not be at the tip, because git revert just creates some new commits and still leaves the current branch at the (new) tip.

"which is not the commit id of a known head" - Actually, a detached HEAD can be pointing at a commit ID which is also the commit ID of a known head (or several heads). What makes it detached is that the HEAD is pointing directly to the commit ID, not to a head. This will affect the behavior of future commits, resets, etc.

@LarsH: Good point on a detached HEAD pointing at a commit ID instead of a reference. You can actually verify this by looking at .git/HEAD. If it is detached, it will contain the hash of a commit, even if it's the same commit as a known head. If it is attached, it will contain the path to the head (ie 'ref: refs/heads/bob'). As for the revert command, after 8 years I never caught that typo. Git reset is what allows you to adjust a particular head to point to a particular commit.

C

Community

There is a, perhaps subtle, but important misconception in a number these answers. I thought I'd add my answer to clear it up.

What is HEAD?

HEAD is YOU

HEADis a symbolic reference pointing to wherever you are in your commit history. It follows you wherever you go, whatever you do, like a shadow. If you make a commit, HEAD will move. If you checkout something, HEAD will move. Whatever you do, if you have moved somewhere new in your commit history, HEAD has moved along with you. To address one common misconception: you cannot detach yourself from HEAD. That is not what a detached HEAD state is. If you ever find yourself thinking: "oh no, i'm in detached HEAD state! I've lost my HEAD!" Remember, it's your HEAD. HEAD is you. You haven't detached from the HEAD, you and your HEAD have detached from something else.

What can HEAD attach to?

HEAD can point to a commit, yes, but typically it does not. Let me say that again. Typically HEAD does not point to a commit. It points to a branch reference. It is attached to that branch, and when you do certain things (e.g., commit or reset), the attached branch will move along with HEAD. You can see what it is pointing to by looking under the hood.

cat .git/HEAD

Normally you'll get something like this:

ref: refs/heads/master

Sometimes you'll get something like this:

a3c485d9688e3c6bc14b06ca1529f0e78edd3f86

That's what happens when HEAD points directly to a commit. This is called a detached HEAD, because HEAD is pointing to something other than a branch reference. If you make a commit in this state, master, no longer being attached to HEAD, will no longer move along with you. It does not matter where that commit is. You could be on the same commit as your master branch, but if HEAD is pointing to the commit rather than the branch, it is detached and a new commit will not be associated with a branch reference.

You can look at this graphically if you try the following exercise. From a git repository, run this. You'll get something slightly different, but they key bits will be there. When it is time to checkout the commit directly, just use whatever abbreviated hash you get from the first output (here it is a3c485d).

git checkout master
git log --pretty=format:"%h:  %d" -1
# a3c485d:   (HEAD -> master)

git checkout a3c485d -q # (-q is for dramatic effect)
git log --pretty=format:"%h:  %d" -1   
# a3c485d:   (HEAD, master)

OK, so there is a small difference in the output here. Checking out the commit directly (instead of the branch) gives us a comma instead of an arrow. What do you think, are we in a detached HEAD state? HEAD is still referring to a specific revision that is associated with a branch name. We're still on the master branch, aren't we?

Now try:

git status
# HEAD detached at a3c485d

Nope. We're in 'detached HEAD' state.

You can see the same representation of (HEAD -> branch) vs. (HEAD, branch) with git log -1.

In conclusion

HEAD is you. It points to whatever you checked out, wherever you are. Typically that is not a commit, it is a branch. If HEAD does point to a commit (or tag), even if it's the same commit (or tag) that a branch also points to, you (and HEAD) have been detached from that branch. Since you don't have a branch attached to you, the branch won't follow along with you as you make new commits. HEAD, however, will.

I like this answer, because while the documentation describes truth, the software defines truth. .git/HEAD is what the software considers to be HEAD.

For its conceptual definition alone, this should be the accepted answer.

I really think this is the best answer. The others imply that HEAD is the tip of a branch, but it is not, it is like a tape head. A really easy way to see this in action is git checkout HEAD~1 to go back one commit, then git checkout HEAD~1 to go back another commit. If HEAD always referred to the most recent commit on a branch the second command would be the same as the first - it is not. The second command moves your HEAD back one more time, i.e. you are now two commits from the tip of the branch. It's subtle but important.

I liked your expression "HEAD is YOU".

D

DavidRR

HEAD is just a special pointer that points to the local branch you’re currently on.

From the Pro Git book, chapter 3.1 Git Branching - Branches in a Nutshell, in the section Creating a New Branch:

What happens if you create a new branch? Well, doing so creates a new pointer for you to move around. Let’s say you create a new branch called testing. You do this with the git branch command: $ git branch testing This creates a new pointer at the same commit you’re currently on How does Git know what branch you’re currently on? It keeps a special pointer called HEAD. Note that this is a lot different than the concept of HEAD in other VCSs you may be used to, such as Subversion or CVS. In Git, this is a pointer to the local branch you’re currently on. In this case, you’re still on master. The git branch command only created a new branch — it didn’t switch to that branch.

Nice, could use a picture showing the detached HEAD case though

@DonHatch, Good explanation of detached HEAD stackoverflow.com/a/35301963/1074179

Nice answer. Branches are nothing but labeled commits, when you make new commits , this label is moved to the new new commit. When you checkout a commit that doesn't have a label , it's in detached HEAD state. That means HEAD is pointing to a commit that doesn't have a branch label. If you checkout 34ac2 in above example, now HEAD would be pointing to that commit and it's called a detached HEAD. In this state, you can make changes, experiment, and commit changes too, but once you checkout a different branch, you'd lose all your changes, unless of course you create a new branch.

@sleepwalkerfx but you can checkout a commit that has a branch label and still be in detached head state because your HEAD is no longer pointing to the branch label but the branch's commit id

@sleepwalkerfx I think we're talking about semantics at this point. You are correct a branch label is a text reference to a particular commit. It is, however, not a commit. So if you did a git log and got something like commit ad0265... HEAD -> foo ... that would mean the foo branch is a reference to commit id ad0265. Doing a checkout of the text reference foo is not a detached head. Doing a checkout of the commit id ad0265 would result in a detached head. May be I'm missing some subtlety of what you're communicating. I hope this wall of text helps discover where I'm lost.

R

Rob Bednark

I recommend this definition from github developer Scott Chacon [video reference]:

Head is your current branch. It is a symbolic reference. It is a reference to a branch. You always have HEAD, but HEAD will be pointing to one of these other pointers, to one of the branches that you're on. It is the parent of your next commit. It is what should be what was last checked-out into your working directory... This is the last known state of what your working directory was.

The whole video will give a fair introduction to the whole git system so I also recommend you to watch it all if have the time to.

So the true def is "the parent of your next commit"

and also "the thing pointing at the next branch that will move"

@nicolas - I don't think that is true. HEAD can point at any commit, it does not necessarily have to point at a branch - when it does not, you are in "detached HEAD" mode.

The video is great, but unfortunately, it makes an ill-suited answer for Stack Overflow. What if the video is taken down sometime in the future? Then your link will point to nothing. A better answer would include a transcript of what Scott says in the video.

Scott says HEAD is a pointer to a branch. But HEAD can point to old commits too. This is sooo confusing.

n

nonopolarity

Assuming it is not a special case called "detached HEAD", then, as stated in the O'Reilly Git book, 2nd edtion, p.69, HEAD means:

HEAD always refers to the most recent commit on the current branch. When you change branches, HEAD is updated to refer to the new branch’s latest commit.

so

HEAD is the "tip" of the current branch.

Note that we can use HEAD to refer to the most recent commit, and use HEAD~ as the commit before the tip, and HEAD~~ or HEAD~2 as the commit even earlier, and so forth.

C

Community

HEAD refers to the current commit that your working copy points to, i.e. the commit you currently have checked-out. From the official Linux Kernel documentation on specifying Git revisions:

HEAD names the commit on which you based the changes in the working tree.

Note, however, that in the upcoming version 1.8.4 of Git, @ can also be used as a shorthand for HEAD, as noted by Git contributor Junio C Hamano in his Git Blame blog:

Instead of typing "HEAD", you can say "@" instead, e.g. "git log @".

Stack Overflow user VonC also found some interesting information on why @ was chosen as a shorthand in his answer to another question.

Also of interest, in some environments it's not necessary to capitalize HEAD, specifically in operating systems that use case-insensitive file systems, specifically Windows and OS X.

C

Cody Gray

Take a look at Creating and playing with branches

HEAD is actually a file whose contents determines where the HEAD variable refers:

$ cat .git/HEAD
ref: refs/heads/master
$ cat .git/refs/heads/master
35ede5c916f88d8ba5a9dd6afd69fcaf773f70ed

In this repository, the contents of the HEAD file refers to a second file named refs/heads/master. The file refs/heads/master contains the hash of the most recent commit on the master branch.

The result is HEAD points to the master branch commit from the .git/refs/heads/master file.

https://i.stack.imgur.com/kYkB8.png

u

user3751385

After reading all of the previous answers, I still wanted more clarity. This blog at the official git website http://git-scm.com/blog gave me what I was looking for:

The HEAD: Pointer to last commit snapshot, next parent

The HEAD in Git is the pointer to the current branch reference, which is in turn a pointer to the last commit you made or the last commit that was checked out into your working directory. That also means it will be the parent of the next commit you do. It's generally simplest to think of it as HEAD is the snapshot of your last commit.

The HEAD: last commit snapshot, next parent is not accurate. HEAD is not a commit; it points to one.

No need for sarcasm; before your edit, even though the quote was accurate, the big bold letters were a simplification and a bit misleading. Now, it's better.

IF you read the next line: The HEAD in Git is the pointer to the current branch reference, which is in turn a pointer to the last commit you made or the last commit that was checked out into your working directory. -- Please note the use of the word "pointer" there.

While the "last commit snapshot" description does give a conceptual feel for how HEAD is typically supposed to be used, it's really not accurate. If I make a commit, then switch to another branch, HEAD doesn't point to the last commit snapshot anymore. It points to the last commit snapshot on the branch I just switched to. If I checkout HEAD^, now HEAD doesn't even point to the last commit snapshot on any branch.

"The parent of your next commit (if you were to commit right now)" is more accurate, but there are many other operations in git besides commit that are affected by HEAD. Really, in the end, HEAD is HEAD, and its nature is defined by how it affects commands like commit, merge, rebase, log, etc. But conceptually maybe "(pointer to) the current position" is a good summary.

m

mike

I'd just like to detail a few things in Greg Hewgil's accepted answer. According to the Git Pocket Guide

Branch:

the branch itself is defined as all points reachable in the commit graph from the named commit (the “tip” of the branch).

HEAD: A special type of Ref

The special ref HEAD determines what branch you are on...

Refs

Git defines two kinds of references, or named pointers, which it calls “refs”: A simple ref, which points directly to an object ID (usually a commit or tag) A symbolic ref (or symref), which points to another ref (either simple or symbolic)

As Greg mentioned, HEAD can be in a "detached state". So HEAD can be either a simple ref (for a detached HEAD) or a symref.

if HEAD is a symbolic ref for an existing branch, then you are “on” that branch. If, on the other hand, HEAD is a simple ref directly naming a commit by its SHA-1 ID, then you are not “on” any branch, but rather in “detached HEAD” mode, which happens when you check out some earlier commit to examine.

Thank you, @mike! This is the first answer that clarifies what happens when you check out an earlier commit. Looking at the book on the git website, I got the impression that a "detached HEAD" was a pathological state you only got into if you did some weird rebasing thing. But checking out an earlier commit is not a strange thing to do, and when you do that, HEAD is not "the tip of the current branch." So this is the first time I feel like I actually understand.

A

Alexis Määttä Vinkler

What is HEAD in Git? (conceptually)

HEAD is a pointer to the currently checked out branch or commit, it answers the question: Where am I right now in the repository? Or, in other words, it's Git's way of knowing on which commit to mirror your local Working Tree on, and whether you're currently working on a branch (attached) or not (detached).

Detached HEAD

HEAD can be in either of two states, attached or detached, depending on if you've checked out a branch or not. Default state is attached, where any manipulation to the history is automatically recorded to the branch HEAD is currently referencing.

In detached state experimental changes can be made without impacting any existing branch. See infographic below illustrating the difference between committing in attached vs detached state.

https://i.stack.imgur.com/vaQxa.png

A common misconception is that the message You are in 'detached HEAD' state is of erroneous tone, when in fact it just describes how HEAD is referencing the current snapshot.

Operations than can leave HEAD in detached state:

Checking out a particular commit, i.e. $ git checkout 14ko3

Explicitly checking out a remote branch, i.e. $ git checkout origin/master

Switching to a branch using the detached flag, i.e. $ git switch master --detached

Checking out a tag, i.e. $ git checkout v1.0.1

Performing an interactive rebase, or a regular rebase containing conflicting changes

Moving from detached to attached state

To move from detached to attached state, you can either create a new branch from where you're at, or switch back to an existing branch.

Note: any commits created in detached state will eventually (post garbage collection) be discarded if you switch to another existing branch, without first persisting your changes in a new branch.

Inspecting the state of HEAD

Figuring out which state HEAD is currently in can be done in different ways, here are two options.

Using show $ git show HEAD --oneline 14ko3 (HEAD, master) C1 # If attached, the output would have been 14ko3 (HEAD -> master) C1

Using status $ git status HEAD detached at 14ko3

What is HEAD exactly? (technically)

If you ever want to explicitly see what HEAD is referencing you can always inspect the .git/HEAD file, which is the actual file Git uses internally to manage HEAD. The file contains the name of the branch or commit hash depending on if HEAD is detached or not.

$ cat .git/HEAD
ref: refs/heads/master

# If detached, the output would have been
14ko36e295f1a98ec57397b3acc7bc247da61ff5

Source: Above excerpt is taken from this full length post on the subject: What is HEAD in Git?

Hi Alexis, your blogs on git is one of the most inspirational contents I ever read about git, thanks a lot!

@Jeff Thanks for your nice comment, it's feedback like this that keeps motivating me to write more! I'm happy you found it useful.

N

Nataraj

I think 'HEAD' is current check out commit. In other words 'HEAD' points to the commit that is currently checked out.

If you have just cloned and not checked out I don't know what it points to, probably some invalid location.

Yes, the special reference HEAD is whatever commit you've currently got checked-out. See the manual for details (relevant paragraph immediately follows Fig 3.4).

If you clone a repository, git will by default check out the master branch - so HEAD will point to master.

@sleske if you clone a repository with no special options git will check out the remote head. it is usually master, but it is not always. See remote set-head

My previous comment was correct except for the reference to remote set-head, which only impacts the local default branch, and won't change the default at the server.

t

tjb

A great way to drive home the point made in the correct answers is to run git reflog HEAD, you get a history of all of the places HEAD has pointed.

s

stack1

Head points to the tip of the currently checked out branch.

https://i.stack.imgur.com/IstVN.png

In your repository, there is a .git folder. Open the file in this location: .git\refs\heads. The (sha-1 hash) code in that file (master in most cases) will be the most recent commit, i.e the one seen in the output of the command git log. More info on the .git folder: http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html

It's a common misconception that the tip of the current branch points to the most recent commit. Typically that's true, but it's also not uncommon to git reset HEAD^, and then the most recent commit (the former tip) is no longer pointed to by the tip of the branch.

V

Vertexwahn

It feels like that HEAD is just a tag for the last commit that you checked out.

This can be the tip of a specific branch (such as "master") or some in-between commit of a branch ("detached head")

A

Anwar Husain

In addition to all definitions, the thing that stuck in my mind was, when you make a commit, GIT creates a commit object within the repository. Commit objects should have a parent ( or multiple parents if it is a merge commit). Now, how does git know the parent of the current commit? So HEAD is a pointer to the (reference of the) last commit which will become the parent of the current commit.

S

S R Chaitanya

Git is all about commits.
And Head points to the commit which you currently checked out.

$ git cat-file -t HEAD
commit

Whenever you checkout a branch, the HEAD points to the latest commit on that branch. Contents of HEAD can checked as below (for master branch):

$ cat .git/refs/heads/master
  b089141cc8a7d89d606b2f7c15bfdc48640a8e25

J

Jerry Chen

I am also still figuring out the internals of git, and have figured out this so far:

Let's say the current branch is master.

HEAD is a file in your .git/ directory that normally looks something like this:

% cat .git/HEAD
ref: refs/heads/master

refs/heads/master is itself a file that normally has the hash value of the latest commit of master:

% cat .git/refs/heads/master 
f342e66eb1158247a98d74152a1b91543ece31b4

If you do a git log, you will see that this is the latest commit for master:

% git log --oneline 
f342e66 (HEAD -> master,...) latest commit
fa99692 parent of latest commit

So my thinking is the HEAD file is a convenient way to track the latest commit, instead of remembering long hash values.

G

Goma

HEAD is nearly literally the head of the branch. So when you are observing a branch, you are looking at the latest commit, which is this same head of the branch. However, you can point yourself to be looking at another commit further back in the history of this branch, and when you do that, you are moving the HEAD to a previous commit. As the HEAD belonged naturally to the latest commit in the branch, it is considered detached.

A visual representation. Each branch is a caterpillar, and each commit is a segment of the creature. So the HEAD will be in the segment that is most ahead. If you remove the HEAD from that to another segment to be used, you have detached the head from the natural segment. Hope it makes any sense.

Now if you detach the HEAD in the main branch, then checkout newFeature, and checkout main again, the HEAD will still be detached, and on top of another commit. I see the HEAD as a looking glass that you can point at where you want.

M

Marcus Thornton

These two may confusing you:

head

Pointing to named references a branch recently submitted. Unless you use the package reference , heads typically stored in $ GIT_DIR/refs/heads/.

HEAD

Current branch, or your working tree is usually generated from the tree HEAD is pointing to. HEAD must point to a head, except you are using a detached HEAD.

T

Ting Wang

Take a look at http://git-scm.com/book/en/Git-Branching-What-a-Branch-Is

Figure 3-5. HEAD file pointing to the branch you’re on.

Link only answers are generally frowned upon on Stackoverflow, please inline the relevant information in your answer.

This isn't entirely correct. What HEAD refers to depends on whether you're talking about a bare vs a non-bare repo. In the context of a non-bare repo, it effectively refers to the currently checked-out commit, which doesn't require there to be a branch attached to it (i.e. when in detached HEAD state).

O

Okd

A branch is actually a pointer that holds a commit ID such as 17a5. HEAD is a pointer to a branch the user is currently working on.

HEAD has a reference filw which looks like this:

ref:

You can check these files by accessing .git/HEAD .git/refs that are in the repository you are working in.

M

Mahdi mehrabi

HEAD actually is just a file for storing current branch info

and if you use HEAD in your git commands you are pointing to your current branch

you can see the data of this file by cat .git/HEAD

F

Faizan Makandar

There can be multiple heads in a repository. And total number of heads is always equals to total number of branches present in the repository,which means heads are nothing but latest commits of each branch

But there will be only one HEAD for a repository.HEAD is a reference which references the latest commit done at the current branch.

Its like eye of git user.Whichever commit the HEAD is referencing to, the repository starts reflecting the condition the repository had during that particular commit.

The basic nature of HEAD is to always refer the latest commit of current branch but we can move HEAD to any commit of the current branch by using git checkout "commit-hash"

Note: We can easily get commit-hash by using command git log --oneline

d

dukeofgaming

As a concept, the head is the latest revision in a branch. If you have more than one head per named branch you probably created it when doing local commits without merging, effectively creating an unnamed branch.

To have a "clean" repository, you should have one head per named branch and always merge to a named branch after you worked locally.

This is also true for Mercurial.

This is true for Mercurial, but not for Git.

What is HEAD in Git?

Follow WeChat

Want to stay one step ahead of the latest teleworks?

相似问题

Platform

Support

Links

Contact US