branch checkout - Come ottenere il nome attuale del ramo in Git?




pull commit (25)

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.


Answers

Che dire di questo?

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

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.


Un'altra alternativa:

git name-rev --name-only HEAD

Per visualizzare il ramo corrente su cui ti trovi, senza gli altri rami elencati, puoi fare quanto segue:

git rev-parse --abbrev-ref HEAD

Riferimento:

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

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

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

Una versione meno rumorosa per lo stato git farebbe il trucco

git status -bsuno

Si stampa

## branch-name

git status 

fornirà anche il nome del ramo insieme alle modifiche.

per esempio

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

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

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.


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


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

Per copiare direttamente il risultato sul tavolo di montaggio. Grazie a @ olivier-refalo per l'inizio ...


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!


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"


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

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:


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

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.


è possibile 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).


Aggiungilo a PS1 usando Mac:

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

Prima di eseguire il comando sopra:

Dopo aver eseguito questo comando:

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.


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


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


Per rimuovere nuovi file dall'area di gestione temporanea (e solo in caso di un nuovo file), come suggerito sopra:

git rm --cached FILE

Usa rm --cached solo per i nuovi file aggiunti per sbaglio.





git branch git-branch