example - Cómo determinar de forma programada la rama Git actual retirada

git pull

Question

Esta pregunta ya tiene una respuesta aquí:

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

En un entorno de secuencias de comandos Unix o GNU (por ejemplo, una distribución Linux, Cygwin, OSX), ¿cuál es la mejor manera de determinar qué rama de Git está actualmente activada en un directorio en funcionamiento?

Un uso de esta técnica sería etiquetar automáticamente una versión (como svnversion haría con Subversion).

Por favor, vea también mi pregunta relacionada: cómo determinar mediante programación si una comprobación de Git es una etiqueta y, de ser así, ¿cuál es el nombre de la etiqueta?

Answer 1

¿Alguien ve algo malo con solo pedirle a Git que describa la sucursal en la que está?

git rev-parse --symbolic-full-name --abbrev-ref HEAD

Se puede usar dentro de $ () y pasar fácilmente en Bash, Powershell, Perl, etc. No se deja engañar si tiene varias sucursales en el compromiso en el que se encuentra, y si actualmente no está en una sucursal, simplemente responde con "HEAD".

Alternativamente, puedes usar

git symbolic-ref --short -q HEAD

Lo que le dará la misma salida, pero no devolverá nada en absoluto si está desconectado. Este es útil si quieres un error cuando se desconecta, solo elimina la -q.

Answer 2

Alguien mencionó hacerlo en bash con menos de tres asignaciones ... ¿qué tal un flujo de control desordenado como este:

branch_name="$(b=$(git symbolic-ref -q HEAD); { [ -n "$b" ] && echo ${b##refs/heads/}; } || echo HEAD)"

Answer 3

Aquí está mi solución, adecuada para usar en una PS1 o para etiquetar automáticamente una versión

Si está en una sucursal, obtiene el nombre de la sucursal.

Si estás en un proyecto de git recién iniciado, solo obtienes ''@''

Si no tiene cabeza, obtiene un buen nombre humano en relación con alguna rama o etiqueta, con una ''@'' que precede al nombre.

Si no tiene cabeza y no es un antepasado de alguna rama o etiqueta, simplemente obtiene el SHA1 corto.

function we_are_in_git_work_tree {
git rev-parse --is-inside-work-tree &> /dev/null
}
function parse_git_branch {
if we_are_in_git_work_tree
then
local BR=$(git rev-parse --symbolic-full-name --abbrev-ref HEAD 2> /dev/null)
if [ "$BR" == HEAD ]
then
local NM=$(git name-rev --name-only HEAD 2> /dev/null)
if [ "$NM" != undefined ]
then echo -n "@$NM"
else git rev-parse --short HEAD 2> /dev/null
fi
else
echo -n $BR
fi
fi
}

Puede eliminar el bit if if we_are_in_git_work_tree si lo desea; Simplemente lo uso en otra función de mi PS1 que puede ver en su totalidad aquí: línea PS1 con rama actual de git y colores

Answer 4

De esta respuesta: https://.com/a/1418022/605356 :

$ git rev-parse --abbrev-ref HEAD
master

Aparentemente funciona con Git 1.6.3 o más nuevo.

Answer 5

Descubrí que llamar a git es bastante lento (cualquiera de los subcomandos), especialmente para actualizar el indicador. El tiempo varía entre .1 y .2 segundos dentro del directorio raíz de un repositorio y durante .2 segundos fuera de un repositorio, en una máquina de primera clase (raid 1, ram de 8 gb, 8 hilos de hardware). Sin embargo, funciona Cygwin.

Por eso escribí este script para la velocidad:

#!/usr/bin/perl
$cwd=$ENV{PWD}; #`pwd`;
chomp $cwd;
while (length $cwd)
{
-d "$cwd/.git" and do {
-f "$cwd/.git/HEAD" and do {
open IN, "<", "$cwd/.git/HEAD";
$_=<IN>;
close IN;
s@ref: refs/heads/@@;
print $_;
};
exit;
};
$cwd=~s@/[^/]*$@@;
}

Puede necesitar algunos ajustes.

Answer 6

El uso de --porcelain proporciona una salida compatible con versiones anteriores fácil de analizar:

git status --branch --porcelain | grep ''##'' | cut -c 4-

De la documentación:

El formato de porcelana es similar al formato corto, pero se garantiza que no cambiará de manera incompatible con versiones anteriores de Git o en función de la configuración del usuario. Esto lo hace ideal para analizar por secuencias de comandos.

https://git-scm.com/docs/git-status

Answer 7

Encontré dos maneras realmente simples de hacer eso:

$ git status | head -1 | cut -d '' '' -f 4

y

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

Answer 8

Esa es una solución. Si lo agrega a su .bashrc, mostrará la rama actual en la consola.

# git branch
parse_git_branch() {
git branch 2> /dev/null | sed -e ''/^[^*]/d'' -e ''s/* /(.*/)/(/1) /''
}
$PS1="/$(parse_git_branch)$PS1"

Sin embargo, es bastante limitado. Pero hay un gran proyecto llamado git sh , que está haciendo exactamente eso (y mucho más).

Answer 9

Esta funciona para mí. La parte --no-color es, o puede ser, importante si desea recuperar una cadena simple.

git branch --no-color | sed -e ''/^[^*]/d'' -e ''s/* /(.*/)//1/''

