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

Soy de un fondo de Subversion y, cuando tenía una rama, sabía en qué estaba trabajando con "Estos archivos de trabajo apuntan a esta rama".

Pero con Git no estoy seguro cuando estoy editando un archivo en NetBeans o Notepad ++, si está vinculado al maestro u otra rama.

No hay problema con gitbash, me dice lo que estoy haciendo.

git branch

debería mostrar todas las sucursales locales de su repositorio. La rama destacada es tu rama actual.

Si desea recuperar solo el nombre de la sucursal en la que se encuentra, puede hacer lo siguiente:

git rev-parse --abbrev-ref HEAD

Para mostrar la rama actual en la que se encuentra, sin las otras ramas enumeradas, puede hacer lo siguiente:

git rev-parse --abbrev-ref HEAD

Referencia:

• Mostrar solo la sucursal actual en Git (septiembre de 2009)

También tiene git symbolic-ref HEADque muestra la especificación de referencia completa.

Para mostrar solo el nombre de la rama en Git v1.8 y posterior (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 separada, las respuestas son diferentes.

Nota:

En un cliente anterior, esto parece funcionar:

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

- Darien 26. mar 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 (línea de comando básica) mencionadas en este hilo, cada una aplicada a varios casos de uso: HEAD es (señalando):

• sucursal local (maestro)
• rama de seguimiento remoto, en sincronización con la rama local (origen / maestro en el mismo compromiso que el maestro)
• rama de seguimiento remoto, no sincronizada con una rama local (origin / feature-foo)
• etiqueta (v1.2.3)
• submódulo (se ejecuta dentro del directorio de submódulos)
• cabeza separada general (ninguna de las anteriores)

Resultados:

• git branch | sed -n '/\* /s///p'
  • sucursal 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)
  • submódulo: (HEAD detached at 285f294)
  • cabeza separada general: (detached from 285f294)
• git status | head -1
  • sucursal 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
  • submódulo: # HEAD detached at 285f294
  • cabeza separada general: # HEAD detached at 285f294
• git describe --all
  • sucursal 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
  • submódulo: remotes/origin/HEAD
  • cabeza separada general: v1.0.6-5-g2393761
• cat .git/HEAD:
  • sucursal local: ref: refs/heads/master
  • submódulo: cat: .git/HEAD: Not a directory
  • todos los demás casos de uso: SHA de la confirmación correspondiente
• git rev-parse --abbrev-ref HEAD
  • sucursal local: master
  • todos los demás casos de uso: HEAD
• git symbolic-ref --short HEAD
  • sucursal local: master
  • todos los demás casos de uso: fatal: ref HEAD is not a symbolic ref

(FYI esto se hizo con git versión 1.8.3.1)

A partir de la versión 2.22 de git, podría usar:

git branch --show-current

Según la página del manual:

Imprime el nombre de la rama actual. En el estado HEAD separado, no se imprime nada.

Una alternativa más:

git name-rev --name-only HEAD

Bueno, lo suficientemente simple, lo obtuve en una línea (bash)

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

(crédito: Expiación limitada)

Y mientras estoy allí, el único revestimiento para obtener la rama de seguimiento remoto (si corresponde)

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á un texto, entre los cuales hay algo similar a:

...
On branch master
...

lo que significa que actualmente estás en una mastersucursal. Si está editando algún archivo en ese momento y está ubicado en el mismo repositorio local (directorio local que contiene los archivos que están bajo la administración del control de versiones de Git), está editando el archivo en esta rama.

git symbolic-ref -q --short HEAD

Lo uso 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

solo mostrará el nombre de la sucursal

git branch mostrar solo el nombre de la sucursal actual.

Si bien git branch le 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

Encontré una solución de línea de comando de la misma longitud que la de Oliver Refalo , usando buena ol 'awk:

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

awklee eso como "hacer las cosas en {}líneas que coinciden con la expresión regular". Por defecto, asume campos delimitados por espacios en blanco, por lo que imprime el segundo. Si puede suponer que solo la línea con su rama tiene el *, puede soltar el ^. Ah, bash golf!

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

¿Por qué no usar el indicador de shell de git-aware, que le dirá el nombre de la rama actual? git statusTambién ayuda.

