How do I get the name of the current branch in Git?
.git/HEAD
, possibly in a parent directory
git branch --show-current
. See my answer here.
To display only the name of the current branch you're on:
git rev-parse --abbrev-ref HEAD
Reference: Show just the current branch in Git
git branch
should show all the local branches of your repo. The starred branch is your current branch.
To retrieve only the name of the branch you are on:
git rev-parse --abbrev-ref HEAD
or with Git 2.22 and above:
git branch --show-current
git checkout --orphan foo
then git branch
failed to show branch foo
. Whereas git symbolic-ref HEAD
as suggested another answer worked.
git rev-parse --abbrev-ref HEAD
do exactly? I was previously using git describe --contains --all HEAD
but that breaks sometimes and i'm not quite sure why.
You have also git symbolic-ref HEAD
which displays the full refspec.
To show only the branch name in Git v1.8 and later (thank's to Greg for pointing that out):
git symbolic-ref --short HEAD
On Git v1.7+ you can also do:
git rev-parse --abbrev-ref HEAD
Both should give the same branch name if you're on a branch. If you're on a detached head answers differ.
Note: On an earlier client, this seems to work: git symbolic-ref HEAD | sed -e "s/^refs\/heads\///" – Darien 26. Mar 2014
git rev-parse --abbrev-ref HEAD
shows HEAD
when you’re on detached head.
git symbolic-ref HEAD | sed -e "s/^refs\/heads\///"
since it will display a string like HEAD detached at a63917f
when in a detached state, unlike the other answers which show either nothing or HEAD. This is important.
For my own reference (but it might be useful to others) I made an overview of most (basic command line) techniques mentioned in this thread, each applied to several use cases: HEAD is (pointing at):
local branch (master)
remote tracking branch, in sync with local branch (origin/master at same commit as master)
remote tracking branch, not in sync with a local branch (origin/feature-foo)
tag (v1.2.3)
submodule (run inside the submodule directory)
general detached head (none of the above)
Results:
git branch | sed -n '/\* /s///p' local branch: master remote tracking branch (in sync): (detached from origin/master) remote tracking branch (not in sync): (detached from origin/feature-foo) tag: (detached from v1.2.3) submodule: (HEAD detached at 285f294) general detached head: (detached from 285f294)
local branch: master
remote tracking branch (in sync): (detached from origin/master)
remote tracking branch (not in sync): (detached from origin/feature-foo)
tag: (detached from v1.2.3)
submodule: (HEAD detached at 285f294)
general detached head: (detached from 285f294)
git status | head -1 local branch: # On branch master remote tracking branch (in sync): # HEAD detached at origin/master remote tracking branch (not in sync): # HEAD detached at origin/feature-foo tag: # HEAD detached at v1.2.3 submodule: # HEAD detached at 285f294 general detached head: # HEAD detached at 285f294
local branch: # On branch master
remote tracking branch (in sync): # HEAD detached at origin/master
remote tracking branch (not in sync): # HEAD detached at origin/feature-foo
tag: # HEAD detached at v1.2.3
submodule: # HEAD detached at 285f294
general detached head: # HEAD detached at 285f294
git describe --all local branch: heads/master remote tracking branch (in sync): heads/master (note: not remotes/origin/master) remote tracking branch (not in sync): remotes/origin/feature-foo tag: v1.2.3 submodule: remotes/origin/HEAD general detached head: v1.0.6-5-g2393761
local branch: heads/master
remote tracking branch (in sync): heads/master (note: not remotes/origin/master)
remote tracking branch (not in sync): remotes/origin/feature-foo
tag: v1.2.3
submodule: remotes/origin/HEAD
general detached head: v1.0.6-5-g2393761
cat .git/HEAD: local branch: ref: refs/heads/master submodule: cat: .git/HEAD: Not a directory all other use cases: SHA of the corresponding commit
local branch: ref: refs/heads/master
submodule: cat: .git/HEAD: Not a directory
all other use cases: SHA of the corresponding commit
git rev-parse --abbrev-ref HEAD local branch: master all the other use cases: HEAD
local branch: master
all the other use cases: HEAD
git symbolic-ref --short HEAD local branch: master all the other use cases: fatal: ref HEAD is not a symbolic ref
local branch: master
all the other use cases: fatal: ref HEAD is not a symbolic ref
(FYI this was done with git version 1.8.3.1)
git describe --all --exact-match 2>/dev/null | sed 's=.*/=='
was the best solution for me (good names for tags and branch heads, no output for random detached heads.
git describe
has a serious failing when there are multiple branches referencing the same commit, e.g. right after git checkout -b foo
- it uses one of them arbitrarily (seems like maybe the most recently created one). I will change my strategy to use filtered output from git branch
and only use git describe
if the result is something about a detached head.
git branch --no-color
to make sure that the filename is free of annoying terminal escape codes.
checkout foo
) and "current commit" are 2 distinct concepts. symbolic-ref
only looks at active branch. describe
only looks at a commit, and chooses heuristically from all branches/tags pointing to it (or near it). DWIM commands like branch
and status
use current branch when defined, but all of them choose heuristically in all "detached HEAD" situations.
As of version 2.22 of git you could just use:
git branch --show-current
As per man page:
Print the name of the current branch. In detached HEAD state, nothing is printed.
One more alternative:
git name-rev --name-only HEAD
echo ${$(git symbolic-ref --quiet HEAD)#refs/heads/}
git checkout master && git name-rev --name-only HEAD # ac-187
It does not work as expected
git branch --list
just says * (HEAD detached at 7127db5)
. Doing git rev-parse --abbrev-ref HEAD
just says HEAD
and so on.
Well simple enough, I got it in a one liner (bash)
git branch | sed -n '/\* /s///p'
(credit: Limited Atonement)
And while I am there, the one liner to get the remote tracking branch (if any)
git rev-parse --symbolic-full-name --abbrev-ref @{u}
sed -n 's/\* //p'
does the trick. Although I tend toward the paranoid so I would anchor it with sed -n 's/^\* //p'
.
You can just type in command line (console) on Linux, in the repository directory:
$ git status
and you will see some text, among which something similar to:
...
On branch master
...
which means you are currently on master
branch. If you are editing any file at that moment and it is located in the same local repository (local directory containing the files that are under Git version control management), you are editing file in this branch.
git status
and get only the first line of output with git status | head -1
which yields something like # On branch master
. I'm sure version differences will needed to be accounted for as well.
git status | grep 'On branch'
, which should have the same effect (should, does not mean it will if your version of Git displays it differently). Or git branch | grep '*'
, which will show the name of the branch with a star at the beginning of it.
<tick>git status | head -1<tick>.gsub('# On branch ', '')
git status
can take a long time to return a value if there are a lot of files being managed.
git status
may tank the whole page's generation time.
git symbolic-ref -q --short HEAD
I use this in scripts that need the current branch name. It will show you the current short symbolic reference to HEAD, which will be your current branch name.
write the following command in terminal:
git branch | grep \*
or
git branch --show-current
or
git branch --show
To get the current branch in git use,
git branch --show-current
git branch | grep -e "^*" | cut -d' ' -f 2
will show only the branch name
git branch
show current branch name only.
While git branch will show you all branches and highlight the current one with an asterisk, it can be too cumbersome when working with lots of branches.
To show only the branch you are currently on, use:
git rev-parse --abbrev-ref HEAD
git branch --contains
sometimes lists more than one branch.
Found a command line solution of the same length as Oliver Refalo's, using good ol' awk:
git branch | awk '/^\*/{print $2}'
awk
reads that as "do the stuff in {}
on lines matching the regex". By default it assumes whitespace-delimited fields, so you print the second. If you can assume that only the line with your branch has the *, you can drop the ^. Ah, bash golf!
A less noisy version for git status would do the trick
git status -bsuno
It prints out
## branch-name
Why not use git-aware shell prompt, which would tell you name of current branch? git status
also helps.
How git-prompt.sh from contrib/
does it (git version 2.3.0), as defined in __git_ps1
helper function:
First, there is special case if rebase in progress is detected. Git uses unnamed branch (detached HEAD) during the rebase process to make it atomic, and original branch is saved elsewhere. If the .git/HEAD file is a symbolic link (a very rare case, from the ancient history of Git), it uses git symbolic-ref HEAD 2>/dev/null Else, it reads .git/HEAD file. Next steps depends on its contents: If this file doesn't exist, then there is no current branch. This usually happens if the repository is bare. If it starts with 'ref: ' prefix, then .git/HEAD is symref (symbolic reference), and we are on normal branch. Strip this prefix to get full name, and strip refs/heads/ to get short name of the current branch: b="${head#ref: }" # ... b=${b##refs/heads/} If it doesn't start with 'ref: ', then it is detached HEAD (anonymous branch), pointing directly to some commit. Use git describe ... to write the current commit in human-readable form.
I hope that helps.
git describe --contains --all HEAD
which I don't currently see elsewhere on this page. As I'm sure you know, link-only answers are not recommended on StackOverflow.
git-prompt.sh
(aka __git_ps1
) does it...
Sorry this is another command-line answer, but that's what I was looking for when I found this question and many of these answers were helpful. My solution is the following bash shell function:
get_branch () {
git rev-parse --abbrev-ref HEAD | grep -v HEAD || \
git describe --exact-match HEAD 2> /dev/null || \
git rev-parse HEAD
}
This should always give me something both human-readable and directly usable as an argument to git checkout
.
on a local branch: feature/HS-0001
on a tagged commit (detached): v3.29.5
on a remote branch (detached, not tagged): SHA1
on any other detached commit: SHA1
git checkout
.
#!/bin/bash
function git.branch {
br=`git branch | grep "*"`
echo ${br/* /}
}
git.branch
you can use git bash on the working directory command is as follow
git status -b
it will tell you on which branch you are on there are many commands which are useful some of them are
-s
--short Give the output in the short-format.
-b --branch Show the branch and tracking info even in short-format.
--porcelain[=] Give the output in an easy-to-parse format for scripts. This is similar to the short output, but will remain stable across Git versions and regardless of user configuration. See below for details.
The version parameter is used to specify the format version. This is optional and defaults to the original version v1 format.
--long Give the output in the long-format. This is the default.
-v --verbose In addition to the names of files that have been changed, also show the textual changes that are staged to be committed (i.e., like the output of git diff --cached). If -v is specified twice, then also show the changes in the working tree that have not yet been staged (i.e., like the output of git diff).
Over time, we might have a really long list of branches.
While some of the other solutions are great, Here is what I do (simplified from Jacob's answer):
git branch | grep \*
Now,
git status
works, but only If there are any local changes
git status
will also give the branch name along with changes.
e.g.
>git status
On branch master // <-- branch name here
.....
I would try one of the following:
1.> git symbolic-ref --short HEAD
git symbolic-ref --short HEAD
>>> sid-dev
git branch --show-current
>>> sid-dev
3.> git name-rev –name-only HEAD
git name-rev –name-only HEAD
>>> HEAD sid-dev
Notes:
1.> git symbolic-ref --short HEAD displays the short symbolic reference to the current branch’s HEAD. This is the current branch name.
2.> git branch --show-current is also a simple and efficient way to print the current branch name.
3.> git name-rev –name-only HEAD gives the symbolic name for HEAD revision of the current branch
4.> In the above examples, sid-dev is the name of my branch.
There is various way to check the current branch of Git
but I prefer :
git branch --show
Even git branch
also shows the current branch name along with all existing branch name list.
I recommend using any of these two commands.
git branch | grep -e "^*" | cut -d' ' -f 2
OR
git status | sed -n 1p | cut -d' ' -f 3
OR (more verbose)
git status -uno -bs| cut -d'#' -f 3 | cut -d . -f 1| sed -e 's/^[ \t]//1'| sed -n 1p
In Netbeans, ensure that versioning annotations are enabled (View -> Show Versioning Labels). You can then see the branch name next to project name.
http://netbeans.org/bugzilla/show_bug.cgi?id=213582
What about this?
{ git symbolic-ref HEAD 2> /dev/null || git rev-parse --short HEAD 2> /dev/null } | sed "s#refs/heads/##"
symbolic-ref
part also need --short
to avoid prefixing the branchname with refs/heads/
?
The following shell command tells you the branch that you are currently in.
git branch | grep ^\*
When you don't want to type that long command every time you want to know the branch and you are using Bash, give the command a short alias, for example alias cb
, like so.
alias cb='git branch | grep ^\*'
When you are in branch master and your prompt is $
, you will get * master
as follows.
$ cb
* master
git branch | grep '^\*'
You can permanently set up your bash output to show your git-branch name. It is very handy when you work with different branches, no need to type $ git status
all the time. Github repo git-aware-prompt .
Open your terminal (ctrl-alt-t) and enter the commands
mkdir ~/.bash
cd ~/.bash
git clone git://github.com/jimeh/git-aware-prompt.git
Edit your .bashrc with sudo nano ~/.bashrc
command (for Ubuntu) and add the following to the top:
export GITAWAREPROMPT=~/.bash/git-aware-prompt
source "${GITAWAREPROMPT}/main.sh"
Then paste the code
export PS1="\${debian_chroot:+(\$debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\] \[$txtcyn\]\$git_branch\[$txtred\]\$git_dirty\[$txtrst\]\$ "
https://i.stack.imgur.com/lczJR.png
I have a simple script called git-cbr
(current branch) which prints out the current branch name.
#!/bin/bash
git branch | grep -e "^*"
I put this script in a custom folder (~/.bin
). The folder is in $PATH
.
So now when I'm in a git repo, I just simply type git cbr
to print out the current branch name.
$ git cbr
* master
This works because the git
command takes its first argument and tries to run a script that goes by the name of git-arg1
. For instance, git branch
tries to run a script called git-branch
, etc.
Returns either branch name or SHA1 when on detached head:
git rev-parse --abbrev-ref HEAD | grep -v ^HEAD$ || git rev-parse HEAD
This is a short version of @dmaestro12's answer and without tag support.
git symbolic-ref --quiet --short HEAD || git rev-parse --short HEAD
Success story sharing
git branch
shows* (no branch)
, which is also useless...git rev-parse --abbrev-ref HEAD 2>/dev/null
The /dev/null part prevents you from seeing an error if you just created a new repository that has not yet HEAD.git symbolic-ref --short HEAD
seems to be more versatile.git rev-parse --abbrev-ref HEAD
yieldsHEAD
if the repo is a just-initialized one.