Come ottenere il nome attuale del ramo in Git?

Vengo da uno sfondo di Subversion e, quando avevo un ramo, sapevo a cosa stavo lavorando con “Questi file di lavoro puntano a questo ramo”.

Ma con Git non sono sicuro quando sto modificando un file in NetBeans o Notepad ++, sia che sia legato al master o ad un altro ramo.

Non c’è nessun problema con git in bash, mi dice cosa sto facendo.

 git branch 

dovrebbe mostrare tutti i rami locali del tuo repository. Il ramo con stelle è il tuo ramo attuale.

Se vuoi recuperare solo il nome del ramo su cui ti trovi, puoi fare:

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

Questo mostrerà il ramo corrente.

Riferimento:

  • Mostra solo la filiale attuale in Git (set 2009)

Hai anche git symbolic-ref HEAD che visualizza il refspec completo.

Per mostrare solo il nome del ramo in Git v1.8 e successive (grazie a Greg per averlo indicato):

 $ git symbolic-ref --short HEAD 

Su Git v1.7 + puoi anche fare:

 $ git rev-parse --abbrev-ref HEAD 

Entrambi dovrebbero dare lo stesso nome di ramo se sei su un ramo. Se sei su una testa staccata le risposte sono diverse.

Nota:

Su un client precedente, sembra funzionare:

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

Darien 26. Mar 2014

Per il mio riferimento personale (ma potrebbe essere utile ad altri) ho fatto una panoramica delle tecniche più (base della linea di comando) menzionate in questo thread, ognuna applicata a diversi casi d’uso: HEAD è (indicando):

  • filiale locale (master)
  • ramo di monitoraggio remoto, in sincrono con il ramo locale (origine / master allo stesso commit come master)
  • ramo di monitoraggio remoto, non in sincrono con un ramo locale (origine / caratteristica-foo)
  • tag (v1.2.3)
  • testa staccata generale (nessuna delle precedenti)

risultati:

  • git branch | sed -n '/\* /s///p'
    • filiale locale: master
    • ramo di monitoraggio remoto (in sincronizzazione): (detached from origin/master)
    • ramo di monitoraggio remoto (non sincronizzato): (detached from origin/feature-foo)
    • tag: (detached from v1.2.3)
    • testa staccata generale: (detached from 285f294)
  • git status | head -1
    • filiale locale: # On branch master
    • ramo di localizzazione remota (in sincronizzazione): # HEAD detached at origin/master
    • ramo di localizzazione remota (non sincronizzato): # HEAD detached at origin/feature-foo
    • tag: # HEAD detached at v1.2.3
    • testa staccata generale: # HEAD detached at 285f294
  • git describe --all
    • filiale locale: heads/master
    • ramo di localizzazione remota (in sincronizzazione): heads/master (nota: not remotes/origin/master )
    • ramo di localizzazione remota (non sincronizzato): remotes/origin/feature-foo
    • tag: v1.2.3
    • testa staccata generale: v1.0.6-5-g2393761
  • cat .git/HEAD :
    • filiale locale: ref: refs/heads/master
    • tutti gli altri casi d’uso: SHA del commit corrispondente
  • git rev-parse --abbrev-ref HEAD
    • filiale locale: master
    • tutti gli altri casi d’uso: HEAD
  • git symbolic-ref --short HEAD
    • filiale locale: master
    • tutti gli altri casi d’uso: fatal: ref HEAD is not a symbolic ref

(FYI questo è stato fatto con git versione 1.8.3.1)

Un’altra alternativa:

 git name-rev --name-only HEAD 

Beh, abbastanza semplice, l’ho preso in un solo liner (bash)

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

(credito: Espiazione limitata)

E mentre sono lì, l’unica linea per ottenere il ramo di monitoraggio remoto (se presente)

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

Puoi semplicemente digitare la riga di comando (console) su Linux, nella directory del repository:

 $ git status 

e vedrai del testo, tra cui qualcosa di simile a:

 ... On branch master ... 

il che significa che al momento ci si trova su un ramo master . Se stai modificando un file in quel momento e si trova nello stesso repository locale (directory locale contenente i file che sono sotto Git version control management), stai modificando il file in questo ramo.

 git symbolic-ref -q --short HEAD 

