Como recuperar o hash para o commit atual no Git?

Gostaria de manter (por enquanto) a capacidade de vincular conjuntos de alterações do Git a itens de trabalho armazenados no TFS.

Eu já escrevi uma ferramenta (usando um gancho do Git) na qual posso injetar identificadores de trabalho na mensagem de um conjunto de alterações do Git.

No entanto, eu também gostaria de armazenar o identificador do commit do Git (o hash) em um campo de item de trabalho TFS personalizado. Dessa forma, posso examinar um item de trabalho no TFS e ver quais conjuntos de alterações do Git estão associados ao item de trabalho.

Como posso recuperar facilmente o hash do commit atual do Git?

Para transformar referência arbitrária de objeto estendido em SHA-1, use simplesmente git-rev-parse , por exemplo

git rev-parse HEAD

ou

git rev-parse --verify HEAD

Nota: Se você deseja transformar referências ( ramificações e tags ) em SHA-1, existegit show-refegit for-each-ref.

Se você deseja apenas o hash reduzido:

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

Além disso, o uso de% H é outra maneira de obter o hash longo.

Outro, usando o git log:

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

É muito semelhante ao da @outofculture, embora um pouco mais curto.

Para obter o SHA completo:

$ git rev-parse HEAD
cbf1b9a1be984a9f61b79a05f23b19f66d533537

Para obter a versão abreviada:

$ git rev-parse --short HEAD
cbf1b9a

Para ser completo, já que ninguém o sugeriu ainda. .git/refs/heads/masteré um arquivo que contém apenas uma linha: o hash da confirmação mais recente emmaster . Então você pode ler a partir daí.

Ou, como comando:

cat .git/refs/heads/master

Atualizar:

Note que o git agora suporta o armazenamento de algumas referências de cabeça no arquivo pack-ref em vez de como um arquivo na pasta / refs / heads /. https://www.kernel.org/pub/software/scm/git/docs/git-pack-refs.html

Confirmar hash

git show -s --format=%H

Hash de confirmação abreviado

git show -s --format=%h

Clique aqui para mais git showexemplos.

Sempre há git describetambém. Por padrão, ele fornece -

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

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

Se você precisar armazenar o hash em uma variável durante um script, poderá usar

last_commit=$(git rev-parse HEAD)

Ou, se você quiser apenas os 10 primeiros caracteres (como o github.com)

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

Se você quiser uma maneira super hacky de fazer isso:

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

Basicamente, o git armazena a localização do HEAD em .git / HEAD, no formato ref: {path from .git} . Este comando lê isso, corta o "ref:" e lê o arquivo que ele apontou.

Isso, é claro, falhará no modo de cabeça destacada, pois HEAD não será "ref: ...", mas o próprio hash - mas você sabe, eu não acho que você espere tanta inteligência em seu bash. forros. Se você não acha que ponto e vírgula estão trapaceando, ...

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

A maneira mais sucinta que eu conheço:

git show --pretty=%h 

Se você deseja um número específico de dígitos do hash, pode adicionar:

--abbrev=n

Talvez você queira um pseudônimo para não precisar se lembrar de todos os detalhes bacanas. Depois de executar uma das etapas abaixo, você poderá digitar simplesmente:

$ git lastcommit
49c03fc679ab11534e1b4b35687b1225c365c630

Seguindo a resposta aceita , aqui estão duas maneiras de configurar isso:

1) Ensine o git da maneira explícita editando a configuração global (minha resposta original):

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

2) Ou se você gosta de um atalho para ensinar ao git um atalho, como recentemente comentado por Adrien:

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

A partir daqui, use git lastcommitpara mostrar o hash do último commit.

Eu precisava de algo um pouco mais diferente: exibir o sha1 completo do commit, mas anexar um asterisco ao final se o diretório de trabalho não estiver limpo. A menos que eu queira usar vários comandos, nenhuma das opções nas respostas anteriores funciona.

Aqui está o liner que faz:
git describe --always --abbrev=0 --match "NOT A TAG" --dirty="*"
Resultado:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe*

Explicação: descreve (usando tags anotadas) a confirmação atual, mas apenas com tags que contêm "NOT A TAG". Como as tags não podem ter espaços, isso nunca corresponde a uma tag e, como queremos mostrar um resultado --always, o comando retorna exibindo o --abbrev=0sha1 completo ( ) do commit e acrescenta um asterisco se o diretório de trabalho estiver --dirty.

Se você não deseja anexar o asterisco, isso funciona como todos os outros comandos nas respostas anteriores:
git describe --always --abbrev=0 --match "NOT A TAG"
Resultado:f5366ccb21588c0d7a5f7d9fa1d3f85e9f9d1ffe

git show-ref --head --hash head

Se você está buscando velocidade, a abordagem mencionada por Deestan

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

é significativamente mais rápido que qualquer outro método listado aqui até agora.

Aqui está uma linha no shell Bash usando a leitura direta de arquivos git:

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

^{Você precisa executar o comando acima na sua pasta raiz do git.}

Este método pode ser útil quando você tiver arquivos de repositório, mas o gitcomando não foi instalado.

Se não funcionar, verifique na .git/refs/headspasta que tipo de cabeça você possui.

no diretório home no arquivo ".gitconfig", adicione o seguinte

[alias]
sha = rev-parse HEAD

então você terá um comando mais fácil de lembrar:

$ git sha
59fbfdbadb43ad0b6154c982c997041e9e53b600

No git bash, basta executar $ git log -1

você verá essas linhas seguindo seu comando.

commit d25c95d88a5e8b7e15ba6c925a1631a5357095db .. (info about your head)

d25c95d88a5e8b7e15ba6c925a1631a5357095db, is your SHA for last commit.

Aqui está outra implementação de acesso direto:

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

Isso também funciona com http, o que é útil para arquivos de pacotes locais (eu sei: para sites públicos, não é recomendável tornar o diretório .git acessível):

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

Aqui está outra maneira de fazê-lo com :)

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

cat .git/HEAD

Exemplo de saída:

ref: refs/heads/master

Analise:

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

Se você possui janelas, considere usar o wsl.exe:

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

Resultado:

refs/heads/master

Esse valor pode ser usado para git checkout mais tarde, mas fica apontando para seu SHA. Para fazê-lo apontar para a ramificação atual real por seu nome, faça:

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

Saídas:

master