Comment obtenir le nom actuel de la succursale dans Git?

Je suis originaire de Subversion et, lorsque j’avais une twig, je savais sur quoi je travaillais avec “Ces fichiers de travail pointent vers cette twig”.

Mais avec Git, je ne suis pas sûr quand je modifie un fichier dans NetBeans ou Notepad ++, qu’il soit lié au maître ou à une autre twig.

Il n’y a pas de problème avec git in bash, ça me dit ce que je fais.

 git branch 

devrait montrer toutes les twigs locales de votre repo. La twig étoilée est votre agence actuelle.

Si vous souhaitez récupérer uniquement le nom de la twig sur laquelle vous vous trouvez, vous pouvez le faire:

 git branch | grep \* | cut -d ' ' -f2 
 git rev-parse --abbrev-ref HEAD -- 

Cela affichera la twig en cours.

Référence:

  • Afficher uniquement la twig actuelle de Git (sept. 2009)

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

Pour afficher uniquement le nom de la twig dans Git v1.8 et versions ultérieures (merci à Greg de l’avoir signalé):

 $ git symbolic-ref --short HEAD 

Sur Git v1.7 +, vous pouvez également faire:

 $ git rev-parse --abbrev-ref HEAD 

Les deux devraient donner le même nom de twig si vous êtes sur une twig. Si vous êtes sur une tête détachée, les réponses sont différentes.

Remarque:

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 cela pourrait être utile pour d’autres), j’ai fait un survol de la plupart des techniques (ligne de commande de base) mentionnées dans ce fil, chacune appliquée à plusieurs cas d’utilisation: HEAD est (pointant sur):

  • twig locale (master)
  • twig de suivi à distance, en synchronisation avec la twig locale (origine / maître avec le même engagement que le maître)
  • twig de suivi à distance, non synchronisée avec une twig locale (origine / feature-foo)
  • tag (v1.2.3)
  • tête détachée générale (aucune de ces réponses)

Résultats:

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

(FYI cela a été fait avec git version 1.8.3.1)

Une alternative de plus:

 git name-rev --name-only HEAD 

Assez simple, je l’ai eu dans un seul paquebot (bash)

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

(crédit: Expiation limitée)

Et pendant que je suis là, le seul paquebot à obtenir la twig de suivi à distance (le cas échéant)

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

Vous pouvez simplement saisir la ligne de commande (console) sous Linux, dans le répertoire du référentiel:

 $ git status 

et vous verrez du texte, parmi lesquels quelque chose de similaire à:

 ... On branch master ... 

ce qui signifie que vous êtes actuellement sur la twig principale. Si vous modifiez un fichier à ce moment et qu’il se trouve dans le même référentiel local (répertoire local contenant les fichiers gérés par Git), vous modifiez le fichier dans cette twig.

 git symbolic-ref -q --short HEAD 

Je l’utilise dans des scripts qui nécessitent le nom de twig actuel. Il vous montrera la référence symbolique courte actuelle à HEAD, qui sera votre nom de twig actuel.

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

affichera uniquement le nom de la twig

J’ai trouvé une solution en ligne de commande de la même longueur que celle d’ Oliver Refalo , utilisant good ol ‘awk:

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

awk lit cela comme “faire le truc dans {} sur les lignes correspondant au regex”. Par défaut, il suppose des champs séparés par des espaces, vous imprimez donc le second. Si vous pouvez supposer que seule la ligne avec votre twig a le *, vous pouvez supprimer le ^. Ah, bash golf!

git branch montre uniquement le nom de la twig actuelle.

Alors que git branch vous montrera toutes les twigs et surlignera l’actuel avec un astérisque, il peut être trop lourd lorsque vous travaillez avec beaucoup de twigs.

Pour afficher uniquement la twig sur laquelle vous vous trouvez, 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 de shell git-aware, qui vous indiquerait le nom de la twig actuelle? git status aide également.


Comment git-prompt.sh de consortingb/ does it (git version 2.3.0), comme défini dans la fonction d’aide __git_ps1 :

  1. Tout d’abord, il y a un cas particulier si la rebase en cours est détectée. Git utilise une twig non nommée (HEAD détaché) pendant le processus de rebase pour le rendre atomique, et la twig d’origine est enregistrée ailleurs.

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

  3. Sinon, il lit le fichier .git/HEAD . Les étapes suivantes dépendent de son contenu:

    • Si ce fichier n’existe pas, il n’y a pas de twig en cours. Cela se produit généralement si le référentiel est vide.

    • S’il commence par 'ref: ' préfixe 'ref: ' , alors .git/HEAD est symref (référence symbolique), et nous sums sur une twig normale. Dénudez ce préfixe pour obtenir le nom complet et supprimez refs/heads/ pour obtenir le nom abrégé de la twig en cours:

       b="${head#ref: }" # ... b=${b##refs/heads/} 
    • S’il ne commence pas par 'ref: ' , alors il est détaché HEAD (twig anonyme), pointant directement vers une validation. Utilisez git describe ... pour écrire le commit actuel sous une forme lisible par l’homme.

J’espère que ça aide.

