¿Cómo recuperar el hash para el commit actual en Git?

Me gustaría conservar (por ahora) la capacidad de vincular los conjuntos de cambios de Git a los elementos de trabajo almacenados en TFS.

Ya escribí una herramienta (usando un gancho de Git) en la que puedo inyectar identificadores de trabajo en el mensaje de un conjunto de cambios de Git.

Sin embargo, también me gustaría almacenar el identificador de la confirmación Git (el hash) en un campo de elemento de trabajo TFS personalizado. De esta forma puedo examinar un elemento de trabajo en TFS y ver qué conjuntos de cambios de Git están asociados con el elemento de trabajo.

¿Cómo puedo recuperar fácilmente el hash del commit actual de Git?

Para convertir la referencia arbitraria de objetos extendidos en SHA-1, use simplemente git-rev-parse , por ejemplo

git rev-parse HEAD

o

git rev-parse --verify HEAD

Nota al margen: si desea convertir las referencias ( ramas y etiquetas ) en SHA-1, haygit show-refygit for-each-ref.

Si solo quieres el hash acortado:

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

Además, usar% H es otra forma de obtener el hash largo.

Otro, usando git log:

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

Es muy similar al de @outofculture, aunque un poco más corto.

Para obtener el SHA completo:

$ git rev-parse HEAD
cbf1b9a1be984a9f61b79a05f23b19f66d533537

Para obtener la versión abreviada:

$ git rev-parse --short HEAD
cbf1b9a

Para completar, ya que nadie lo ha sugerido todavía. .git/refs/heads/masteres un archivo que contiene solo una línea: el hash de la última confirmación master. Entonces puedes leerlo desde allí.

O, como comando:

cat .git/refs/heads/master

Actualizar:

Tenga en cuenta que git ahora admite el almacenamiento de algunas referencias de cabeza en el archivo pack-ref en lugar de como un archivo en la carpeta / refs / heads /. https://www.kernel.org/pub/software/scm/git/docs/git-pack-refs.html

Cometer hash

git show -s --format=%H

Comportamiento abreviado hash

git show -s --format=%h

Haga clic aquí para más git showejemplos.

Siempre hay git describetambién. Por defecto te da -

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

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

Si necesita almacenar el hash en una variable durante un script, puede usar

last_commit=$(git rev-parse HEAD)

O, si solo quieres los primeros 10 caracteres (como lo hace github.com)

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

Si quieres la forma súper hacky de hacerlo:

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

Básicamente, git almacena la ubicación de HEAD en .git / HEAD, en el formulario ref: {path from .git}. Este comando lee eso, corta el "ref:" y lee cualquier archivo al que apunte.

Esto, por supuesto, fallará en el modo de cabeza separada, ya que HEAD no será "ref: ...", sino el hash en sí mismo, pero ya sabes, no creo que esperes tanta inteligencia en tu golpe. -liners. Sin embargo, si no crees que el punto y coma son trampas ...

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

La forma más sucinta que conozco:

git show --pretty=%h 

Si desea un número específico de dígitos del hash, puede agregar:

--abbrev=n

Quizás desee un alias para no tener que recordar todos los detalles ingeniosos. Después de realizar uno de los pasos a continuación, simplemente podrá escribir:

$ git lastcommit
49c03fc679ab11534e1b4b35687b1225c365c630

Después de la respuesta aceptada , aquí hay dos formas de configurar esto:

1) Enseñe a git de manera explícita editando la configuración global (mi respuesta original):

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

2) O si le gusta un atajo para enseñarle un atajo, como comentó recientemente Adrien:

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

De aquí en adelante, use git lastcommitpara mostrar el hash del último commit.

Necesitaba algo un poco más diferente: mostrar el sha1 completo de la confirmación, pero agregue un asterisco al final si el directorio de trabajo no está limpio. A menos que quiera usar varios comandos, ninguna de las opciones en las respuestas anteriores funciona.

Aquí está el único revestimiento que hace:
git describe --always --abbrev=0 --match "NOT A TAG" --dirty="*"
Resultado:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe*

Explicación: describe (usando etiquetas anotadas) el commit actual, pero solo con etiquetas que contienen "NOT A TAG". Como las etiquetas no pueden tener espacios, esto nunca coincide con una etiqueta y dado que queremos mostrar un resultado --always, el comando retrocede mostrando el --abbrev=0sha1 completo ( ) de la confirmación y agrega un asterisco si el directorio de trabajo lo es --dirty.

Si no desea agregar el asterisco, esto funciona como todos los otros comandos en las respuestas anteriores:
git describe --always --abbrev=0 --match "NOT A TAG"
Resultado:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe

git show-ref --head --hash head

Si vas por la velocidad, el enfoque mencionado por Deestan

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

es significativamente más rápido que cualquier otro método enumerado aquí hasta ahora.

Aquí hay una línea en el shell Bash que usa lectura directa de archivos git:

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

^{Debe ejecutar el comando anterior en su carpeta raíz git.}

Este método puede ser útil cuando tiene archivos de repositorio, pero el gitcomando no se ha instalado.

Si no funciona, verifique en la .git/refs/headscarpeta qué tipo de cabezas tiene presente.

en su directorio de inicio en el archivo ".gitconfig" agregue lo siguiente

[alias]
sha = rev-parse HEAD

entonces tendrás un comando más fácil de recordar:

$ git sha
59fbfdbadb43ad0b6154c982c997041e9e53b600

En git bash, simplemente ejecute $ git log -1

verá, estas líneas siguiendo su comando.

commit d25c95d88a5e8b7e15ba6c925a1631a5357095db .. (info about your head)

d25c95d88a5e8b7e15ba6c925a1631a5357095db, is your SHA for last commit.

Aquí hay otra implementación de acceso directo:

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

Esto también funciona sobre http, que es útil para archivos de paquetes locales (lo sé: para sitios web públicos no se recomienda hacer accesible el directorio .git):

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

Aquí hay otra forma de hacerlo :)

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

cat .git/HEAD

Salida de ejemplo:

ref: refs/heads/master

Analízalo:

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

Si tiene Windows, entonces puede considerar usar wsl.exe:

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

Salida:

refs/heads/master

Este valor puede usarse para git checkout más tarde, pero se convierte en apuntando a su SHA. Para que apunte a la rama actual actual por su nombre, haga lo siguiente:

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

Salidas:

master