Come ottenere il nome della filiale corrente in Git?

Vengo da un background di Subversion e, quando avevo un ramo, sapevo su cosa stavo lavorando con "Questi file di lavoro indicano 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'è problema con gitin bash, mi dice cosa sto facendo.

git branch

dovrebbe mostrare tutte le filiali locali del tuo repository. Il ramo stellato è il tuo ramo attuale.

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

git rev-parse --abbrev-ref HEAD

Per visualizzare il ramo corrente in cui ti trovi, senza gli altri rami elencati, puoi effettuare le seguenti operazioni:

git rev-parse --abbrev-ref HEAD

Riferimento:

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

Hai anche git symbolic-ref HEADche visualizza il refspec completo.

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

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 si è su un ramo. Se sei su una testa distaccata le risposte differiscono.

Nota:

Su un client precedente, questo sembra funzionare:

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

- Darien, 26 marzo 2014

Per mio riferimento (ma potrebbe essere utile ad altri) ho fatto una panoramica della maggior parte delle tecniche (riga di comando di base) menzionate in questo thread, ognuna applicata a diversi casi d'uso: HEAD è (indicando):

• filiale locale (master)
• ramo di tracciamento remoto, sincronizzato con il ramo locale (origine / master con lo stesso commit del master)
• ramo di tracciamento remoto, non sincronizzato con un ramo locale (origin / feature-foo)
• tag (v1.2.3)
• sottomodulo (eseguito all'interno della directory del sottomodulo)
• testa staccata generale (nessuna delle precedenti)

risultati:

• git branch | sed -n '/\* /s///p'
  • filiale locale: master
  • ramo di tracciamento remoto (sincronizzato): (detached from origin/master)
  • ramo di tracciamento remoto (non sincronizzato): (detached from origin/feature-foo)
  • etichetta: (detached from v1.2.3)
  • modulo: (HEAD detached at 285f294)
  • testa distaccata generale: (detached from 285f294)
• git status | head -1
  • filiale locale: # On branch master
  • ramo di tracciamento remoto (sincronizzato): # HEAD detached at origin/master
  • ramo di tracciamento remoto (non sincronizzato): # HEAD detached at origin/feature-foo
  • etichetta: # HEAD detached at v1.2.3
  • modulo: # HEAD detached at 285f294
  • testa distaccata generale: # HEAD detached at 285f294
• git describe --all
  • filiale locale: heads/master
  • ramo di tracciamento remoto (sincronizzato): heads/master(nota: no remotes/origin/master )
  • ramo di tracciamento remoto (non sincronizzato): remotes/origin/feature-foo
  • etichetta: v1.2.3
  • modulo: remotes/origin/HEAD
  • testa distaccata generale: v1.0.6-5-g2393761
• cat .git/HEAD:
  • filiale locale: ref: refs/heads/master
  • modulo: cat: .git/HEAD: Not a directory
  • 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

(Cordiali saluti, questo è stato fatto con la versione 1.8.3.1 di git)

A partire dalla versione 2.22 di git potresti semplicemente usare:

git branch --show-current

Come da pagina man:

Stampa il nome del ramo corrente. In stato HEAD distaccato, non viene stampato nulla.

Un'altra alternativa:

git name-rev --name-only HEAD

Bene abbastanza semplice, l'ho preso in una fodera (bash)

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

(credito: espiazione limitata)

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

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

Puoi semplicemente digitare nella 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 sei attualmente in masterfiliale. Se stai modificando un file in quel momento e si trova nello stesso repository locale (directory locale contenente i file che sono sotto la gestione del controllo versione Git), stai modificando il file in questo ramo.

git symbolic-ref -q --short HEAD

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

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

mostrerà solo il nome della filiale

git branch mostra solo il nome della filiale corrente.

Mentre git branch ti mostrerà tutti i rami ed evidenzierà quello attuale con un asterisco, può essere troppo ingombrante quando si lavora con molti rami.

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

git rev-parse --abbrev-ref HEAD

Ho trovato una soluzione a riga di comando della stessa lunghezza di Oliver Refalo , usando un buon vecchio awk:

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

awksi legge come "fare il materiale {}su righe corrispondenti alla regex". Per impostazione predefinita, presuppone campi delimitati da spazi bianchi, quindi si stampa il secondo. Se puoi presumere che solo la linea con il tuo ramo abbia il *, puoi rilasciare il ^. Ah, bash golf!

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

Perché non usare il prompt della shell git-aware, che ti direbbe il nome del ramo corrente? git statusaiuta anche.

Come git-prompt.sh da contrib/lo fa (git versione 2.3.0), come definito nella __git_ps1funzione di supporto:

1. Innanzitutto, c'è un caso speciale se viene rilevato un 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 .git/HEADfile è un collegamento simbolico (un caso molto raro, dell'antica storia di Git), lo utilizzagit symbolic-ref HEAD 2>/dev/null

