Come recuperare l'hash per il commit corrente in Git?

Vorrei conservare (per ora) la possibilità di collegare i changeset Git ai workitem memorizzati in TFS.

Ho già scritto uno strumento (usando un hook di Git) in cui posso iniettare identificatori di lavoro nel messaggio di un changeset di Git.

Tuttavia, vorrei anche memorizzare l'identificatore del commit Git (l'hash) in un campo di lavoro TFS personalizzato. In questo modo posso esaminare un workitem in TFS e vedere quali cambiamenti Git sono associati al workitem.

Come posso recuperare facilmente l'hash dall'attuale commit da Git?

Per trasformare il riferimento arbitrario di oggetti estesi in SHA-1 , ad esempio , utilizzare semplicemente git-rev-parse

git rev-parse HEAD

o

git rev-parse --verify HEAD

Sidenote: se vuoi trasformare riferimenti ( rami e tag ) in SHA-1, c'ègit show-refegit for-each-ref.

Se vuoi solo l'hash abbreviato:

git log --pretty=format:'%h' -n 1

Inoltre, usare% H è un altro modo per ottenere l'hash lungo.

Un altro, usando git log:

git log -1 --format="%H"

È molto simile a @outofculture anche se un po 'più breve.

Per ottenere lo SHA completo:

$ git rev-parse HEAD
cbf1b9a1be984a9f61b79a05f23b19f66d533537

Per ottenere la versione abbreviata:

$ git rev-parse --short HEAD
cbf1b9a

Per completezza, dal momento che nessuno lo ha ancora suggerito. .git/refs/heads/masterè un file che contiene solo una riga: l'hash dell'ultimo commit su master. Quindi puoi leggerlo da lì.

Oppure, come comando:

cat .git/refs/heads/master

Aggiornare:

Si noti che git ora supporta la memorizzazione di alcuni riferimenti head nel file pack-ref anziché come file nella cartella / refs / heads /. https://www.kernel.org/pub/software/scm/git/docs/git-pack-refs.html

Commettere l'hash

git show -s --format=%H

Hash di commit abbreviato

git show -s --format=%h

Clicca qui per altri git showesempi.

C'è sempre git describeanche. Di default ti dà -

john@eleanor:/dev/shm/mpd/ncmpc/pkg (master)$ git describe --always
release-0.19-11-g7a68a75

Uso git rev-list --max-count=1 HEAD

Se è necessario memorizzare l'hash in una variabile durante uno script, è possibile utilizzare

last_commit=$(git rev-parse HEAD)

Oppure, se vuoi solo i primi 10 caratteri (come fa github.com)

last_commit=$(git rev-parse HEAD | cut -c1-10) 

Se vuoi il modo super-hacky per farlo:

cat .git/`cat .git/HEAD | cut -d \  -f 2`

Fondamentalmente, git memorizza la posizione di HEAD in .git / HEAD, nel modulo ref: {path from .git}. Questo comando lo legge, taglia "ref:" e legge qualunque file abbia indicato.

Questo, ovviamente, fallirà in modalità a testa staccata, poiché HEAD non sarà "ref: ...", ma l'hash stesso - ma sai, non penso che ti aspetti che tanta intelligenza nella tua bash -liners. Se non pensi che i punti e virgola stiano tradendo, però ...

HASH="ref: HEAD"; while [[ $HASH == ref\:* ]]; do HASH="$(cat ".git/$(echo $HASH | cut -d \  -f 2)")"; done; echo $HASH

Il modo più conciso che conosco:

git show --pretty=%h 

Se vuoi un numero specifico di cifre dell'hash puoi aggiungere:

--abbrev=n

Forse vuoi un alias in modo da non dover ricordare tutti i dettagli eleganti. Dopo aver eseguito uno dei passaggi seguenti, sarai in grado di digitare semplicemente:

$ git lastcommit
49c03fc679ab11534e1b4b35687b1225c365c630

Seguendo la risposta accettata , ecco due modi per impostare questo:

