Como obter o nome do ramo atual no Git?

Eu sou do background do Subversion e, quando tinha uma ramificação, sabia no que estava trabalhando com "Esses arquivos de trabalho apontam para essa ramificação".

Mas, com o Git, não tenho certeza quando estou editando um arquivo no NetBeans ou no Notepad ++, esteja ele vinculado ao mestre ou a outro ramo.

Não há problema com o gitbash, isso me diz o que estou fazendo.

git branch

deve mostrar todas as ramificações locais do seu repo. O ramo com estrela é o seu ramo atual.

Se você deseja recuperar apenas o nome da filial em que está, pode:

git rev-parse --abbrev-ref HEAD

Para exibir o ramo atual em que você está, sem os outros ramos listados, você pode fazer o seguinte:

git rev-parse --abbrev-ref HEAD

Referência:

• Mostrar apenas a filial atual no Git (set 2009)

Você também tem o git symbolic-ref HEADque exibe o refspec completo.

Para mostrar apenas o nome do ramo no Git v1.8 e posterior (obrigado a Greg por apontar isso):

git symbolic-ref --short HEAD

No Git v1.7 +, você também pode:

git rev-parse --abbrev-ref HEAD

Ambos devem dar o mesmo nome de filial, se você estiver em uma filial. Se você estiver com uma cabeça desapegada, as respostas serão diferentes.

Nota:

Em um cliente anterior, isso parece funcionar:

git symbolic-ref HEAD | sed -e "s/^refs\/heads\///"

- Darien 26. Mar 2014

Para minha própria referência (mas pode ser útil para outras pessoas), fiz uma visão geral da maioria das técnicas (linha de comando básica) mencionadas neste encadeamento, cada uma aplicada a vários casos de uso: HEAD is (apontando para):

• filial local (mestre)
• filial de rastreamento remoto, sincronizada com a filial local (origem / mestre na mesma confirmação que mestre)
• filial de rastreamento remoto, não sincronizada com uma filial local (origin / feature-foo)
• tag (v1.2.3)
• submódulo (executado dentro do diretório submódulo)
• cabeça destacada geral (nenhuma das opções acima)

Resultados:

• git branch | sed -n '/\* /s///p'
  • Filial local: master
  • ramo de rastreamento remoto (em sincronia): (detached from origin/master)
  • ramo de rastreamento remoto (não sincronizado): (detached from origin/feature-foo)
  • tag: (detached from v1.2.3)
  • submódulo: (HEAD detached at 285f294)
  • cabeça destacada geral: (detached from 285f294)
• git status | head -1
  • Filial local: # On branch master
  • ramo de rastreamento remoto (em sincronia): # HEAD detached at origin/master
  • ramo de rastreamento remoto (não sincronizado): # HEAD detached at origin/feature-foo
  • tag: # HEAD detached at v1.2.3
  • submódulo: # HEAD detached at 285f294
  • cabeça destacada geral: # HEAD detached at 285f294
• git describe --all
  • Filial local: heads/master
  • filial de rastreamento remoto (em sincronia): heads/master(nota: não remotes/origin/master )
  • ramo de rastreamento remoto (não sincronizado): remotes/origin/feature-foo
  • tag: v1.2.3
  • submódulo: remotes/origin/HEAD
  • cabeça destacada geral: v1.0.6-5-g2393761
• cat .git/HEAD:
  • Filial local: ref: refs/heads/master
  • submódulo: cat: .git/HEAD: Not a directory
  • todos os outros casos de uso: SHA do commit correspondente
• git rev-parse --abbrev-ref HEAD
  • Filial local: master
  • todos os outros casos de uso: HEAD
• git symbolic-ref --short HEAD
  • Filial local: master
  • todos os outros casos de uso: fatal: ref HEAD is not a symbolic ref

(FYI, isso foi feito com a versão 1.8.3.1 do git)

A partir da versão 2.22 do git, você poderia apenas usar:

git branch --show-current

Conforme a página de manual:

Imprima o nome da ramificação atual. No estado HEAD desanexado, nada é impresso.

Mais uma alternativa:

git name-rev --name-only HEAD

Bem simples, eu comprei em um forro (bash)

git branch | sed -n '/\* /s///p'

(crédito: Expiação Limitada)

E enquanto estou lá, o único liner para obter o ramo de rastreamento remoto (se houver)

git rev-parse --symbolic-full-name --abbrev-ref @{u}

Você pode digitar apenas a linha de comando (console) no Linux, no diretório do repositório:

$ git status

e você verá algum texto, entre os quais algo semelhante a:

...
On branch master
...

o que significa que você está atualmente no masterramo. Se você estiver editando algum arquivo naquele momento e ele estiver localizado no mesmo repositório local (diretório local que contém os arquivos que estão sob o gerenciamento de controle de versão do Git), você estará editando o arquivo nesta ramificação.

