¿Cómo obtener el nombre actual de la rama en Git?

git rev-parse --abbrev-ref HEAD --

Que mostrará la rama actual.

Referencia:

• Mostrar solo la rama actual en Git (Sep 2009)

También tiene git symbolic-ref HEAD que muestra el refspec completo.

Para mostrar solo el nombre de la rama en Git v1. 8 y posteriores (gracias a Greg por señalarlo):

$ git symbolic-ref --short HEAD

En Git v1.7 + también puedes hacer:

$ git rev-parse --abbrev-ref HEAD

Ambos deben dar el mismo nombre de rama si estás en una rama. Si estás en una cabeza desapegada las respuestas difieren.

Nota:

En un cliente anterior, esto parece funcionar:

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

– Darien 26. Estropear 2014

Para mi propia referencia (pero podría ser útil para otros) hice una descripción general de la mayoría de las técnicas (básicas de línea de comandos) mencionadas en este hilo, cada una aplicada a varios casos de uso: HEAD is (pointing at):

• rama local (master)
• rama de seguimiento remoto, sincronizada con la rama local (origin/master en el mismo commit que master)
• rama de seguimiento remoto, no sincronizada con una rama local (origin/feature-foo)
• tag (v1.2.3)
• general separado head (none of the above)

Resultados:

• git branch | sed -n '/\* /s///p'
  • rama local: master
  • rama de seguimiento remoto (en sincronización): (detached from origin/master)
  • rama de seguimiento remoto (no sincronizada): (detached from origin/feature-foo)
  • etiqueta: (detached from v1.2.3)
  • cabeza general separada: (detached from 285f294)
• git status | head -1
  • rama local: # On branch master
  • rama de seguimiento remoto (en sincronización): # HEAD detached at origin/master
  • rama de seguimiento remoto (no sincronizada): # HEAD detached at origin/feature-foo
  • etiqueta: # HEAD detached at v1.2.3
  • cabeza general separada: # HEAD detached at 285f294
• git describe --all
  • rama local: heads/master
  • rama de seguimiento remoto (en sincronización): heads/master (nota: no remotes/origin/master)
  • rama de seguimiento remoto (no sincronizada): remotes/origin/feature-foo
  • etiqueta: v1.2.3
  • cabeza general separada: {[18]]}
• cat .git/HEAD:
  • rama local: ref: refs/heads/master
  • todos los demás casos de uso: SHA de la correspondiente commit
• git rev-parse --abbrev-ref HEAD
  • rama local: master
  • todos los demás casos de uso: HEAD
• git symbolic-ref --short HEAD
  • rama local: master
  • todos los demás casos de uso: fatal: ref HEAD is not a symbolic ref

(Para su información, esto se hizo con la versión 1.8.3.1 de git)

Una alternativa más:

git name-rev --name-only HEAD

Bastante simple, lo conseguí en un solo trazador de líneas (bash)

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

(crédito: Expiación limitada)

Y mientras estoy allí, el único trazador de líneas para obtener la rama de seguimiento remoto (si la hay)

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

Simplemente puede escribir en la línea de comandos (consola) en Linux, en el directorio del repositorio:

$ git status

Y verás algún texto, entre los cuales algo similar a:

...
On branch master
...

Lo que significa que estás actualmente en la rama master. Si está editando cualquier archivo en ese momento y está ubicado en el mismo repositorio local (directorio local que contiene los archivos que están bajo Git version control management), está editando el archivo en esta rama.

git symbolic-ref -q --short HEAD

Uso esto en scripts que necesitan el nombre de la rama actual. Le mostrará la referencia simbólica corta actual a HEAD, que será su nombre de rama actual.

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

Mostrará solo el nombre de la rama

Encontró una solución de línea de comandos de la misma longitud que de Oliver Refalo, usando el buen awk:

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