Lo uso negli script che richiedono il nome attuale del ramo. Ti mostrerà l’attuale breve riferimento simbolico a HEAD, che sarà il nome attuale del tuo ramo.

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

mostrerà solo il nome del ramo

Ho trovato una soluzione da riga di comando della stessa lunghezza di quella di Oliver Refalo , usando il buon vecchio awk:

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

awk legge “come fare le cose in {} sulle righe che corrispondono alla regex”. Per impostazione predefinita, assume i campi delimitati da spazi bianchi, quindi si stampa il secondo. Se puoi supporre che solo la linea con il tuo ramo ha il segno *, puoi lasciare il ^. Ah, bash golf!

git branch mostra solo il nome attuale del ramo.

Mentre git branch ti mostra tutti i rami e evidenzia quello attuale con un asterisco, può essere troppo macchinoso quando si lavora con molti rami.

Per mostrare solo il ramo in cui ti trovi al momento, usa:

 git rev-parse --abbrev-ref HEAD 
 #!/bin/bash function git.branch { br=`git branch | grep "*"` echo ${br/* /} } git.branch 

Perché non utilizzare il prompt della shell git-aware, che ti dirà il nome del ramo corrente? anche lo git status aiuta.


Come git-prompt.sh da contrib/ fa (git versione 2.3.0), come definito nella funzione helper __git_ps1 :

  1. Innanzitutto, c’è un caso speciale se viene rilevato rebase in corso. Git usa un ramo senza nome (HEAD distaccato) durante il processo di rebase per renderlo atomico, e il ramo originale viene salvato altrove.

  2. Se il file .git/HEAD è un collegamento simbolico (un caso molto raro, dalla storia antica di Git), usa git symbolic-ref HEAD 2>/dev/null

  3. Altrimenti legge file .git/HEAD . I prossimi passi dipendono dal suo contenuto:

    • Se questo file non esiste, allora non esiste un ramo corrente. Questo di solito accade se il repository è nudo.

    • Se inizia con 'ref: ' prefisso, quindi .git/HEAD è symref (riferimento simbolico), e siamo su ramo normale. Striscia questo prefisso per ottenere il nome completo e strip refs/heads/ per ottenere il nome breve del ramo corrente:

       b="${head#ref: }" # ... b=${b##refs/heads/} 
    • Se non inizia con 'ref: ' , allora è scollegato HEAD (branch anonimo), che punta direttamente ad un commit. Usa git describe ... per scrivere il commit corrente in forma leggibile.

Spero che aiuti.

è ansible utilizzare git bash sul comando della directory di lavoro è come segue

 git status -b 

ti dirà su quale ramo ti trovi ci sono molti comandi che sono utili alcuni di loro lo sono

 -s 

–short Fornisce l’output nel formato breve.

-b –branch Mostra il ramo e le informazioni di tracciamento anche in formato breve.

–porcelain [=] Fornisce l’output in un formato facile da analizzare per gli script. Questo è simile all’output corto, ma rimarrà stabile nelle versioni Git e indipendentemente dalla configurazione dell’utente. Vedi sotto per i dettagli.

Il parametro version viene utilizzato per specificare la versione del formato. Questo è opzionale e il valore predefinito per la versione originale v1.

–lunga Fornisci l’output nel formato lungo. Questo è l’impostazione predefinita.

-v –verbose Oltre ai nomi dei file che sono stati modificati, mostra anche le modifiche testuali che vengono messe in scena (cioè, come l’output di git diff –cached). Se -v viene specificato due volte, mostra anche le modifiche nell’albero di lavoro che non sono ancora state messe in scena (ad esempio, come l’output di git diff).

Nel tempo, potremmo avere una lunga lista di filiali.

Mentre alcune delle altre soluzioni sono grandi, ecco cosa faccio (semplificato dalla risposta di Jacob):

 git branch | grep \* 

Adesso,

 git status 

funziona, ma solo se ci sono cambiamenti locali

Raccomando di utilizzare uno di questi due comandi.

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

O

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

OR (più dettagliato)

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

In Netbeans, assicurarsi che le annotazioni di versione siano abilitate (Visualizza -> Mostra etichette di versioni). Puoi quindi vedere il nome del ramo accanto al nome del progetto.

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

Che dire di questo?

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

Una versione meno rumorosa per lo stato git farebbe il trucco

 git status -bsuno 

Si stampa

 ## branch-name 