1) Insegna a git in modo esplicito modificando la configurazione globale (la mia risposta originale):

 # open the git config editor
 $ git config --global --edit
 # in the alias section, add
 ...
 [alias]
   lastcommit = rev-parse HEAD
 ...

2) O se ti piace una scorciatoia per insegnare a git una scorciatoia, come recentemente commentato da Adrien:

$ git config --global alias.lastcommit "rev-parse HEAD"

Da qui in poi, usa git lastcommitper mostrare l'hash dell'ultimo commit.

Avevo bisogno di qualcosa di un po 'più diverso: visualizzare l'intero sha1 del commit, ma aggiungere un asterisco alla fine se la directory di lavoro non è pulita. A meno che non volessi usare più comandi, nessuna delle opzioni nelle risposte precedenti funziona.

Ecco quello che fa:
git describe --always --abbrev=0 --match "NOT A TAG" --dirty="*"
Risultato:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe*

Spiegazione: descrive (utilizzando tag annotati) il commit corrente, ma solo con tag contenenti "NOT A TAG". Poiché i tag non possono avere spazi, questo non corrisponde mai a un tag e poiché vogliamo mostrare un risultato --always, il comando ricade indietro visualizzando l'intero ( --abbrev=0) sha1 del commit e aggiunge un asterisco se la directory di lavoro è --dirty.

Se non si desidera aggiungere l'asterisco, funziona come tutti gli altri comandi nelle risposte precedenti:
git describe --always --abbrev=0 --match "NOT A TAG"
Risultato:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe

git show-ref --head --hash head

Se stai andando per la velocità, l'approccio citato da Deestan

cat .git/refs/heads/<branch-name>

è significativamente più veloce di qualsiasi altro metodo elencato qui finora.

Ecco una riga nella shell Bash usando la lettura diretta dai file git:

(head=($(<.git/HEAD)); cat .git/${head[1]})

^{Devi eseguire il comando sopra nella cartella principale di git.}

Questo metodo può essere utile quando hai file di repository, ma il gitcomando non è stato installato.

Se non funziona, controlla nella .git/refs/headscartella che tipo di teste hai presente.

nella tua home-dir nel file ".gitconfig" aggiungi quanto segue

[alias]
sha = rev-parse HEAD

allora avrai un comando più facile da ricordare:

$ git sha
59fbfdbadb43ad0b6154c982c997041e9e53b600

Su git bash, esegui semplicemente $ git log -1

vedrai che queste righe seguono il tuo comando.

commit d25c95d88a5e8b7e15ba6c925a1631a5357095db .. (info about your head)

d25c95d88a5e8b7e15ba6c925a1631a5357095db, is your SHA for last commit.

Ecco un'altra implementazione ad accesso diretto:

head="$(cat ".git/HEAD")"
while [ "$head" != "${head#ref: }" ]; do
  head="$(cat ".git/${head#ref: }")"
done

Questo funziona anche su http che è utile per gli archivi di pacchetti locali (lo so: per i siti Web pubblici non è consigliabile rendere accessibile la directory .git):

head="$(curl -s "$baseurl/.git/HEAD")"
while [ "$head" != "${head#ref: }" ]; do
  head="$(curl -s "$baseurl/.git/${head#ref: }")"
done

Ecco un altro modo di farlo con :)

git log | grep -o '\w\{8,\}' | head -n 1

cat .git/HEAD

Esempio di output:

ref: refs/heads/master

Analizzalo:

cat .git/HEAD | sed "s/^.\+ \(.\+\)$/\1/g"

Se hai Windows, puoi prendere in considerazione l'utilizzo di wsl.exe:

wsl cat .git/HEAD | wsl sed "s/^.\+ \(.\+\)$/\1/g"

Produzione:

refs/heads/master

Questo valore può essere utilizzato per eseguire il checkout in un secondo momento, ma diventa puntato al suo SHA. Per farlo puntare all'attuale ramo attuale con il suo nome fai:

wsl cat .git/HEAD | wsl sed "s/^.\+ \(.\+\)$/\1/g" | wsl sed "s/^refs\///g" | wsl sed "s/^heads\///g"

Uscite:

master