vous pouvez utiliser git bash sur la commande de répertoire de travail est comme suit

 git status -b 

il vous dira sur quelle twig vous êtes, il y a beaucoup de commandes qui sont utiles certaines d’entre elles sont

 -s 

–short Donne la sortie au format court.

-b –branch Affiche la twig et les informations de suivi même en format court.

–porcelain [=] Donne la sortie dans un format facile à parsingr pour les scripts. Ceci est similaire à la sortie courte, mais restra stable sur toutes les versions de Git et quelle que soit la configuration de l’utilisateur. Voir ci-dessous pour plus de détails.

Le paramètre de version est utilisé pour spécifier la version du format. Ceci est facultatif et utilise par défaut le format original de la version v1.

–long Donne la sortie au format long. Ceci est la valeur par défaut.

-v –verbose En plus des noms de fichiers modifiés, affichez également les modifications textuelles à transférer (comme la sortie de git diff –cached). Si -v est spécifié deux fois, affichez également les modifications de l’arbre de travail qui n’ont pas encore été mises en scène (comme la sortie de git diff).

Au fil du temps, nous pourrions avoir une très longue liste de twigs.

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

 git branch | grep \* 

À présent,

 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 verbeux)

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

Dans Netbeans, vérifiez que les annotations de gestion des versions sont activées (Affichage -> Afficher les étiquettes de contrôle de version). Vous pouvez alors voir le nom de la twig à côté du nom du projet.

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

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 réponse en ligne de commande, mais c’est ce que je cherchais quand j’ai trouvé cette question et que beaucoup de ces réponses étaient utiles. Ma solution est la fonction shell bash 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 en tant qu’argument pour git checkout .

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

J’ai un script simple appelé git-cbr ( twig actuelle ) qui affiche le nom de la twig en cours.

 #!/bin/bash git branch | grep -e "^*" 

Je mets ce script dans un dossier personnalisé ( ~/.bin ). Le dossier est dans $PATH .

Alors maintenant, quand je suis dans un repository git, il me suffit de taper git cbr pour imprimer le nom de la twig en cours.

 $ git cbr * master 

Cela fonctionne parce que la commande git prend son premier argument et tente d’exécuter un script nommé git-arg1 . Par exemple, git branch essaie de lancer un script appelé git-branch , etc.

La commande shell suivante vous indique la twig dans laquelle vous vous trouvez actuellement.

 git branch | grep ^\* 

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

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

Lorsque vous êtes en maître de twig et que votre invite est $ , vous obtenez * master comme suit.

 $ cb * master 

Une version moins bruyante pour le statut git ferait l’affaire

 git status -bsuno 

Il imprime

 ## branch-name 

Vous pouvez configurer de manière permanente votre sortie bash pour afficher votre nom de twig git. C’est très pratique lorsque vous travaillez avec différentes twigs, pas besoin de taper le $ git status tout le temps. Github repo git-aware-prompt .

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

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

Modifiez votre commande .bashrc avec la commande sudo nano ~/.bashrc (pour Ubuntu) et ajoutez les éléments suivants en haut:

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

Puis collez le code

 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\]\$ " 

à la fin du même fichier que vous avez collé le code d’installation dans plus tôt. Cela vous donnera la sortie colorisée: entrer la description de l'image ici

Si vous voulez vraiment que la dernière twig / balise soit également extraite dans l’état HEAD détaché.

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

Mise à jour C’est plus agréable si vous avez et n’avez pas 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, depuis le terminal, vous pouvez utiliser ce qui suit.

 git status | sed -n 1p 

Explication:

git status -> obtient le statut de l’arbre de travail
sed -n 1p -> obtient la première ligne du corps du statut

La réponse à la commande ci-dessus se présente comme suit:

 "On branch your_branch_name" 

Retourne soit le nom de la twig, soit SHA1 sur la tête détachée:

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

Ceci est une version courte de la réponse de @dmaestro12 et sans support de tag.

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 du courant

GIT_BRANCH – Nom de la twig en cours d’utilisation, par exemple “master” ou “origin / foo”

GIT_PREVIOUS_COMMIT – SHA du commit précédent généré à partir de la même twig (le SHA actuel lors de la première compilation dans la twig)

GIT_URL – URL distante du référentiel

GIT_URL_N – URL distantes du référentiel lorsqu’il y a plus de 1 télécommandes, par exemple GIT_URL_1, GIT_URL_2

GIT_AUTHOR_EMAIL – Committer / Auteur Email

GIT_COMMITTER_EMAIL – Committer / Auteur Email

Ajoutez-le à PS1 utilisant Mac:

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

Avant d’exécuter la commande ci-dessus:

entrer la description de l'image ici

Après avoir exécuté cette commande:

entrer la description de l'image ici

Ne vous inquiétez pas, si ce n’est pas le repository 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 twig avec les modifications.

par exemple

 >git status On branch master // <-- branch name here ..... 
 git branch | grep "*" | sed "s/* //" | awk '{printf $0}' | pbcopy 

Pour copier directement le résultat dans la table de assembly. Merci à @ olivier-refalo pour le départ…