Comment récupérer le hachage pour le commit actuel dans Git?

Je voudrais conserver (pour l'instant) la possibilité de lier les ensembles de modifications Git aux éléments de travail stockés dans TFS.

J'ai déjà écrit un outil (en utilisant un hook de Git) dans lequel je peux injecter des identifiants de travail dans le message d'un changeset Git.

Cependant, je voudrais également stocker l'identifiant de la validation Git (le hachage) dans un champ d'élément de travail TFS personnalisé. De cette façon, je peux examiner un élément de travail dans TFS et voir quels ensembles de modifications Git sont associés à l'élément de travail.

Comment puis-je récupérer facilement le hachage à partir du commit actuel de Git?

Pour transformer une référence d'objet étendu arbitraire en SHA-1, utilisez simplement git-rev-parse , par exemple

git rev-parse HEAD

ou

git rev-parse --verify HEAD

Sidenote: Si vous voulez transformer des références ( branches et balises ) en SHA-1, il y agit show-refetgit for-each-ref.

Si vous souhaitez uniquement le hachage raccourci:

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

De plus, l'utilisation de% H est une autre façon d'obtenir le long hachage.

Un autre, en utilisant git log:

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

Il est très similaire à celui de @outofculture mais un peu plus court.

Pour obtenir le SHA complet:

$ git rev-parse HEAD
cbf1b9a1be984a9f61b79a05f23b19f66d533537

Pour obtenir la version raccourcie:

$ git rev-parse --short HEAD
cbf1b9a

Pour être complet, puisque personne ne l'a encore suggéré. .git/refs/heads/masterest un fichier qui ne contient qu'une seule ligne: le hachage du dernier commit sur master. Vous pouvez donc le lire à partir de là.

Ou, comme commande:

cat .git/refs/heads/master

Mise à jour:

Notez que git prend désormais en charge le stockage de certaines références de tête dans le fichier pack-ref au lieu d'un fichier dans le dossier / refs / heads /. https://www.kernel.org/pub/software/scm/git/docs/git-pack-refs.html

Valider le hachage

git show -s --format=%H

Hachage de validation abrégé

git show -s --format=%h

Cliquez ici pour plus d' git showexemples.

Il y en a toujours git describeaussi. Par défaut, cela vous donne -

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

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

Si vous devez stocker le hachage dans une variable pendant un script, vous pouvez utiliser

last_commit=$(git rev-parse HEAD)

Ou, si vous ne voulez que les 10 premiers caractères (comme le fait github.com)

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

Si vous voulez le faire de manière super-hacky:

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

Fondamentalement, git stocke l'emplacement de HEAD dans .git / HEAD, sous la forme ref: {path from .git}. Cette commande lit cela, supprime le "ref:" et lit le fichier vers lequel il pointait.

Bien sûr, cela échouera en mode tête détachée, car HEAD ne sera pas "ref: ...", mais le hachage lui-même - mais vous savez, je ne pense pas que vous vous attendiez à autant d'intelligence dans votre bash one -liner. Si vous ne pensez pas que les points-virgules trichent, cependant ...

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

La manière la plus succincte que je connaisse:

git show --pretty=%h 

Si vous voulez un nombre spécifique de chiffres du hachage, vous pouvez ajouter:

--abbrev=n

Peut-être que vous voulez un alias pour ne pas avoir à vous souvenir de tous les détails astucieux. Après avoir effectué l'une des étapes ci-dessous, vous pourrez simplement taper:

$ git lastcommit
49c03fc679ab11534e1b4b35687b1225c365c630

Pour donner suite à la réponse acceptée , voici deux façons de procéder:

1) Apprenez à git de manière explicite en éditant la configuration globale (ma réponse d'origine):

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

2) Ou si vous aimez un raccourci pour enseigner à git un raccourci, comme l'a récemment commenté Adrien:

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

À partir de là, utilisez git lastcommitpour afficher le hachage du dernier commit.

J'avais besoin de quelque chose d'un peu plus différent: afficher le sha1 complet du commit, mais ajouter un astérisque à la fin si le répertoire de travail n'est pas propre. À moins que je veuille utiliser plusieurs commandes, aucune des options des réponses précédentes ne fonctionne.

Voici la doublure qui le fait:
git describe --always --abbrev=0 --match "NOT A TAG" --dirty="*"
Résultat:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe*

Explication: décrit (à l'aide de balises annotées) la validation actuelle, mais uniquement avec des balises contenant "NOT A TAG". Étant donné que les balises ne peuvent pas avoir d'espaces, cela ne correspond jamais à une balise et puisque nous voulons afficher un résultat --always, la commande revient à afficher le full ( --abbrev=0) sha1 du commit et elle ajoute un astérisque si le répertoire de travail l'est --dirty.

Si vous ne souhaitez pas ajouter l'astérisque, cela fonctionne comme toutes les autres commandes des réponses précédentes:
git describe --always --abbrev=0 --match "NOT A TAG"
Résultat:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe

git show-ref --head --hash head

Si vous optez pour la vitesse, l'approche mentionnée par Deestan

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

est nettement plus rapide que toute autre méthode répertoriée ici jusqu'à présent.

Voici une ligne dans le shell Bash utilisant la lecture directe à partir de fichiers git:

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

^{Vous devez exécuter la commande ci-dessus dans votre dossier racine git.}

Cette méthode peut être utile lorsque vous avez des fichiers de référentiel, mais que la gitcommande n'a pas été installée.

Si cela ne fonctionne pas, vérifiez dans le .git/refs/headsdossier quel type de têtes avez-vous présent.

dans votre répertoire personnel dans le fichier ".gitconfig", ajoutez ce qui suit

[alias]
sha = rev-parse HEAD

alors vous aurez une commande plus facile à retenir:

$ git sha
59fbfdbadb43ad0b6154c982c997041e9e53b600

Sur git bash, exécutez simplement $ git log -1

vous verrez, ces lignes suivant votre commande.

commit d25c95d88a5e8b7e15ba6c925a1631a5357095db .. (info about your head)

d25c95d88a5e8b7e15ba6c925a1631a5357095db, is your SHA for last commit.

Voici une autre implémentation à accès direct:

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

Cela fonctionne également sur http, ce qui est utile pour les archives de paquets locaux (je sais: pour les sites Web publics, il n'est pas recommandé de rendre le répertoire .git accessible):

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

Voici une autre façon de le faire avec :)

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

cat .git/HEAD

Exemple de sortie:

ref: refs/heads/master

Analysez-le:

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

Si vous avez des fenêtres, vous pouvez envisager d'utiliser wsl.exe:

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

Production:

refs/heads/master

Cette valeur peut être utilisée pour git checkout plus tard, mais elle pointe vers son SHA. Pour faire pointer vers la branche actuelle réelle par son nom, procédez comme suit:

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

Les sorties:

master