awk lo lee como "hacer las cosas en {} en líneas que coincidan con la expresión regular". De forma predeterminada, asume campos delimitados por espacios en blanco, por lo que imprime el segundo. Si puedes asumir que solo la línea con tu rama tiene el*, puedes soltar el ^. ¡Ah, bash golf!

git branch mostrar solo el nombre de la rama actual.

Mientras que git branch te mostrará todas las ramas y resaltará la actual con un asterisco, puede ser demasiado engorroso cuando se trabaja con muchas ramas.

Para mostrar solo la rama en la que se encuentra actualmente, use:

git rev-parse --abbrev-ref HEAD

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

¿Por qué no usar el prompt de shell git-aware, que le indicaría el nombre de la rama actual? git status también ayuda.

Cómo git-prompt.sh desde contrib/ lo hace (git versión 2.3.0), como se define en __git_ps1 función auxiliar:

1. En primer lugar, hay un caso especial si se detecta rebase en progreso. Git usa rama sin nombre (CABEZA separada) durante el proceso de rebase para hacerla atómica, y la rama original se guarda en otro lugar.

2. Si el .git/HEAD el archivo es un enlace simbólico (un caso muy raro, de la historia antigua de Git), utiliza git symbolic-ref HEAD 2>/dev/null

3. De lo contrario, se lee .git/HEAD archivo. Los siguientes pasos dependen de su contenido:

   • Si este archivo no existe, entonces no hay ninguna rama actual. Esto suele ocurrir si el repositorio está vacío.

   • Si comienza con 'ref: ' prefijo, entonces .git/HEAD es symref (referencia simbólica), y estamos en rama normal. Quita este prefijo para obtener el nombre completo, y quita refs/heads/ para obtener el nombre corto de la rama actual:

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

   • Si no comienza con 'ref: ', entonces es CABEZA separada (rama anónima), apuntando directamente a algún commit. Use git describe ... para escribir el commit actual en forma legible por humanos.

Espero que eso ayude.

Puedes usar git bash en el directorio de trabajo orden es como sigue

git status -b

Te dirá en qué rama estás hay muchos comandos que son útiles algunos de ellos son

-s

Short corto Dar la salida en el formato corto.

- b --Sucursal Muestra la información de la rama y el seguimiento incluso en formato corto.

Porcelain porcelana[=] Proporcione la salida en un formato fácil de analizar para scripts. Esto es similar a la salida corta, pero permanecerá estable en Git versiones e independientemente de la configuración del usuario. Vea más abajo para más detalles.

El parámetro version se utiliza para especificar la versión de formato. Esto es opcional y por defecto al formato de la versión original v1.

Long largo Dar la salida en el formato largo. Este es el valor predeterminado.

-v --verboso Además de los nombres de los archivos que se han cambiado, también muestra los cambios textuales que se preparan para ser confirmados (es decir, como la salida de git diff c cached). Si-v se especifica dos veces, luego también muestra los cambios en el árbol de trabajo que aún no se han preparado (es decir, como la salida de git diff).

Con el tiempo, podríamos tener una lista muy larga de ramas.

Mientras que algunas de las otras soluciones son grandes, esto es lo que hago (simplificado de la respuesta de Jacob):

git branch | grep \*

Ahora,

git status

Funciona, pero solo Si hay algún cambio local

Recomiendo usar cualquiera de estos dos comandos.

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

O

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

O (más detallado)

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

En Netbeans, asegúrese de que las anotaciones de control de versiones estén habilitadas (Ver - > Mostrar control de versiones Etiqueta). Luego puede ver el nombre de la rama junto al nombre del proyecto.

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

Una versión menos ruidosa para el estado de git haría el truco

git status -bsuno

Imprime

## branch-name

¿Qué pasa con esto?

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

Lo sentimos, esta es otra respuesta de línea de comandos, pero eso es lo que estaba buscando cuando encontré esta pregunta y muchas de estas respuestas fueron útiles. Mi solución es la siguiente función bash shell:

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