3. Altrimenti, legge il .git/HEADfile. I prossimi passi dipendono dal suo contenuto:

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

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

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

   • Se non inizia con 'ref: ', viene rimosso HEAD (ramo anonimo), indicando direttamente un commit. Utilizzare git describe ...per scrivere il commit corrente in forma leggibile dall'uomo.

Spero che aiuti.

Una versione meno rumorosa per lo stato git farebbe il trucco

git status -bsuno

Si stampa

## branch-name

Mi dispiace che questa sia un'altra risposta da riga 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 dall'uomo e direttamente utilizzabile come argomento git checkout.

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

puoi usare 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 essi

-s

--short Fornisce l'output in formato breve.

-b --branch Mostra la filiale 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 breve, ma rimarrà stabile tra le versioni di Git e indipendentemente dalla configurazione dell'utente. Vedi sotto per i dettagli.

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

--long Fornisce l'output in formato lungo. Questo è il valore predefinito.

-v --verbose Oltre ai nomi dei file che sono stati modificati, mostra anche le modifiche testuali che vengono messe in scena per il commit (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 es. Come l'output di git diff).

git status 

darà anche il nome del ramo insieme alle modifiche.

per esempio

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

Nel tempo, potremmo avere un elenco molto lungo di filiali.

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

git branch | grep \*

Adesso,

git status

funziona, ma solo se ci sono cambiamenti locali

Consiglio 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

O (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 del controllo delle versioni siano abilitate (Visualizza -> Mostra etichette controllo versioni). È quindi possibile visualizzare 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/##"

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

#!/bin/bash

git branch | grep -e "^*"

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

Quindi ora quando sono in un repository git, semplicemente digito git cbrper stampare il nome del ramo corrente.

$ git cbr
* master

Questo funziona perché il gitcomando prende il suo primo argomento e tenta di eseguire uno script che si chiama git-arg1. Ad esempio, git branchprova a eseguire uno script chiamato git-branch, ecc.

È possibile impostare in modo permanente l'output di bash per mostrare il nome del proprio ramo git. È molto utile quando si lavora con rami diversi, non è necessario digitare $ git statussempre. 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 sudo nano ~/.bashrccomando (per Ubuntu) e aggiungi quanto segue all'inizio:

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

Quindi incolla il codice

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

alla fine dello stesso file hai incollato il codice di installazione in precedenza. Questo ti darà l'output colorato:

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

git branch | grep ^\*

Quando non vuoi digitare quel lungo comando 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 * masterquanto segue.

$ cb
* master

Restituisce il nome del ramo o SHA1 quando si è sulla testa 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.

Se vuoi davvero che l'ultimo ramo / tag sia estratto anche nello stato 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 è in ritardo, ma su un Linux / Mac, dal terminale è possibile utilizzare quanto segue.

git status | sed -n 1p

Spiegazione:

git status -> ottiene lo stato dell'albero di lavoro
sed -n 1p -> ottiene la prima riga dal corpo dello stato

La risposta al comando sopra apparirà come segue:

"On branch your_branch_name"

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 nei tuoi script:

GIT_COMMIT - SHA della corrente

GIT_BRANCH - Nome della filiale attualmente in uso, ad esempio "master" o "origin / foo"

GIT_PREVIOUS_COMMIT - SHA del commit precedente creato dallo stesso ramo (l'attuale SHA al primo build nel ramo)

GIT_URL - URL remoto del repository

GIT_URL_N - URL remoti del repository quando ci sono più di 1 telecomandi, ad esempio GIT_URL_1, GIT_URL_2

GIT_AUTHOR_EMAIL - Email committer / autore

GIT_COMMITTER_EMAIL - Email committer / autore

Aggiungilo PS1all'utilizzo del Mac:

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

Prima di eseguire il comando sopra:

Dopo aver eseguito quel comando:

Non preoccuparti, se non è un repository GIT, non visualizzerà errori a causa dei [-d .git]quali controlla se la .gitcartella esiste o meno.