Existe uma maneira melhor de descobrir se existe uma ramificação git local?


191

Estou usando o seguinte comando para descobrir se existe uma ramificação git localbranch-name no meu repositório. Isso está correto? Existe uma maneira melhor?

Observe que estou fazendo isso dentro de um script. Por esse motivo, eu gostaria de usar comandos de encanamento, se possível.

git show-ref --verify --quiet refs/heads/<branch-name>
# $? == 0 means local branch with <branch-name> exists. 

Seu comando se parece com o que eu tinha usado.
Paŭlo Ebermann 02/03

6
Na minha ignorância, eu teria ido git branch | grep -w <branch-name>. Ok, é um comando de porcelana, mas eu não posso imaginar este uso particular, para haver mudança significativa no futuro, como fazer esse trecho inutilizável ...
UncleZeiv

@UncleZeiv: Você provavelmente está certo de que o comando não mudaria significativamente para torná-lo inutilizável. Eu tenho um pouco de TOC sobre coisas como porcelana versus encanamento, só isso.
Manoj Govindan 02/03

9
git rev-parse --verify <branch_name>também verifica outras referências, como tags e hashes de confirmação, embora seja mais adequado para o que você precisa, retornará falsos positivos se você estiver interessado apenas precisamente em ramificações.
Paul S.

2
Somente o git show-ref está trabalhando para determinar se um ramo LOCAL está presente. Na atualização (sintaxe com git rev-parse), o código de retorno também é 0 se uma ramificação remota corresponder.
Fabien Bouleau 5/09

Respostas:


57

Até onde eu sei, essa é a melhor maneira de fazer isso em um script. Não tenho certeza de que há muito mais a acrescentar a isso, mas pode haver uma resposta que apenas diga "Esse comando faz tudo o que você deseja" :)

A única coisa com a qual você deve ter cuidado é que os nomes das filiais podem ter caracteres surpreendentes, portanto, convém citar <branch-name>.


1
bom ponto sobre a citação <branch-name>. FWIW Estou usando isso em um script de malha. Vou lembrar de citar a variável.
Manoj Govindan 02/03

A resposta correta é esta implicitamente: git show-ref --verify --quiet refs / heads / <nome da filial> mostrará que HEAD não é um ramo corretamente. git rev-parse --verify informará que HEAD é um ramo existente. Falso porque HEAD não é um ramo.
Paulo Neves

106

Quando procuro por 'git verifique se existe ramificação' em um mecanismo de pesquisa, esta página é a primeira que vejo.

Consigo o que quero, mas gostaria de fornecer uma resposta atualizada, pois a postagem original era de 2011.

git rev-parse --verify <branch_name>

É basicamente o mesmo que a resposta aceita, mas você não precisa digitar "refs / heads /"


20
Apenas uma observação: git rev-parse --verifyinforma apenas se esse objeto existe no repositório (isto é, retornará 0 para qualquer valor <branch_name>que se traduza em um objeto de qualquer tipo no repositório). Não diz se esse objeto é um ramo ou não.
Tavnab # 5/15

9
Esta não é uma resposta correta para a pergunta, que está perguntando como saber se existe uma ramificação. Isso fornecerá um falso positivo para uma tag. Você pode facilmente testar isso sozinho. Você precisa de refs / heads / para distinguir das tags que estão em refs / tags e até mesmo controles remotos em refs / remotes.
msouth

15
git rev-parse --verify gh-pages me dá: fatal: precisava de uma única revisão
SuperUberDuper

@SuperUberDuper você tentou: git rev-parse --verify ** origin / ** gh-pages?
RoyalBigMack

33

Quase lá.

Basta deixar o --verifye--quiet e você quer receber o hash se existir o ramo ou nada se isso não acontecer.

Atribua-o a uma variável e verifique se há uma sequência vazia.

exists=`git show-ref refs/heads/<branch-name>`
if [ -n "$exists" ]; then
    echo 'branch exists!'
fi

10
O valor de retorno é suficiente - você não precisa passar pelo esforço possivelmente propenso a erros de atribuir a uma variável.
msouth

15

Eu acho que você pode usar git show-branchaqui.

$ git show-branch --list
  [master] test
* [testbranch] test
$ git show-branch testbranch
[testbranch] test
$ echo $?
0
$ git show-branch nonexistantbranch
fatal: bad sha1 reference nonexistantbranch
$ echo $?
128

Então $? == 0 indica que a filial existe e você não precisa se aprofundar no encanamento de refs / heads /. Contanto que você não passe -rpara show-branch, ele funcionará apenas em ramos locais.


5
AFAIK git show-branché um comando de porcelana . Como disse na minha pergunta, prefiro não usar comandos de porcelana em um script se houver equivalentes de encanamento disponíveis. Veja kernel.org/pub/software/scm/git/docs
Manoj Govindan