Spiacente, questa è un’altra risposta da linea di comando, ma è quello che stavo cercando quando ho trovato questa domanda e molte di queste risposte sono state utili. La mia soluzione è la seguente funzione di shell bash:

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

Questo dovrebbe sempre darmi qualcosa di leggibile da tutti e direttamente utilizzabile come argomento per il git checkout .

  • su una filiale locale: feature/HS-0001
  • su un tag v3.29.5 (distaccato): v3.29.5
  • su un ramo remoto (scollegato, non taggato): SHA1
  • su qualsiasi altro commit distaccato: SHA1

Ho un semplice script chiamato git-cbr ( ramo corrente ) che stampa il nome attuale del ramo.

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

Ho messo questo script in una cartella personalizzata ( ~/.bin ). La cartella è in $PATH .

Così ora quando sono in un repository git, semplicemente git cbr per stampare il nome attuale del ramo.

 $ git cbr * master 

Questo funziona perché il comando git prende il suo primo argomento e prova a eseguire uno script che prende il nome di git-arg1 . Ad esempio, git branch tenta di eseguire uno script chiamato git-branch , ecc.

Il seguente comando di shell ti dice il ramo in cui ti trovi attualmente.

 git branch | grep ^\* 

Quando non vuoi digitare quel comando lungo ogni volta che vuoi conoscere il ramo e stai usando Bash, dai al comando un breve alias, ad esempio alias cb , in questo modo.

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

Quando sei in branch master e il tuo prompt è $ , otterrai * master come segue.

 $ cb * master 

Puoi impostare in modo permanente il tuo output bash per mostrare il tuo nome git-branch. È molto utile quando lavori con diversi rami, non è necessario digitare $ git status tutto il tempo. Github repo git-aware-prompt .

Apri il tuo terminale (ctrl-alt-t) e inserisci i comandi

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

Modifica il tuo .bashrc con il comando sudo nano ~/.bashrc (per Ubuntu) e aggiungi quanto segue all’inizio:

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

Quindi incollare il codice

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

alla fine dello stesso file è stato incollato il codice di installazione in precedenza. Questo ti darà l’output colorato: inserisci la descrizione dell'immagine qui

Se vuoi davvero che l’ultimo branch / tag sia estratto nello stato di HEAD distaccato.

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

Aggiornamento Questo è più bello se hai e non hai paura di awk.

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

So che è tardi, ma su un Linux / Mac, dal terminale puoi usare quanto segue.

 git status | sed -n 1p 

Spiegazione:

git status -> ottiene lo stato della struttura di lavoro
sed -n 1p -> ottiene la prima riga dal corpo di stato

La risposta al comando precedente sarà la seguente:

 "On branch your_branch_name" 

Restituisce il nome del ramo o SHA1 quando si trova sulla testata staccata:

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

Questa è una versione breve della risposta di @ dmaestro12 e senza supporto per i tag.

puoi anche usare la variabile GIT_BRANCH come appare qui: https://wiki.jenkins-ci.org/display/JENKINS/Git+Plugin

Il plugin git imposta diverse variabili d’ambiente che puoi usare negli script:

GIT_COMMIT – SHA della corrente

GIT_BRANCH – Nome del ramo attualmente in uso, ad esempio “master” o “origine / foo”

GIT_PREVIOUS_COMMIT – SHA del commit precedente costruito dallo stesso ramo (lo SHA corrente sulla prima build nel ramo)

GIT_URL – URL remoto del repository

GIT_URL_N – URL remoti del repository quando ci sono più di 1 telecomandi, ad es. GIT_URL_1, GIT_URL_2

GIT_AUTHOR_EMAIL – Email di committer / autore

GIT_COMMITTER_EMAIL – Email di committer / autore

Aggiungilo a PS1 usando Mac:

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

Prima di eseguire il comando sopra:

inserisci la descrizione dell'immagine qui

Dopo aver eseguito questo comando:

inserisci la descrizione dell'immagine qui

Non preoccuparti, se non è un repository GIT, non visualizzerà l’errore a causa di [-d .git] che controlla se la cartella .git esiste o meno.

 git status 

fornirà anche il nome del ramo insieme alle modifiche.

per esempio

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

Per copiare direttamente il risultato sul tavolo di assembly. Grazie a @ olivier-refalo per l’inizio …