How do I get the current branch name in Git?

How do I get the name of the current branch in Git?

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

Version 2.22 adds the --show-current option to ”print the name of the current branch”. The combination also works for freshly initialized repositories before the first commit:

git branch --show-current

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

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)
• 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
• 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
• 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
• git rev-parse --abbrev-ref 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

(FYI this was done with git version 1.8.3.1)

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

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}

write the following command in terminal :

git branch | grep \*

or

git branch --show-current 

or on Git 2.22 and above:

  git branch --show

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 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.

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

I would try one of the following:

1. git symbolic-ref --short HEAD

    git symbolic-ref --short HEAD
    sid-dev
   

2. git branch --show-current

    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.

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!

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

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:

1. 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.

2. 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

3. 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.

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.

#!/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).

git status 

will also give the branch name along with changes.

e.g.

>git status
On branch master // <-- branch name here
.....

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

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

Short answer:

git branch --show-current

To put it in a variable in a bash script for example:

current_branch=$(git branch --show-current); 

or in Powershell script:

$currentBranch = $(git branch --show-current)

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/##"

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\]\$ "

at the end of the same file you pasted the installation code into earlier. This will give you the colorized output:

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

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.