Answer 10

Este me funcionó en el archivo bash.

git branch | grep ''^*'' | sed ''s/* //''
################bash file###################
#!/bin/bash
BRANCH=$(git branch | grep ''^*'' | sed ''s/* //'' )
echo $BRANCH

Answer 11

Esto es lo que hago:

git branch | sed --quiet ''s/* /(.*/)//1/p''

La salida se vería así:

$ git branch | sed --quiet ''s/* /(.*/)//1/p''
master
$

Answer 12

Estoy intentando el método más simple y autoexplicativo aquí:

git status | grep "On branch" | cut -c 11-

Answer 13

Intenta con:

 git symbolic-ref --short -q HEAD

O puedes probar con git branch con --no-color force simple simple string la salida:

 git branch --no-color

Con grep en modo regex ( -E ) puede verificar si existe el carácter ''*'':

 git branch --no-color | grep -E ''^/*''

Los resultados son similares a:

* currentBranch

Puedes usar las siguientes opciones:

sed ''s//*[^a-z]*//g''
cut -d '' '' -f 2
awk ''{print $2}''

por ejemplo:

 git branch --no-color | grep -E ''^/*'' | sed ''s//*[^a-z]*//g''
git branch --no-color | grep -E ''^/*'' | sed cut -d '' '' -f 2
git branch --no-color | grep -E ''^/*'' | awk ''{print $2}''

Si existe un error, no puede utilizar un valor predeterminado:

 cmd || echo ''defualt value'';

Todo en una función de bash:

function get_branch() {
git branch --no-color | grep -E ''^/*'' | awk ''{print $2}'' /
|| echo "default_value"
# or
# git symbolic-ref --short -q HEAD || echo "default_value";
}

Utilizar:

branch_name=`get_branch`;
echo $branch_name;

Answer 14

La solución correcta es echar un vistazo a contrib/completions/git-completion.bash hace para el mensaje de bash en __git_ps1 . Eliminar todos los extras, como seleccionar cómo describir la situación de HEAD desconectada, es decir, cuando estamos en una sucursal sin nombre, es:

branch_name="$(git symbolic-ref HEAD 2>/dev/null)" ||
branch_name="(unnamed branch)" # detached HEAD
branch_name=${branch_name##refs/heads/}

git symbolic-ref se utiliza para extraer el nombre de rama completo de la referencia simbólica; Lo usamos para HEAD, que actualmente se encuentra en la sucursal.

Una solución alternativa podría ser:

branch_name=$(git symbolic-ref -q HEAD)
branch_name=${branch_name##refs/heads/}
branch_name=${branch_name:-HEAD}

donde en la última línea tratamos con la situación de HEAD desapegada, usando simplemente "HEAD" para denotar tal situación.

Añadido el 11-06-2013

La publicación del blog Junio ​​C. Hamano (mantenedor de git), Verificación de la sucursal actual programáticamente , desde el 10 de junio de 2013 explica por qué (y cómo) en más detalle.

Answer 15

Los mismos resultados que la respuesta aceptada en una asignación de variable de una línea:

branch_name=$((git symbolic-ref HEAD 2>/dev/null || echo "(unnamed branch)")|cut -d/ -f3-)

Answer 16

Si está en una cabeza separada (es decir, ha verificado una versión) y tiene una salida del estado de git como

HEAD detached at v1.7.3.1

Y si quieres la versión de lanzamiento, usamos el siguiente comando ...

git status --branch | head -n1 | tr -d ''A-Za-z: ''

Esto devuelve 1.7.3.1, que reemplazamos en nuestros parameters.yml (Symfony) con

# RevNum=`svn status -u | grep revision | tr -d ''A-Za-z: ''` # the old SVN version
RevNum=`git status --branch | head -n1 | tr -d ''A-Za-z: ''` # Git (obvs)
sed -i "/^ app_version:/c/ app_version:$RevNum" app/config/parameters.yml

Espero que esto ayude :) Obviamente, si no tiene números en el nombre de su rama, deberá modificar los argumentos del comando tr.

Answer 17

Si está utilizando Gradle,

`` `

def gitHash = new ByteArrayOutputStream()
project.exec {
commandLine ''git'', ''rev-parse'', ''--short'', ''HEAD''
standardOutput = gitHash
}
def gitBranch = new ByteArrayOutputStream()
project.exec {
def gitCmd = "git symbolic-ref --short -q HEAD || git branch -rq --contains "+getGitHash()+" | sed -e ''2,/$d'' -e ''s///(.*//)/////(.*//)/$///2/'' || echo ''master''"
commandLine "bash", "-c", "${gitCmd}"
standardOutput = gitBranch
}

`` `

Answer 18

Si está utilizando la antigua línea de comandos de NT, puede usar lo siguiente:

@for /f "usebackq" %i in (`git symbolic-ref -q HEAD`) do @echo %~ni

Para usar en un archivo por lotes, tendrás que duplicar los% s:

@for /f "usebackq" %%i in (`git symbolic-ref -q HEAD`) do @echo %%~ni

Answer 19

adaptando la respuesta aceptada a windows powershell:

Split-Path -Leaf (git symbolic-ref HEAD)

Answer 20

puedes usar git name-rev --name-only HEAD