Esto siempre debería darme algo legible por humanos y directamente utilizable como argumento para git checkout.

• en una rama local: feature/HS-0001
• en una confirmación etiquetada (desapegada): v3.29.5
• en una rama remota (separada, no etiquetada): SHA1
• en cualquier otro commit separado: SHA1

Tengo un script simple llamado git-cbr (current branch) que imprime el nombre de la rama actual.

#!/bin/bash

git branch | grep -e "^*"

Pongo este script en una carpeta personalizada (~/.bin). La carpeta está en $PATH.

Así que ahora cuando estoy en un repositorio de git, simplemente escribo git cbr para imprimir el nombre de la rama actual.

$ git cbr
* master

Esto funciona porque el comando git toma su primer argumento e intenta ejecutar un script que se hace llamar git-arg1. Por ejemplo, git branch intenta ejecutar un script llamado git-branch, etc.

El siguiente comando de shell le indica la rama en la que se encuentra actualmente.

git branch | grep ^\*

Cuando no quieras escribir ese comando largo cada vez que quieras conocer la rama y estés usando Bash, dale al comando un alias corto, por ejemplo alias cb, así.

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

Cuando esté en branch master y su solicitud sea $, obtendrá * master de la siguiente manera.

$ cb
* master

Puedes configurar permanentemente tu salida bash para mostrar tu nombre de git-branch. Es muy útil cuando se trabaja con diferentes ramas, no es necesario escribir $ git status todo el tiempo. Github repo git-aware-prompt .

Abra su terminal (ctrl-alt-t) e introduzca los comandos

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

Edita tu .bashrc con el comando sudo nano ~/.bashrc (para Ubuntu) y agregue lo siguiente a la parte superior:

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

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

Al final del mismo archivo pegó el código de instalación anterior. Esto le dará la salida coloreada:

Si realmente desea que la última rama/etiqueta se compruebe en el estado de CABEZA separado también.

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

Actualización Esto es mejor si tienes y no tienes miedo de awk.

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

Sé que esto es tarde ,pero en un linux/mac, desde el terminal se puede utilizar lo siguiente.

git status | sed -n 1p

Explicación:

Git status - > obtiene el estado del árbol de trabajo
sed-n 1p - > obtiene la primera línea del cuerpo de estado

La respuesta al comando anterior se verá de la siguiente manera:

"On branch your_branch_name"

Devuelve el nombre de la rama o SHA1 cuando en la cabeza separada:

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

Esta es una versión corta de la respuesta de @dmaestro12 y sin soporte de etiquetas.

También puedes usar la variable GIT_BRANCH como aparece aquí: https://wiki.jenkins-ci.org/display/JENKINS/Git + Plugin

El plugin git establece varias variables de entorno que puedes usar en tus scripts:

GIT_COMMIT-SHA de la corriente

GIT_BRANCH-Nombre de la rama que se está utilizando actualmente, por ejemplo, "master" o "origin/foo"

GIT_PREVIOUS_COMMIT-SHA de la confirmación compilada anterior desde la misma rama (el SHA actual en la primera compilación branch)

GIT_URL-URL remota del repositorio

GIT_URL_N-Url remotas del repositorio cuando hay más de 1 control remoto, por ejemplo GIT_URL_1, GIT_URL_2

GIT_AUTHOR_EMAIL-Committer/Author Email

GIT_COMMITTER_EMAIL-Committer/Author Email

Agrégalo a PS1 usando Mac :

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

Antes de ejecutar el comando anterior :

Después de ejecutar ese comando:

No te preocupes, si no es repositorio GIT , no mostrará error debido a [-d .git] que comprueba si la carpeta .git existe o no.

git status 

También dará el nombre de la rama junto con los cambios.

Por ejemplo

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

git branch | grep "*" | sed "s/* //" | awk '{printf $0}' | pbcopy

Para copiar directamente el resultado a la mesa de trabajo. Gracias a @ olivier-refalo por el comienzo {