Cómo git-prompt.sh desde contrib/lo hace (GIT versión 2.3.0), como se define en __git_ps1función de ayuda:

1. Primero, hay un caso especial si se detecta rebase en progreso. Git usa una rama sin nombre (HEAD separada) durante el proceso de rebase para hacerlo atómico, y la rama original se guarda en otro lugar.

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

3. De lo contrario, lee el .git/HEADarchivo. Los siguientes pasos dependen de su contenido:

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

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

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

   • Si no comienza con 'ref: ', entonces se separa HEAD (rama anónima), apuntando directamente a alguna confirmación. Se usa git describe ...para escribir el commit actual en forma legible para humanos.

Espero que eso ayude.

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

git status -bsuno

Se imprime

## branch-name

Lo siento, esta es otra respuesta de la 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 que sea legible para los humanos y directamente utilizable como argumento git checkout.

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

puede usar git bash en el comando del directorio de trabajo es el siguiente

git status -b

le dirá en qué rama se encuentra hay muchos comandos que son útiles, algunos de ellos son

-s

--short Proporciona la salida en formato corto.

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

--porcelain [=] Proporcione la salida en un formato fácil de analizar para los scripts. Esto es similar a la salida corta, pero se mantendrá estable en todas las versiones de Git e independientemente de la configuración del usuario. Ver abajo para más detalles.

El parámetro versión se usa para especificar la versión del formato. Esto es opcional y el formato predeterminado es la versión original v1.

--long Proporciona la salida en formato largo. Este es el valor predeterminado.

-v --verbose Además de los nombres de los archivos que se han cambiado, también se muestran los cambios de texto que se realizarán por etapas (es decir, como la salida de git diff --cached). Si -v se especifica dos veces, también muestra los cambios en el árbol de trabajo que aún no se han organizado (es decir, como la salida de git diff).

git status 

también le dará el nombre de la sucursal junto con los cambios.

p.ej

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

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

Si bien algunas de las otras soluciones son excelentes, 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 versiones estén habilitadas (Ver -> Mostrar etiquetas de versiones). Luego puede ver el nombre de la sucursal junto al nombre del proyecto.

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

¿Qué hay de esto?

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

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

#!/bin/bash

git branch | grep -e "^*"

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

Entonces, cuando estoy en un repositorio de git, simplemente escribo git cbrpara imprimir el nombre de la rama actual.

$ git cbr
* master

Esto funciona porque el gitcomando toma su primer argumento e intenta ejecutar un script que se conoce con el nombre de git-arg1. Por ejemplo, git branchintenta ejecutar un script llamado git-branch, etc.

Puede configurar permanentemente su salida de bash para mostrar su nombre de git-branch. Es muy útil cuando trabajas con diferentes ramas, no necesitas escribir $ git statustodo el tiempo. Github repo git-aware-prompt .

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

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

Edite su .bashrc con el sudo nano ~/.bashrccomando (para Ubuntu) y agregue lo siguiente en la parte superior:

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

Luego pegue 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 en el que pegó el código de instalación anteriormente. Esto le dará la salida coloreada:

El siguiente comando de shell te dice en qué rama estás actualmente.

git branch | grep ^\*

Cuando no desee escribir ese comando largo cada vez que desee conocer la rama y esté usando Bash, asigne al comando un alias corto, por ejemplo cb, alias , de esta manera.

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

Cuando esté en la rama maestra y su solicitud sea $, obtendrá * masterlo siguiente.

$ cb
* master

Devuelve el nombre de la rama o SHA1 cuando está 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.

Si realmente desea que la última rama / etiqueta se desproteja también en estado HEAD separado.

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 la terminal puedes usar 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 del estado

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

"On branch your_branch_name"

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

El complemento git establece varias variables de entorno que puede usar en sus scripts:

GIT_COMMIT - SHA del actual

GIT_BRANCH - Nombre de la rama que se está utilizando actualmente, por ejemplo, "maestro" u "origen / foo"

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

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 - Correo electrónico del autor / autor

GIT_COMMITTER_EMAIL - Correo electrónico del autor / autor

Agréguelo al PS1uso de 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 se preocupe, si no es un repositorio GIT, no mostrará un error debido a [-d .git]que comprueba si la .gitcarpeta existe o no.