git symbolic-ref -q --short HEAD

Eu uso isso em scripts que precisam do nome da filial atual. Ele mostrará a referência simbólica abreviada atual para HEAD, que será seu nome de filial atual.

git branch | grep -e "^*" | cut -d' ' -f 2

mostrará apenas o nome do ramo

git branch mostrar apenas o nome da filial atual.

Embora o ramo git mostre todos os ramos e destaque o atual com um asterisco, ele pode ser muito complicado quando se trabalha com muitos ramos.

Para mostrar apenas a filial em que você está atualmente, use:

git rev-parse --abbrev-ref HEAD

Encontrei uma solução de linha de comando do mesmo tamanho que a de Oliver Refalo , usando o bom e velho awk:

git branch | awk '/^\*/{print $2}'

awklê isso como "faça as coisas nas {}linhas correspondentes ao regex". Por padrão, ele assume campos delimitados por espaços em branco, para que você imprima o segundo. Se você puder assumir que apenas a linha com sua ramificação possui o *, você pode soltar o ^. Ah, bash golfe!

#!/bin/bash
function git.branch {
  br=`git branch | grep "*"`
  echo ${br/* /}
}
git.branch

Por que não usar o prompt de shell compatível com git, que informa o nome da ramificação atual? git statustambém ajuda.

Como git-prompt.sh de contrib/faz isso (git versão 2.3.0), conforme definido na __git_ps1função auxiliar:

1. Primeiro, há um caso especial se a rebase em andamento for detectada. O Git usa ramificação sem nome (HEAD desanexado) durante o processo de rebase para torná-lo atômico, e a ramificação original é salva em outro lugar.

2. Se o .git/HEADarquivo é um link simbólico (um caso muito raro, da história antiga do Git), ele usagit symbolic-ref HEAD 2>/dev/null

3. Senão, lê o .git/HEADarquivo. Os próximos passos dependem do seu conteúdo:

   • Se esse arquivo não existir, não haverá ramificação atual. Isso geralmente acontece se o repositório estiver vazio.

   • Se ele começa com o 'ref: 'prefixo, então .git/HEADé symref (referência simbólica) e estamos no ramo normal. Retire esse prefixo para obter o nome completo e retire o refs/heads/nome abreviado da ramificação atual:

     b="${head#ref: }"
     # ...
     b=${b##refs/heads/}
     

   • Se não começar 'ref: ', será desanexado HEAD (ramificação anônima), apontando diretamente para algum commit. Use git describe ...para escrever a confirmação atual em formato legível por humanos.

Espero que ajude.

Uma versão menos barulhenta para o status git faria o truque

git status -bsuno

Imprime

## branch-name

Desculpe, esta é outra resposta da linha de comando, mas era isso que eu estava procurando quando encontrei esta pergunta e muitas dessas respostas foram úteis. Minha solução é a seguinte função de shell bash:

get_branch () {
    git rev-parse --abbrev-ref HEAD | grep -v HEAD || \
    git describe --exact-match HEAD 2> /dev/null || \
    git rev-parse HEAD
}

Isso sempre deve me dar algo legível por humanos e diretamente utilizável como argumento git checkout.

• em uma filial local: feature/HS-0001
• em um commit marcado (desanexado): v3.29.5
• em uma ramificação remota (desanexada, não marcada): SHA1
• em qualquer outro commit desanexado: SHA1

você pode usar git bash no comando diretório de trabalho é o seguinte

git status -b

dirá em que ramo você está, existem muitos comandos úteis, alguns deles são

-s

--short Fornece a saída no formato curto.

-b --branch Mostra as informações da filial e do rastreamento, mesmo em formato curto.

--porcelain [=] Forneça a saída em um formato fácil de analisar para scripts. Isso é semelhante à saída curta, mas permanecerá estável nas versões do Git e independentemente da configuração do usuário. Veja abaixo os detalhes.

O parâmetro version é usado para especificar a versão do formato. Isso é opcional e o padrão é o formato da versão original v1.

--long Fornece a saída no formato longo. Esse é o padrão.

-v --verbose Além dos nomes dos arquivos que foram alterados, também mostre as alterações textuais que são preparadas para serem confirmadas (ou seja, como a saída do git diff --cached). Se -v for especificado duas vezes, também mostre as mudanças na árvore de trabalho que ainda não foram preparadas (por exemplo, como a saída do git diff).

git status 

também fornecerá o nome do ramo junto com as alterações.

por exemplo

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

Com o tempo, podemos ter uma lista realmente longa de filiais.

Enquanto algumas das outras soluções são ótimas, eis o que eu faço (simplificado da resposta de Jacob):

git branch | grep \*

Agora,

git status

funciona, mas apenas se houver alguma alteração local

Eu recomendo usar qualquer um desses dois comandos.

git branch | grep -e "^*" | cut -d' ' -f 2

OU

git status | sed -n 1p | cut -d' ' -f 3

OU (mais detalhado)

git status -uno -bs| cut -d'#' -f 3 | cut -d . -f 1| sed -e 's/^[ \t]//1'| sed -n 1p

No Netbeans, verifique se as anotações de versão estão ativadas (Exibir -> Mostrar etiquetas de versão). Você pode ver o nome da filial ao lado do nome do projeto.

http://netbeans.org/bugzilla/show_bug.cgi?id=213582

Que tal isso?

{ git symbolic-ref HEAD 2> /dev/null || git rev-parse --short HEAD 2> /dev/null } | sed "s#refs/heads/##"

Eu tenho um script simples chamado git-cbr( ramo atual ) que imprime o nome do ramo atual.

#!/bin/bash

git branch | grep -e "^*"

Eu coloquei esse script em uma pasta personalizada ( ~/.bin). A pasta está em$PATH .

Então agora, quando estou em um repositório git, simplesmente digito git cbrpara imprimir o nome do ramo atual.

$ git cbr
* master

Isso funciona porque o gitcomando pega seu primeiro argumento e tenta executar um script que seja chamado pelo nome de git-arg1. Por exemplo, git branchtenta executar um script chamado git-branchetc.

Você pode configurar permanentemente sua saída do bash para mostrar o nome do seu git-branch. É muito útil quando você trabalha com ramificações diferentes, sem precisar digitar $ git statuso tempo todo. Repo do Github git-awareness-prompt .

Abra seu terminal (ctrl-alt-t) e digite os comandos

mkdir ~/.bash
cd ~/.bash
git clone git://github.com/jimeh/git-aware-prompt.git

Edite seu .bashrc com o sudo nano ~/.bashrccomando (para Ubuntu) e adicione o seguinte ao topo:

export GITAWAREPROMPT=~/.bash/git-aware-prompt
source "${GITAWAREPROMPT}/main.sh"

Depois cole o código

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

no final do mesmo arquivo em que você colou o código de instalação anteriormente. Isso fornecerá a saída colorida:

O seguinte comando shell informa a filial em que você está atualmente.

git branch | grep ^\*

Quando você não quiser digitar esse comando longo toda vez que quiser conhecer a ramificação e usar o Bash, forneça um pequeno alias ao comando, por exemplo cb, alias , assim.

alias cb='git branch | grep ^\*'

Quando você está no mestre da filial e seu prompt é $, você obtém * mastero seguinte.

$ cb
* master

Retorna o nome da ramificação ou SHA1 quando na cabeça desanexada:

git rev-parse --abbrev-ref HEAD | grep -v ^HEAD$ || git rev-parse HEAD

Esta é uma versão curta da resposta de @ dmaestro12 e sem suporte a tags.

Se você realmente deseja fazer o check-out da última ramificação / etiqueta no estado HEAD desanexado.

git reflog HEAD | grep 'checkout:' | head -1 | rev | cut -d' ' -f1 | rev

Atualizar Isso é melhor se você tiver e não tiver medo do awk.

git reflog HEAD | grep 'checkout:' | head -1 | awk '{print $NF}'

Eu sei que é tarde, mas em um linux / mac, a partir do terminal, você pode usar o seguinte.

git status | sed -n 1p

Explicação:

git status -> obtém o status da árvore de trabalho
sed -n 1p -> obtém a primeira linha do corpo do status

A resposta ao comando acima terá a seguinte aparência:

"On branch your_branch_name"

você também pode usar a variável GIT_BRANCH como aparece aqui: https://wiki.jenkins-ci.org/display/JENKINS/Git+Plugin

O plugin git define várias variáveis ​​de ambiente que você pode usar em seus scripts:

GIT_COMMIT - SHA do atual

GIT_BRANCH - Nome do ramo atualmente em uso, por exemplo, "master" ou "origin / foo"

GIT_PREVIOUS_COMMIT - SHA do commit construído anteriormente da mesma ramificação (o SHA atual na primeira compilação na ramificação)

GIT_URL - URL remoto do repositório

GIT_URL_N - URLs remotos do repositório quando houver mais de 1 controles remotos, por exemplo, GIT_URL_1, GIT_URL_2

GIT_AUTHOR_EMAIL - Email do autor / autor

GIT_COMMITTER_EMAIL - Email do autor / autor

Adicione-o ao PS1Mac:

PS1='\W@\u >`[ -d .git ] && git branch | grep  ^*|cut -d" " -f2`> $ '

Antes de executar o comando acima:

Depois de executar esse comando:

Não se preocupe, se não for um repositório GIT, ele não exibirá erros, pois [-d .git]verifica se a .gitpasta existe ou não.