sintaxis - subir todas las ramas git

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

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

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

Primero, hay un caso especial si se detecta una rebase en progreso. Git usa una rama sin nombre (HEAD separada) durante el proceso de rebase para hacerla atómica, y la rama original se guarda en otra parte.
Si el archivo .git/HEAD es un enlace simbólico (un caso muy raro, de la historia antigua de Git), usa git symbolic-ref HEAD 2>/dev/null
Si no, lee el archivo .git/HEAD . Los próximos pasos dependen de su contenido:
- Si este archivo no existe, entonces no hay rama actual. Esto suele suceder si el repositorio está vacío.
- Si comienza con ''ref: '' prefijo ''ref: '' , entonces .git/HEAD es 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 desvincula HEAD (rama anónima), apuntando directamente a algún compromiso. Use git describe ... para escribir la confirmación actual en forma legible por humanos.

Espero que eso ayude.

Soy de un fondo de Subversion y, cuando tenía una sucursal, 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 ++, ya sea que esté vinculado al maestro u otra rama.

No hay problema con git en Bash, me dice lo que estoy haciendo.

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

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

(crédito: expiación limitada)

Y mientras estoy allí, la única línea para obtener la rama de seguimiento remoto (si existe)

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

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

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.

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

git branch | grep ^/*

Cuando no quiera escribir ese comando largo cada vez que quiera conocer la rama y esté utilizando Bash, asigne al comando un alias corto, por ejemplo alias cb , así.

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

Cuando esté en el maestro de sucursal y su indicador sea $ , obtendrá * master siguiente manera.

$ cb * master

En Netbeans, asegúrese de que las anotaciones de versión estén habilitadas (Ver -> Mostrar etiquetas de versión). A continuación, puede ver el nombre de la rama junto al nombre del proyecto.

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

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

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

awk lee eso como "hacer las cosas en {} en las 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 asumir que solo la línea con su rama tiene el *, puede soltar la ^. Ah, bash golf!

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

Esto siempre debería darme algo legible por el ser humano y utilizable directamente como argumento para 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 otro commit separado: SHA1

Para mi propia referencia (pero podría ser útil para otros) realicé 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ñala a):

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

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)
- submódulo: `(HEAD separado en 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
- 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)

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

git rev-parse --abbrev-ref HEAD

Referencia:

Mostrar solo la sucursal actual en Git (Sep 2009)

Puedes configurar permanentemente tu salida de bash para mostrar el nombre de tu rama git. Es muy útil cuando trabaja con diferentes sucursales, sin necesidad de escribir $ git status todo 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 comando sudo nano ~/.bashrc (para Ubuntu) y agregue lo siguiente en 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 en el que pegó el código de instalación anteriormente. Esto le dará la salida coloreada:

Que hay de esto

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

Recomiendo usar cualquiera de estos dos comandos.

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

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

Sé que es tarde, pero en un linux / mac, desde la terminal puede 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 de estado

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

"On branch your_branch_name"

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

Actualizar Esto es mejor si tienes y no tienes miedo de awk.

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

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 actualmente estás en la rama master . Si está editando un 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 de control de versiones de Git), está editando el archivo en esta rama.

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 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" u "origin / foo"

GIT_PREVIOUS_COMMIT - SHA de la confirmación construida anterior de la misma rama (la SHA actual en la primera construcción en la rama)

GIT_URL - URL remota del repositorio

GIT_URL_N - URL remotas del repositorio cuando hay más de 1 controles remotos, 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

También tiene git symbolic-ref HEAD que muestra la refspec completa.

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 separada las respuestas difieren.

Nota:
En un cliente anterior, esto parece funcionar:
$ git symbolic-ref HEAD | sed -e "s/^refs//heads////"
- Darien 26. Mar 2014

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á en $PATH .

Así que ahora, cuando estoy en un repositorio de git, simplemente 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 lleva el nombre de git-arg1 . Por ejemplo, git branch intenta ejecutar un script llamado git-branch , etc.

Una alternativa más:

git name-rev --name-only HEAD

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

git status -bsuno

Se imprime

## branch-name

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

git status -b

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

-s

--short Dar la salida en el formato corto.

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

--porcelain [=] Proporcione la salida en un formato fácil de analizar para 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. Vea a continuación para más detalles.

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

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

-v --verbose Además de los nombres de los archivos que se han cambiado, también muestra los cambios textuales que están en fase de ejecución (es decir, como la salida de git diff --cached). Si se especifica -v dos veces, también se muestran los cambios en el árbol de trabajo que aún no se han efectuado (es decir, como la salida de git diff).

PS1 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 se preocupe, si no es un repositorio GIT, no mostrará un error debido a [-d .git] que verifica si la carpeta .git existe o no.

git branch muestra solo el nombre de la rama actual.

Si bien git branch le mostrará todas las ramas y destacará 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

git branch

Debe mostrar todas las sucursales locales de su repositorio. La rama estrellada es tu rama actual.

Si desea recuperar solo el nombre de la rama en la que se encuentra, puede hacerlo:

git branch | grep /* | cut -d '' '' -f2

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

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

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

mostrará solo el nombre de la rama

git status

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

p.ej

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

git symbolic-ref -q --short HEAD

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