3
@Manoj: Eu sei sobre porcelana x encanamento, mas nunca tinha lido que o encanamento era considerado mais estável que a porcelana. Obrigado por me indicar isso nos documentos.
Mark Drago

Para evitar encontrar tags por engano e para ser mais específico sobre se a ramificação é local ou remota, você pode especificar git show-branch refs/heads/[branch]ou git show-branch refs/remotes/origin/[branch].
twasbrillig

13

Eu recomendo git show-ref --quiet refs/heads/$name.

  • --quiet significa que não há saída, o que é bom, pois você pode verificar o status da saída de maneira limpa.

  • refs/heads/$namelimites para filiais locais e corresponde a nomes completos (caso contrário dev, corresponderiam develop)

Uso em um script:

if git show-ref --quiet refs/heads/develop; then
    echo develop branch exists
fi

Sim, este é o único que faz isso silenciosamente. A nomenclatura de comandos git é um pouco Wack TBH
smac89

10

Para uso em um script:

git show-ref -q --heads <branch-name>

Isso sairá 0se, e somente se, <branch-name>existir como uma filial local.

Exemplo:

if git show-ref -q --heads <branch-name>; then
   echo 'Branch exists'
fi

2

No script em lote do Windows, é um pouco diferente,

git rev-parse --verify <branch>

if %ERRORLEVEL% == 0  (
    echo "Yes"
) else (
    echo "No"
)


1

Vamos chamá-lo git is_localbranch(você precisa adicionar o apelido .gitconfig).

Uso:

$ git is_localbranch BRANCH

Fonte:

git branch | grep -w $1 > /dev/null
if [ $? = 0 ]
then
  echo "branch exists"
fi

1

O resultado da revisão em minha 'Edição sugerida' para a 'Atualização' na pergunta inicial foi 'Deveria ter sido escrito como um comentário ou uma resposta', por isso estou publicando aqui:

A outra maneira proposta não apenas verificará as ramificações, mas qualquer referência com esse nome @jhuynh .

git rev-parse --verify <reference-name>
# $? == 0 means reference with <reference-name> exists.

Problema com uma 'Atualização' na pergunta inicial explicada:

Vamos assumir e verificar se 'master.000' é apenas uma tag, tal filial local não existe, grep retorna uma entrada que é uma tag. Ainda a análise de retorno retornará 0 se a referência existir, mesmo que essa ramificação local não exista. Esta é uma correspondência falsa, exatamente como mencionado por @ paul-s

$ git show-ref |grep master.000

f0686b8c16401be87e72f9466083d29295b86f4a refs/tags/master.000
$ git rev-parse --verify master.000
f0686b8c16401be87e72f9466083d29295b86f4a
$ echo $?
0


0

Nem git show-refnem git rev-parsefunciona no meu caso.

$ git --version
git version 2.21.0

$ git show-branch --list
* [master] mybranch commit

$ BRANCH_NAME=mybranch
$ git rev-parse --verify $BRANCH_NAME
fatal: Needed a single revision

$ git show-ref refs/heads/$BRANCH_NAME
<no otput>
$ [ $? == 0 ] && echo "$BRANCH_NAME exists" || echo "$BRANCH_NAME not exists"
mybranch not exists

Eu acabei com isso

$ BRANCH_NAME=mybranch
$ SHOW_ALL=`git show-branch --all | grep -w $BRANCH_NAME`
$ [ $? == 0 ] && echo "$BRANCH_NAME exists" || echo "$BRANCH_NAME not exists"
mybranch exists

Você também pode fazer com um arquivo de script

#!/bin/sh
BRANCH_NAME=mybranch
if grep -Fqe $BRANCH_NAME << EOF
`git show-branch --all`
EOF
then
   echo "$BRANCH_NAME exists"
else
   echo "$BRANCH_NAME not exists"
fi

-1

Se você conseguir incluir o grep.

git branch | grep -q <branch>

1
Isso pode lhe dar a resposta errada se você usar pontos (".") Nos nomes dos ramos, como eu às vezes faço, já que o ponto é interpretado grepcomo um metacaractere.
Peter John Acklam

1
Você também receberá um falso positivo se testar uma ramificação cujo nome é uma subcadeia de uma ramificação real. por exemplo abc, corresponderá se houver um ramo chamado abcdef.
Rjmunro 25/09/2015

-1

Para uso em um script, recomendo o seguinte comando:

git ls-remote --heads <repo_url> "<branch_name>" | wc -l

Observe que <repo_url>pode ser apenas um "." para especificar o repositório local se você estiver dentro de sua estrutura de diretórios, o caminho para um repositório local ou o endereço de um repositório remoto.

O comando retorna um 0 se o <branch_name>não estiver presente de 1 se presente.


-1
git branch --list $branch_name | grep $branch_name

depois verifique se o valor de retorno é 0 ou 1.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.