How do I get the hash of the current commit in Git?
25 Answers
To turn any extended object reference into a hash, use git-rev-parse
:
git rev-parse HEAD
or
git rev-parse --verify HEAD
To retrieve the short hash:
git rev-parse --short HEAD
To turn references (e.g. branches and tags) into hashes, use git show-ref
and git for-each-ref
.
-
108
--verify
implies that:The parameter given must be usable as a single, valid object name. Otherwise barf and abort.
Commented Jul 24, 2011 at 17:50 -
707
git rev-parse --short HEAD
returns the short version of the hash, just in case anyone was wondering. Commented Oct 25, 2012 at 21:28 -
70Adding to what Thane said, you can also add a specific length to
--short
, such as--short=12
, to get a specific number of digits from the hash. Commented Feb 21, 2014 at 17:18 -
47@TysonPhalp:
--short=N
is about minimal number of digits; git uses larger number of digits if shortened one would be undistinguishable from shortened other commit. Try e.g.git rev-parse --short=2 HEAD
orgit log --oneline --abbrev=2
. Commented Feb 21, 2014 at 18:08 -
46Adding to what Thane, Tyson, and Jakub said, you can print the full hash, but highlight the hexits necessary to identify the commit blue with
git rev-parse HEAD | GREP_COLORS='ms=34;1' grep $(git rev-parse --short=0 HEAD)
– ZazCommented Aug 5, 2014 at 16:44
To get the shortened commit hash, use the %h
format specifier:
git log --pretty=format:'%h' -n 1
%H
represents the long commit hash. Also, -1
can be used directly in place of -n 1
.
-
117Or, it seems, adding --short to the rev-parse command above seems to work. Commented Sep 30, 2011 at 23:39
-
24I think
git log
is porcelain andgit rev-parse
is plumbing. Commented Jan 29, 2016 at 10:40 -
5This is a bad/ incorrect way of doing it because this method will give you the wrong hash if you have a detached head. For example if the current commit is 12ab34... and the previous commit was 33aa44... then if i do 'git checkout 33aa44' and then I run your command I will still be getting back 12ab34... despite my head actually pointing to 33aa44... Commented Jul 17, 2017 at 0:03
-
6@theQuestionMan I don't experience the behavior you describe;
git checkout 33aa44; git log -n 1
gives me33aa44
. What version of git are you using? Commented Jul 19, 2017 at 17:32 -
19@AmedeeVanGasse, ah! I HAD NO IDEA this is a toilet analogy! I've been seeing
porcelain
in thegit
man
pages for years, but had NO idea it was referring to a toilet! The porcelain is the toilet, and it's "closer to the user" (who figuratively sits on this toilet) than the plumbing, which is lower-level and farther from the user--ie: below the "porcelain"! Mind blown. Commented Feb 21, 2021 at 7:26
Another one, using git log:
git log -1 --format="%H"
It's very similar to the of @outofculture though a bit shorter.
-
1
-
12This is the correct answer, since it works even if you checkout a specific commit instead of
HEAD
.– ParsaCommented Feb 22, 2019 at 19:16 -
3@Parsa: when checking out a specific commit
HEAD
points to this commit rather than a named branche know as detached head. Commented Jan 28, 2020 at 20:46 -
2From the command line, to avoid pager:
git --no-pager log -1 --format="%H"
– ederagCommented May 9, 2021 at 20:27 -
1@Parsa - maybe we misunderstand each other: after checkout from commit a1b1 to c1d1
git rev-parse HEAD
prints c1d1. So, HEAD points to the "current commit" which the OP asked for. From your upvoted comment I mistakenly concluded thatgit rev-parse HEAD
was wrong.– spawnCommented May 17, 2022 at 12:31
To get the full SHA:
$ git rev-parse HEAD
cbf1b9a1be984a9f61b79a05f23b19f66d533537
To get the shortened version:
$ git rev-parse --short HEAD
cbf1b9a
-
If two
git
commit
hashes are needed, such as one from thebranch
you are currently working with and amaster
branch
, you could also usegit rev-parse FETCH_HEAD
if you need the hash for themaster
commit
that youmerge
d into your currentbranch
. e.g. if you havebranch
esmaster
andfeature/new-feature
for a given repo., while onfeature/new-feature
you could usegit fetch origin master && git merge FETCH_HEAD
and thengit rev-parse --short FETCH_HEAD
if you needed thecommit
hash from themaster
you justmerge
d in for any scripts you may have.– MikeCommented Sep 3, 2018 at 21:43
Commit hash
git show -s --format=%H
Abbreviated commit hash
git show -s --format=%h
The -s
flag is same as --no-patch
and stands for "Suppress diff output".
Click here for more git show
examples.
For completeness, since no one has suggested it yet. .git/refs/heads/master
is a file that contains only one line: the hash of the latest commit on master
. So you could just read it from there.
Or, as a command:
cat .git/refs/heads/master
Update:
Note that git now supports storing some head refs in the pack-ref file instead of as a file in the /refs/heads/ folder. https://www.kernel.org/pub/software/scm/git/docs/git-pack-refs.html
-
15This assumes the current branch is
master
, which is not necessarily true.– gavrieCommented Oct 23, 2012 at 15:10 -
13
-
23
.git/HEAD
typically points to a ref, if you have a SHA1 in there, you are in detached head mode.– eckesCommented Apr 9, 2013 at 1:48 -
11This isn't very robust compared to other approaches, in particular because it assumes that there is a
.git
subdirectory, which is not necessarily the case. See the--separate-git-dir
flag in thegit init
man page.– jub0bsCommented Dec 29, 2014 at 17:44 -
28+1 because sometimes you don't want git executable installed (e.g. in your Dockerfile)– wimCommented Apr 7, 2015 at 2:59
There's always git describe
as well. By default it gives you --
john@eleanor:/dev/shm/mpd/ncmpc/pkg (master)$ git describe --always
release-0.19-11-g7a68a75
-
19Git describe returns the first TAG reachable from a commit. How does this help me get the SHA? Commented Sep 9, 2011 at 13:45
-
49I like
git describe --long --dirty --abbrev=10 --tags
it will give me something like7.2.0.Final-447-g65bf4ef2d4
which is 447 commits after the 7.2.0.Final tag and the first 10 digest of the global SHA-1 at the current HEAD are "65bf4ef2d4". This is very good for version strings. With --long it will always add the count (-0-) and the hash, even if the tag happens to match exactly.– eckesCommented Apr 9, 2013 at 1:46 -
20If no tags exist then
git describe --always
will "show uniquely abbreviated commit object as fallback" Commented Sep 18, 2014 at 16:57 -
3I use
git describe --tags --first-parent --abbrev=11 --long --dirty --always
. The--always
option means it provides a result (hash) even if there are no tags. The--first-parent
means it doesn't get confused by merge commits and only follows items on the current branch. Note also that--dirty
will append-dirty
to the result if the current branch has uncommitted changes.– ingyhereCommented Jan 31, 2020 at 7:05
Use git rev-list --max-count=1 HEAD
-
4git-rev-list is about generating list of commit objects; it is git-rev-parse to translate object name (e.g. HEAD) into SHA-1 Commented Jun 4, 2009 at 14:13
If you need to store the hash in a variable during a script, you can use
last_commit=$(git rev-parse HEAD);
Or, if you only want the first 10 characters (like github.com does)
last_commit=$(git rev-parse --short=10 HEAD);
-
Thanks. I was able to use this in a build script:
now=$(date -u "+%Y-%m-%d %H:%M:%S") && last_commit=$(git rev-parse HEAD) && echo "{\"commit\": \"$last_commit\", \"build_time\": \"$now\"}" > version.json
– RyanCommented Nov 29, 2022 at 18:42
If you want the super-hacky way to do it:
cat .git/`cat .git/HEAD | cut -d \ -f 2`
Basically, git stores the location of HEAD in .git/HEAD, in the form ref: {path from .git}
. This command reads that out, slices off the "ref: ", and reads out whatever file it pointed to.
This, of course, will fail in detached-head mode, as HEAD won't be "ref:...", but the hash itself - but you know, I don't think you expect that much smarts in your bash one-liners. If you don't think semicolons are cheating, though...
HASH="ref: HEAD"; while [[ $HASH == ref\:* ]]; do HASH="$(cat ".git/$(echo $HASH | cut -d \ -f 2)")"; done; echo $HASH
-
3no need to install git, I like it. (my docker build image does not have git) Commented Feb 15, 2016 at 20:18
-
also useful because you can run this easily from outside the git repo– samaspinCommented Jun 22, 2016 at 16:30
-
2I formalized this to a script for my local machine. Then, I thought, hey: the implementation I made are simple enough that it illustrates how to solve an unrelated problem (parsing arguments in raw POSIX shell scripts without external programs), but complex enough to provide a little variation and to exploit most of the features of
sh
. Half an hour of documentation comments later, and here's a Gist of it: gist.github.com/Fordi/29b8d6d1ef1662b306bfc2bd99151b07– FordiCommented Jun 29, 2016 at 14:41 -
1Looking at it, I made a more extensive version for detecting Git and SVN, and grabbing the git hash/svn revision. Not a clean string this time, but easily command-line parsed, and usable as a version tag: gist.github.com/Fordi/8f1828efd820181f24302b292670b14e– FordiCommented Jun 29, 2016 at 15:21
I needed something a little more different: display the full sha1 of the commit, but append an asterisk to the end if the working directory is not clean. Unless I wanted to use multiple commands, none of the options in the previous answers work.
Here is the one liner that does:
git describe --always --abbrev=0 --match "NOT A TAG" --dirty="*"
Result: f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe*
Explanation: describes (using annotated tags) the current commit, but only with tags containing "NOT A TAG". Since tags cannot have spaces, this never matches a tag and since we want to show a result --always
, the command falls back displaying the full (--abbrev=0
) sha1 of the commit and it appends an asterisk if the working directory is --dirty
.
If you don't want to append the asterisk, this works like all the other commands in the previous answers:
git describe --always --abbrev=0 --match "NOT A TAG"
Result: f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe
-
Thanks, just stumbling over it and it spares me the one or other echo for that :)– hakreCommented Feb 23, 2018 at 20:43
-
2It works for me without the
--match "NOT A TAG"
. Tested in git 2.18.0 as well as 2.7.4. Is there any situation where this argument is needed?– ThomasCommented Aug 7, 2018 at 7:24 -
2@Thomas it won't work if you have an annotated tag anywhere in the history of the current commit. The fake tag makes sure that the describe command does not use a tag to describe the commit,– RadoCommented Aug 8, 2018 at 5:44
Perhaps you want an alias so you don't have to remember all the nifty details. After doing one of the below steps, you will be able to simply type:
$ git lastcommit
49c03fc679ab11534e1b4b35687b1225c365c630
Following up on the accepted answer, here are two ways to set this up:
- Teach git the explicit way by editing the global config (my original answer):
# open the git config editor
$ git config --global --edit
# in the alias section, add
...
[alias]
lastcommit = rev-parse HEAD
...
Or if you like a shortcut to teach git a shortcut, as recently commented by Adrien:
$ git config --global alias.lastcommit "rev-parse HEAD"
From here on, use git lastcommit
to show the last commit's hash.
git rev-parse HEAD
does the trick.
If you need to store it to checkout back later than saving actual branch if any may be preferable:
cat .git/HEAD
Example output:
ref: refs/heads/master
Parse it:
cat .git/HEAD | sed "s/^.\+ \(.\+\)$/\1/g"
If you have Windows then you may consider using wsl.exe:
wsl cat .git/HEAD | wsl sed "s/^.\+ \(.\+\)$/\1/g"
Output:
refs/heads/master
This value may be used to git checkout later but it becomes pointing to its SHA. To make it to point to the actual current branch by its name do:
wsl cat .git/HEAD | wsl sed "s/^.\+ \(.\+\)$/\1/g" | wsl sed "s/^refs\///g" | wsl sed "s/^heads\///g"
Output:
master
The most succinct way I know:
git show --pretty=%h
If you want a specific number of digits of the hash you can add:
--abbrev=n
-
16While this technically works,
git show
is what's known as a porcelain command (i.e. user-facing), and so should not be used in scripts because its output is subject to change. The answer above (git rev-parse --short HEAD
) should be used instead.– jm3Commented Mar 15, 2014 at 23:45 -
5@jm3 that's backwards. "Porcelain" commands have stable outputs that are intended for scripts. Search
git help show
forporcelain
. Commented Jul 6, 2015 at 21:32 -
4@JohnTyree This is a confusing subject, but jm3 was right: porcelain commands are not meant to be parsed, but rather to be human-readable. In case you need to use a porcelain command in a script and you want to have a stable format, there's sometimes (for example with git status, push and blame) an option that does just that. Unfortunately, that option is called
--porcelain
, which is why this is confusing. You can find the details in this great answer by VonC Commented Jan 14, 2019 at 17:20
Here is one-liner in Bash shell using direct read from git files:
(head=($(<.git/HEAD)); cat .git/${head[1]})
You need to run above command in your git root folder.
This method can be useful when you've repository files, but git
command has been not installed.
If won't work, check in .git/refs/heads
folder what kind of heads do you have present.
git show-ref --head --hash head
If you're going for speed though, the approach mentioned by Deestan
cat .git/refs/heads/<branch-name>
is significantly faster than any other method listed here so far.
-
1
show-ref
seems to me to be the best option for scripting, since it's a plumbing command and thus guaranteed (or at least very likely) to remain stable in future releases: other answers userev-parse
,show
,describe
, orlog
, which are all porcelain commands. And in cases where speed is not of the essence, the note from theshow-ref
manpage applies: ‘Use of this utility is encouraged in favor of directly accessing files under the .git directory.’– PontCommented Oct 8, 2018 at 18:21
in your home-dir in file ".gitconfig" add the following
[alias]
sha = rev-parse HEAD
then you will have an easier command to remember:
$ git sha
59fbfdbadb43ad0b6154c982c997041e9e53b600
On git bash, simply run $ git log -1
you will see, these lines following your command.
commit d25c95d88a5e8b7e15ba6c925a1631a5357095db .. (info about your head)
d25c95d88a5e8b7e15ba6c925a1631a5357095db, is your SHA for last commit.
Get the hash for the current commit, and see if git status
is "clean" or "dirty"
I want to see 72361c8
or 72361c8-dirty
for use in my build system version numbers injected into my program executables (as part of this MPLAB X IDE pre-build step). Here is how:
Quick summary
# get a short commit hash, and see whether `git status` is clean or dirty
test -z "$(git status --porcelain)" \
&& echo "$(git rev-parse --short HEAD)" \
|| echo "$(git rev-parse --short HEAD)-dirty"
Sample output when git status
is clean (there are no uncommitted changes):
72361c8
Sample output when git status
is dirty (there are any uncommitted changes):
- Meaning: there are any uncommitted changes, whether they are unstaged changes to tracked files, staged (
git add
ed) changes to tracked files, or the addition of new files
72361c8-dirty
Details
Just like git status
will show when a submodule is "clean" or "dirty" when using Git Submodules, I really want to see my short commit hash with the word -dirty
after it if git status
is dirty! I'm using this inside my build system as a version number in my software, so I can easily see exactly which software version I'm running at any moment!
So, I combined this answer (git rev-parse --short HEAD
) by @Jakub Narębski, and this answer: (test -n "$(git status --porcelain)"
) by @benzado on their answer to "Checking for a dirty index or untracked files with Git", I was able to come up with my "1-line" solution above.
The &&
part only runs if the return code to the previous command (git status --porcelain
) is 0
, meaning "success" (clean in this case), and the ||
part only runs if the return code of the previous command (git status --porcelain
) is any other error code, meaning "error" (dirty in this case).
Going further
See my bash/git_get_short_hash.sh file in my eRCaGuy_hello_world repo.
Wrap it in a git_get_short_hash
Bash function:
# From my answer: https://stackoverflow.com/a/76856090/4561887
# Get a short commit hash, and see whether `git status` is clean or dirty.
# Example outputs:
# 1. Not in a git repo: `(not a git repo)`
# 2. In a repo which has a "dirty" `git status`: `72361c8-dirty`
# - Note that "dirty" means there are pending uncommitted changes.
# 3. In a repo which has a "clean" `git status`: `72361c8`
git_get_short_hash() {
# See: https://stackoverflow.com/a/16925062/4561887
is_git_repo="$(git rev-parse --is-inside-work-tree 2>/dev/null)"
if [ "$is_git_repo" != "true" ]; then
echo "(not a git repo)"
return $RETURN_CODE_SUCCESS
fi
# See my answer here: https://stackoverflow.com/a/76856090/4561887
test -z "$(git status --porcelain)" \
&& echo "$(git rev-parse --short HEAD)" \
|| echo "$(git rev-parse --short HEAD)-dirty"
}
Even better, here's a whole program that you can run or source:
#!/usr/bin/env bash
# This file is part of eRCaGuy_hello_world: https://github.com/ElectricRCAircraftGuy/eRCaGuy_hello_world
RETURN_CODE_SUCCESS=0
RETURN_CODE_ERROR=1
# From my answer: https://stackoverflow.com/a/76856090/4561887
# Get a short commit hash, and see whether `git status` is clean or dirty.
# Example outputs:
# 1. Not in a git repo: `(not a git repo)`
# 2. In a repo which has a "dirty" `git status`: `72361c8-dirty`
# - Note that "dirty" means there are pending uncommitted changes.
# 3. In a repo which has a "clean" `git status`: `72361c8`
git_get_short_hash() {
# See: https://stackoverflow.com/a/16925062/4561887
is_git_repo="$(git rev-parse --is-inside-work-tree 2>/dev/null)"
if [ "$is_git_repo" != "true" ]; then
echo "(not a git repo)"
return $RETURN_CODE_SUCCESS
fi
# See my answer here: https://stackoverflow.com/a/76856090/4561887
test -z "$(git status --porcelain)" \
&& echo "$(git rev-parse --short HEAD)" \
|| echo "$(git rev-parse --short HEAD)-dirty"
}
main() {
git_get_short_hash
}
# Determine if the script is being sourced or executed (run).
# See:
# 1. "eRCaGuy_hello_world/bash/if__name__==__main___check_if_sourced_or_executed_best.sh"
# 1. My answer: https://stackoverflow.com/a/70662116/4561887
if [ "${BASH_SOURCE[0]}" = "$0" ]; then
# This script is being run.
__name__="__main__"
else
# This script is being sourced.
__name__="__source__"
fi
# Only run `main` if this script is being **run**, NOT sourced (imported).
# - See my answer: https://stackoverflow.com/a/70662116/4561887
if [ "$__name__" = "__main__" ]; then
main "$@"
fi
Sample run command and output when running it:
eRCaGuy_hello_world$ bash/git_get_short_hash.sh
fddb4ef-dirty
Sample run and output by sourcing it (see my answer here if you don't know what that means) and then running main
or git_get_short_hash
directly:
eRCaGuy_hello_world$ . bash/git_get_short_hash.sh
eRCaGuy_hello_world$ main
fddb4ef-dirty
eRCaGuy_hello_world$ git_get_short_hash
fddb4ef-dirty
For a Python version of the above program, see my file here: python/git_get_short_hash.py in my eRCaGuy_hello_world repo.
Example usage:
- Use this function in another program of yours like this, for instance.
- First, copy the
git_get_short_hash.py
script into another git project of yours. - Then, use it like this (assuming
mylogfile
exists):
import git_get_short_hash
import textwrap
# Alias the function to a shorter name
git_get_short_hash = git_get_short_hash.git_get_short_hash3
git_short_hash = git_get_short_hash()
program_info_str = textwrap.dedent(f"""\
My other program details here...
Program version: {git_short_hash}
""")
print(program_info_str)
mylogfile.write(program_info_str)
See also
-
1Nice use of the
git status --porcelain
I described here. Upvoted.– VonCCommented Aug 8, 2023 at 5:51
Pretty print of main git repo, and sub-modules:
echo "Main GIT repo:"
echo $(git show -s --format=%H) '(main)'
echo "Sub-modules:"
git submodule status | awk '{print $1,$2}'
Example output:
3a032b0992d7786b00a8822bbcbf192326160cf9 (main)
7de695d58f427c0887b094271ba1ae77a439084f sub-module-1
58f427c0887b01ba1ae77a439084947de695d27f sub-module-2
d58f427c0887de6957b09439084f4271ba1ae77a sub-module-3
How I would do it in python (based on @kenorb's bash answer)
def get_git_sha():
# Which branch are we on?
branch = open(".git/HEAD", "r").read()
# Parse output "ref: refs/heads/my_branch" -> my_branch
branch = branch.strip().split("/")[-1]
# What's the latest commit in this branch?
return open(f".git/refs/heads/{branch}").read().strip()
Here is another direct-access implementation:
head="$(cat ".git/HEAD")"
while [ "$head" != "${head#ref: }" ]; do
head="$(cat ".git/${head#ref: }")"
done
This also works over http which is useful for local package archives (I know: for public web sites it's not recommended to make the .git directory accessable):
head="$(curl -s "$baseurl/.git/HEAD")"
while [ "$head" != "${head#ref: }" ]; do
head="$(curl -s "$baseurl/.git/${head#ref: }")"
done
I wanted the newest commit on the origin/main
branch so I use
git ls-remote origin | grep main$ | cut -f 1
-
1Good to know, although not the answer specific to this exact question Commented Jan 11, 2023 at 13:00
git log
to retrieve recent commits, that will show full commit hash"record_commit_hash_and_build_time": "now=$(date -u \"+%Y-%m-%d %H:%M:%S\") && last_commit=$(git rev-parse HEAD) && echo \"{\\\"commit\\\": \\\"$last_commit\\\", \\\"build_time\\\": \\\"$now\\\"}\" > frontend/dist/version.json",
stackoverflow.com/a/11493416/470749