Comment obtenir le nom actuel de la branche dans Git?

git rev-parse --abbrev-ref HEAD --

qui affichera la branche courante.

référence:

• Montrer la branche courante dans Git (Sep 2009)

vous avez aussi git symbolic-ref HEAD qui affiche la refspec complète.

Pour afficher uniquement le nom de la branche dans Git v1.8 et plus tard (merci à Greg pour souligné):

$ git symbolic-ref --short HEAD

sur Git v1.7 + vous pouvez aussi faire:

$ git rev-parse --abbrev-ref HEAD

les deux doivent donner le même nom de branche si vous êtes sur une branche. Si vous êtes sur une tête détachée, les réponses diffèrent.

Note:

sur un client antérieur, cela semble fonctionner:

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

– Darien 26. Mars 2014

pour ma propre référence (mais il pourrait être utile à d'autres) j'ai fait un aperçu de la plupart des techniques (ligne de commande de base) mentionnées dans ce fil, chacune appliquée à plusieurs cas d'utilisation: la tête est (pointant vers):

• branche locale (master)
• suivi à distance de la branche, en synchronisation avec la branche locale (origin/master à même de s'engager en tant que maître)
• suivi à distance de la branche, pas en synchronisation avec une agence locale (origine/caractéristique-foo)
• tag (v1.2.3)
• général détaché de la tête (aucun)

Résultats:

• git branch | sed -n '/\* /s///p'
  • branche locale: master
  • suivi à distance de la branche (synchronisation): (detached from origin/master)
  • suivi à distance de la branche (pas de synchronisation): (detached from origin/feature-foo)
  • tag: (detached from v1.2.3)
  • général détaché de la tête: (detached from 285f294)
• git status | head -1
  • branche locale: # On branch master
  • suivi à distance de la branche (synchronisation): # HEAD detached at origin/master
  • suivi à distance de la branche (pas de synchronisation): # HEAD detached at origin/feature-foo
  • tag: # HEAD detached at v1.2.3
  • général détaché de la tête: # HEAD detached at 285f294
• git describe --all
  • branche locale: heads/master
  • suivi à distance de la branche (synchronisation): heads/master (note: pas remotes/origin/master )
  • suivi à distance de la branche (pas de synchronisation): remotes/origin/feature-foo
  • tag: v1.2.3
  • général détaché de la tête: v1.0.6-5-g2393761
• cat .git/HEAD :
  • branche locale: ref: refs/heads/master
  • tous les autres cas d'utilisation: SHA du commit correspondant
• git rev-parse --abbrev-ref HEAD
  • branche locale: master
  • tous les autres cas d'utilisation: HEAD
• git symbolic-ref --short HEAD
  • branche locale: master
  • tous les les autres cas d'utilisation: fatal: ref HEAD is not a symbolic ref

(pour information ceci a été fait avec la version 1.8.3.1 de git)

une autre alternative:

git name-rev --name-only HEAD

assez simple, je l'ai eu dans une doublure (bash)

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

(crédit: Expiation limitée)

et pendant que je suis là, le seul liner pour obtenir la branche de suivi à distance (s'il y en a)

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

vous pouvez simplement taper ligne de commande (console) sur Linux, dans le répertoire du dépôt:

$ git status

et vous verrez quelques textes, parmi lesquels quelque chose de similaire à:

...
On branch master
...

ce qui signifie que vous êtes actuellement sur la branche master . Si vous éditez un fichier à ce moment et qu'il est situé dans le même dépôt local (répertoire local contenant les fichiers qui sont sous la gestion de contrôle de version Git), vous éditez le fichier en cette branche.

git symbolic-ref -q --short HEAD

j'utilise ceci dans les scripts qui ont besoin du nom de la branche courante. Il vous montrera la courte référence symbolique actuelle à HEAD, qui sera votre nom de branche actuel.

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

n'affichera que le nom de la succursale

a trouvé une solution de ligne de commande de la même longueur que Oliver Refalo , en utilisant bon ol 'awk:

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

awk lit "pour faire les trucs en {} sur les lignes correspondant à l'expression rationnelle". Par défaut, il suppose des champs délimités par des espaces, donc vous imprimez le second. Si vous pouvez supposer que seule la ligne avec votre branche a le *, vous pouvez laisser tomber le ^. Ah, bash golf!

git branch afficher le nom actuel de la succursale seulement.

alors que la branche git vous montrera toutes les branches et mettra en évidence l'actuelle avec un astérisque, elle peut être trop lourde en travaillant avec beaucoup de branches.

pour afficher uniquement la branche sur laquelle vous êtes actuellement, utilisez:

git rev-parse --abbrev-ref HEAD

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

pourquoi ne pas utiliser l'invite git-aware shell, qui vous indiquerait le nom de la branche courante? git status aide aussi.

Comment git-prompt.sh à partir de contrib/ does it (git version 2.3.0), tel que défini dans __git_ps1 aide de la fonction:

1. tout d'abord, il y a un cas spécial si rebase en cours est détecté. Git utilise une branche sans nom (tête détachée) pendant le processus de rebase pour le rendre atomique, et la branche originale est sauvegardée ailleurs.

2. si le fichier .git/HEAD est un lien symbolique (un cas très rare, de l'histoire ancienne de Git), il utilise git symbolic-ref HEAD 2>/dev/null

3. sinon, il lit .git/HEAD fichier. Les prochaines étapes dépendent de son contenu:

   • Si ce fichier n'existe pas, alors il n'y a pas de branche courante. Cela se produit généralement si le dépôt est vide.

   • si elle commence par le préfixe 'ref: ' , alors .git/HEAD est symref (référence symbolique), et nous sommes sur la branche normale. Rayer ce préfixe pour obtenir le nom complet, et rayer refs/heads/ pour obtenir le nom court de la branche actuelle:

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

   • S'il ne commence pas avec 'ref: ' , alors il est tête détachée (branche anonyme), pointant directement vers certains commettent. Utilisez git describe ... pour écrire la propagation courante sous une forme lisible par l'homme.

j'espère que ça aidera.

vous pouvez utiliser git bash dans le répertoire de travail commande est comme suit

git status -b

il vous dira sur quelle branche vous sont sur Il ya beaucoup de commandes qui sont utiles certains d'entre eux sont

-s

-- court Donnez la sortie dans le format court.

- b --direction Montrez l'information de la branche et de suivi même dans le format court.

-- porcelaine[=] Donnez la sortie dans un format facile à analyser pour script. Cela est similaire à la sortie courte, mais restera stable à travers les versions Git et indépendamment de la configuration de l'utilisateur. Voir ci-dessous pour plus de détails.

le paramètre version est utilisé pour spécifier la version format. C'est optionnel et par défaut au format d'origine de la version v1.

--long Donnez la sortie dans le format long. C'est la valeur par défaut.

- v --verbeux En plus des noms de fichiers qui ont été modifiés, aussi montrez les modifications textuelles qui sont mises en scène pour être engagées (i.e., comme la sortie de git diff --cached). Si -v est spécifié deux fois, alors montrez aussi les changements dans l'arbre de travail qui n'ont pas encore été échelonnés (i.e., comme la sortie de git diff).

avec le temps, nous pourrions avoir une très longue liste de branches.

tandis que certaines des autres solutions sont grandes, voici ce que je fais (simplifié de la réponse de Jacob):

git branch | grep \*

maintenant,

git status

fonctionne, mais seulement S'il y a des changements locaux

je recommande d'utiliser l'une de ces deux commandes.

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

ou

git status | sed -n 1p | cut -d' ' -f 3

OU (plus détaillé)

git status -uno -bs| cut -d'#' -f 3 | cut -d . -f 1| sed -e 's/^[ \t]//1'| sed -n 1p

dans Netbeans, s'assurer que les annotations de versioning sont activées (afficher - > Afficher la Versioning Étiquette.) Vous pouvez alors voir le nom de la branche à côté du nom du projet.

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

une version moins bruyante pour le statut git ferait l'affaire

git status -bsuno

Il imprime

## branch-name

et ça?

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

Désolé, c'est une autre ligne de commande, mais c'est ce que je cherchais quand j'ai trouvé cette question et beaucoup de ces réponses ont été utiles. Ma solution est la fonction bash shell suivante:

get_branch () {
    git rev-parse --abbrev-ref HEAD | grep -v HEAD || \
    git describe --exact-match HEAD 2> /dev/null || \
    git rev-parse HEAD
}

cela devrait toujours me donner quelque chose à la fois lisible par l'homme et directement utilisable comme argument à git checkout .

• sur une branche locale: feature/HS-0001
• sur un commit étiqueté (détaché): v3.29.5
• sur une branche distante (détaché, non balisé): SHA1
• sur tout autre commit détaché: SHA1

j'ai un script simple appelé git-cbr ( branche courante ) qui imprime le nom de la branche courante.

#!/bin/bash

git branch | grep -e "^*"

j'ai placé ce script dans un dossier personnalisé ( ~/.bin ). Le dossier est dans $PATH .

alors maintenant, quand je suis dans un git repo, Je n'ai qu'à taper git cbr pour imprimer le nom de la branche courante.

$ git cbr
* master

cela fonctionne parce que la commande git prend son premier argument et tente d'exécuter un script qui va par le nom de git-arg1 . Par exemple, git branch essaie d'exécuter un script appelé git-branch , etc.

La commande shell suivante vous indique la branche sur laquelle vous êtes actuellement.

git branch | grep ^\*

quand vous ne voulez pas taper cette commande longue à chaque fois que vous voulez connaître la branche et que vous utilisez Bash, donnez à la commande un alias court, par exemple alias cb , comme ça.

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

lorsque vous êtes en branch master et que votre invite est $ , vous obtiendrez * master comme suit.

$ cb
* master

vous pouvez configurer en permanence votre sortie bash pour afficher le nom de votre branche git. Il est très pratique lorsque vous travaillez avec différentes branches, pas besoin de taper $ git status tout le temps. Dépôt Github git-conscient-invite .

ouvrez votre terminal (ctrl-alt-t) et entrez les commandes

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

éditez votre .bashrc avec "151940920 de la commande" (pour Ubuntu) et ajoutez la ligne suivante en haut:

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

puis coller le code

export PS1="${debian_chroot:+($debian_chroot)}\[3[01;32m\]\u@\h\[3[00m\]:\[3[01;34m\]\w\[3[00m\] \[$txtcyn\]$git_branch\[$txtred\]$git_dirty\[$txtrst\]$ "

à la fin du même fichier vous avez collé le code d'installation dans plus tôt. Cela vous donnera la sortie colorisée:

si vous voulez vraiment que la dernière branche/étiquette soit vérifiée en état de tête détaché aussi.

git reflog HEAD | grep 'checkout:' | head -1 | rev | cut -d' ' -f1 | rev

mise à Jour C'est mieux si vous avez peur de awk.

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

je sais que c'est en retard mais sur un linux/mac ,à partir du terminal, vous pouvez utiliser ce qui suit.

git status | sed -n 1p

explication:

git status -> obtient l'arbre de travail "statut de la 151970920"
sed -n 1p - > obtient la première ligne du corps d'état

réponse à la commande ci-dessus ressemblera à ce qui suit:

"On branch your_branch_name"

renvoie soit le nom de la branche, soit SHA1 lorsqu'il est sur la tête détachée:

git rev-parse --abbrev-ref HEAD | grep -v ^HEAD$ || git rev-parse HEAD

c'est une version courte de la réponse de @dmaestro12 et sans étiquette.

vous pouvez également utiliser la variable GIT_BRANCH telle qu'elle apparaît ici: https://wiki.jenkins-ci.org/display/JENKINS/Git + Plugin

le plugin git définit plusieurs variables d'environnement que vous pouvez utiliser dans vos scripts:

GIT_COMMIT-SHA of the current

GIT_BRANCH-nom de la branche actuellement utilisée, p.ex. "master" ou" origin/foo "

GIT_PREVIOUS_COMMIT-SHA de la précédente construit s'engager de la même branche (la SHA sur la première construction de la branche)

GIT_URL-remote Repository URL

GIT_URL_N - Depository remote URLs when there are more than 1 remotes, e.g. GIT_URL_1, GIT_URL_2

GIT_AUTH_EMAIL-Committer / Author Email

GIT_COMMITTER_EMAIL-Committer / Author Email

ajouter à PS1 en utilisant Mac:

PS1='\W@\u >`[ -d .git ] && git branch | grep  ^*|cut -d" " -f2`> $ '

avant d'exécuter la commande ci-dessus:

après avoir exécuté cette commande:

ne vous inquiétez pas, si ce n'est pas un dépôt GIT , il n'affichera pas d'erreur à cause de [-d .git] qui vérifie si Le dossier .git existe ou non.

git status 

donnera également le nom de la branche ainsi que les modifications.

p.ex.

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

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

pour copier directement le résultat sur la planche. Merci à @olivier-refalo pour le début...