Est-il une meilleure façon de savoir si une branche git existe?

Je suis en utilisant la commande suivante pour savoir si un local git branch avec branch-name existe dans mon référentiel. Est-ce correct? Est-il un meilleur moyen?

Veuillez noter que je suis en train de faire cela à l'intérieur d'un script. Pour cette raison, j'aimerais l'utilisation de plomberie commandes si possible.

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

Votre commande ressemble à celui que j'avais utilisé.
Dans mon ignorance, je serais allé avec git branch | grep -w <branch-name>. Ok, c'est une porcelaine de commande, mais je ne peux pas imaginer une telle utilisation à évoluer considérablement dans l'avenir pour faire de cet extrait inutilisable...
Vous avez probablement raison, que la commande ne serait pas modifier de manière significative afin de le rendre inutilisable. J'ai un peu d'un trouble obsessionnel-compulsif au sujet de telles choses comme la porcelaine rapport à la plomberie, c'est tout.
git rev-parse --verify <branch_name> vérifie également d'autres références telles que des balises et de commettre des hachages, si bien qu'il pourrait être plus approprié pour ce que vous avez besoin, il sera de retour de faux positifs si vous êtes uniquement intéressé précisément dans les branches.
Chose très mineure, mais dans le mise à Jour de la section, il convient de git rev-parse --verify <branch-name> (c'est à dire branch-name au lieu de branch_name)?
Seul le git show-ref travaille pour déterminer si une section LOCALE est présente. Dans la mise à jour (syntaxe avec git rev-parse), le code de retour est également 0 si une branche distante matchs.

InformationsquelleAutor Manoj Govindan | 2011-03-02

49

Pour autant que je sais, c'est la meilleure façon de le faire dans un script. Je ne suis pas sûr qu'il ya beaucoup plus à ajouter à cela, mais il pourrait aussi bien être une réponse qui dit simplement: "Que la commande est tout ce que vous voulez" 🙂

La seule chose que vous voudrez peut-être prudent, c'est que les noms de branche peut avoir d'étonnants personnages en eux, de sorte que vous pouvez citer <branch-name>.
- bon point sur citant <branch-name>. FWIW, je suis en utilisant ce dans un tissu de script. Je n'oublierai pas de citer la variable.
- La réponse correcte est-ce implicitement: git show-ref --vérifier --quiet refs/heads/<branche-name> allons montrer que la TÊTE n'est pas une branche correctement. git rev-parse --vérifier vous indiquera à la TÊTE est une branche. Faux car la TÊTE n'est pas une branche.
InformationsquelleAutor Mark Longair
102

Quand je fais une recherche pour 'git vérifier si la branche existe" sur un moteur de recherche, cette page est la première que je vois.

J'obtiens ce que je veux, mais j'aimerais fournir une mise à jour de réponse depuis le post original est à partir de 2011.
```
git rev-parse --verify <branch_name>
```
C'est essentiellement le même que l'on a accepté la réponse, mais vous n'avez pas besoin de taper "refs/heads/"
- Juste une remarque: git rev-parse --verify ne vous raconte pas si un tel objet existe dans le repo (c'est à dire il va retourner 0 pour toute valeur de <branch_name> qui se traduit par un objet de n'importe quel type dans les pensions de titres). Elle ne vous dit pas si cet objet est une branche ou pas.
- Ce n'est pas une réponse correcte à la question, qui se pose de comment savoir si une branche existe. Cela vous donnera un faux positif pour une balise. Vous pouvez facilement tester vous-même. Vous avez besoin refs/heads/ à distinguer de balises qui sont dans les refs/tags, et même des télécommandes refs/remotes.
- git rev-parse --vérifier gh-pages donne moi: fatal: Besoin d'une seule révision
- avez-vous essayé: git rev-parse --vérifier **origine/**gh-pages?
InformationsquelleAutor jhuynh
31

Presque là.

Il suffit de laisser le --verify et --quiet et vous obtenez soit la valeur de hachage si la branche existe ou rien si elle n'est pas.

L'affecter à une variable et à la vérification d'une chaîne vide.
```
exists=`git show-ref refs/heads/<branch-name>`
if [ -n "$exists" ]; then
    echo 'branch exists!'
fi
```
- La valeur de retour est suffisant, et vous n'avez pas besoin de passer par la peut-être le risque d'erreur de l'effort de l'affectation à une variable.
InformationsquelleAutor Martijn
15

Je pense que vous pouvez utiliser git show-branch ici.
```
$ 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
```
Donc, $? == 0 indique que la branche existe et que vous n'avez pas à plonger dans la plomberie de refs/heads/à tous. Tant que vous ne passez pas -r montrer la branche, il ne fonctionne que sur des branches locales.
- Autant que je sache git show-branch est un en porcelaine la commande. Comme je l'ai dit dans ma question, je préfère ne pas utiliser de la porcelaine des commandes dans un script si plomberie équivalents sont disponibles. Voir kernel.org/pub/software/scm/git/docs
- Je sais à propos de porcelaine contre la plomberie, mais je n'avais jamais lu que la plomberie a été considéré comme plus stable que la porcelaine. Merci pour m'indiquer que dans les docs.
- Pour éviter de trouver des balises à l'erreur, et pour être plus précis quant à savoir si la direction générale est en local ou à distance, vous pouvez spécifier git show-branch refs/heads/[branch] ou git show-branch refs/remotes/origin/[branch].
InformationsquelleAutor Mark Drago
12

Je recommande git show-ref --quiet refs/heads/$name.
- --quiet signifie qu'il n'ya pas de sortie, ce qui est bon, car vous pouvez proprement vérifier l'état de sortie.
- refs/heads/$name limites aux antennes locales des matchs et des noms complets (sinon dev correspondent à develop)
Utilisation dans un script:
```
if git show-ref --quiet refs/heads/develop; then
    echo develop branch exists
fi
```
- Yup c'est le seul qui n'en silence. Le nommage des commandes git est un peu wack tbh
InformationsquelleAutor Razzi Abuissa
7

Pour une utilisation dans un script:
```
git show-ref -q --heads <branch-name>
```
Cette sortie 0 si et seulement si <branch-name> existe comme une branche locale.

Exemple:
```
if git show-ref -q --heads <branch-name>; then
   echo 'Branch exists'
fi
```
InformationsquelleAutor Tom Hale

Sur windows script batch c'est un peu différent,

git rev-parse --verify <branch>

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

InformationsquelleAutor pinkal vansia

1

Appelons git is_localbranch (vous devez ajouter un alias dans .gitconfig).

Utilisation:
```
$ git is_localbranch BRANCH
```
Source:
```
git branch | grep -w $1 > /dev/null
if [ $? = 0 ]
then
  echo "branch exists"
fi
```
InformationsquelleAutor Zlatan
1

Le résultat de l'examen sur ma Proposé de Modifier "à la" mise à Jour "sur la question initiale était" Il doit avoir été écrit comme un commentaire ou une réponse", donc je poste ici:

La une autre façon proposées seront non seulement vérifier les branches, mais toute référence avec un tel nom @jhuynh.
```
git rev-parse --verify <reference-name>
# $? == 0 means reference with <reference-name> exists.
```
Problème avec une "mise à Jour" sur les premiers quiestion expliqué:

Permet de supposer et vérifiez que " maître.000' n'est qu'une étiquette, telle branche locale n'existe pas, grep renvoie une entrée wchich est un tag. Encore rev-parse sera de retour 0 si la référence existe, même si la branche locale n'existe pas. C'est un faux match, exactement comme l'a mentionné @paul-s
```
$ git show-ref |grep master.000

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

git show-branch <BRANCH-NAME> &>/dev/null && echo yes || echo no

InformationsquelleAutor Vojtech Vitek

0

et oui il y en a un.
git rev-parse [] ...
https://git-scm.com/docs/git-rev-parse
Où u peut trouver l'ensemble des arguments et de la fonction.
```
        git rev-parse --verify <branch-name>
```
InformationsquelleAutor

Ni git show-ref ni git rev-parse travaille sur mon cas.

$ 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

J'ai fini avec ce

$ 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

Vous pouvez le faire aussi avec un fichier 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

InformationsquelleAutor Chetabahana

-1

Si vous pouvez gérer à inclure grep.
```
git branch | grep -q <branch>
```
- Qui pourrait vous donner la mauvaise réponse si vous utilisez des points (".") dans les noms de branche, comme je le fais parfois, puisque le point est interprété par grep comme un caractère de remplacement.
- Vous pourrez également obtenir un faux positif, si vous essai pour une branche dont le nom est une sous-chaîne d'une véritable direction. par exemple, abc correspondent si il y a une branche appelée abcdef.
InformationsquelleAutor Daniel Vikström
-1

Pour une utilisation dans un script, je vous recommande la commande suivante:
```
git ls-remote --heads <repo_url> "<branch_name>" | wc -l
```
Noter que <repo_url> peut-être juste un "." pour spécifier la locale repo si vous êtes à l'intérieur de sa structure de répertoire, le chemin d'accès à un local de pensions, ou l'adresse d'une distance repo.

La commande retourne 0 si la <branch_name> n'est pas présent de 1 si elle est présente.

InformationsquelleAutor David
-1

$ git branch --list $branch_name | grep $branch_name
ensuite, vérifier la valeur de retour est 0 ou 1.

InformationsquelleAutor Howell ZHU

Vous devez vous connecter pour publier un commentaire.